377 lines
12 KiB
QML
377 lines
12 KiB
QML
pragma Singleton
|
|
|
|
import QtQuick
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import qs.Commons
|
|
import qs.Services
|
|
import Quickshell.Services.Notifications
|
|
|
|
Singleton {
|
|
id: root
|
|
|
|
// Notification server instance
|
|
property NotificationServer server: NotificationServer {
|
|
id: notificationServer
|
|
|
|
// Server capabilities
|
|
keepOnReload: false
|
|
imageSupported: true
|
|
actionsSupported: true
|
|
actionIconsSupported: true
|
|
bodyMarkupSupported: true
|
|
bodySupported: true
|
|
persistenceSupported: true
|
|
inlineReplySupported: true
|
|
bodyHyperlinksSupported: true
|
|
bodyImagesSupported: true
|
|
|
|
// Signal when notification is received
|
|
onNotification: function (notification) {
|
|
// Always add notification to history
|
|
root.addToHistory(notification)
|
|
|
|
// Check if do-not-disturb is enabled
|
|
if (Settings.data.notifications && Settings.data.notifications.doNotDisturb) {
|
|
return
|
|
}
|
|
|
|
// Track the notification
|
|
notification.tracked = true
|
|
|
|
// Connect to closed signal for cleanup
|
|
notification.closed.connect(function () {
|
|
root.removeNotification(notification)
|
|
})
|
|
|
|
// Add to our model
|
|
root.addNotification(notification)
|
|
}
|
|
}
|
|
|
|
// List model to hold notifications
|
|
property ListModel notificationModel: ListModel {}
|
|
|
|
// Persistent history of notifications (most recent first)
|
|
property ListModel historyModel: ListModel {}
|
|
property int maxHistory: 100
|
|
|
|
// Cached history file path
|
|
property string historyFile: Quickshell.env("NOCTALIA_NOTIF_HISTORY_FILE") || (Settings.cacheDir + "notifications.json")
|
|
|
|
// Persisted storage for history
|
|
property FileView historyFileView: FileView {
|
|
id: historyFileView
|
|
objectName: "notificationHistoryFileView"
|
|
path: historyFile
|
|
printErrors: false
|
|
watchChanges: true
|
|
onFileChanged: reload()
|
|
onAdapterUpdated: writeAdapter()
|
|
Component.onCompleted: reload()
|
|
onLoaded: loadFromHistory()
|
|
onLoadFailed: function (error) {
|
|
// Create file on first use
|
|
if (error.toString().includes("No such file") || error === 2) {
|
|
writeAdapter()
|
|
}
|
|
}
|
|
|
|
JsonAdapter {
|
|
id: historyAdapter
|
|
property var history: []
|
|
property real timestamp: 0
|
|
}
|
|
}
|
|
|
|
// Maximum visible notifications
|
|
property int maxVisible: 5
|
|
|
|
// Function to get duration based on urgency
|
|
function getDurationForUrgency(urgency) {
|
|
switch (urgency) {
|
|
case 0:
|
|
// Low urgency
|
|
return (Settings.data.notifications.lowUrgencyDuration || 3) * 1000
|
|
case 1:
|
|
// Normal urgency
|
|
return (Settings.data.notifications.normalUrgencyDuration || 8) * 1000
|
|
case 2:
|
|
// Critical urgency
|
|
return (Settings.data.notifications.criticalUrgencyDuration || 15) * 1000
|
|
default:
|
|
return (Settings.data.notifications.normalUrgencyDuration || 8) * 1000
|
|
}
|
|
}
|
|
|
|
// Auto-hide timer
|
|
property Timer hideTimer: Timer {
|
|
interval: 1000 // Check every second
|
|
repeat: true
|
|
running: notificationModel.count > 0
|
|
|
|
onTriggered: {
|
|
if (notificationModel.count === 0) {
|
|
return
|
|
}
|
|
|
|
// Check each notification for expiration
|
|
for (var i = notificationModel.count - 1; i >= 0; i--) {
|
|
let notificationData = notificationModel.get(i)
|
|
if (notificationData && notificationData.rawNotification) {
|
|
let notification = notificationData.rawNotification
|
|
let urgency = notificationData.urgency
|
|
let timestamp = notificationData.timestamp
|
|
|
|
// Calculate if this notification should be removed
|
|
let duration = getDurationForUrgency(urgency)
|
|
let now = new Date()
|
|
let elapsed = now.getTime() - timestamp.getTime()
|
|
|
|
if (elapsed >= duration) {
|
|
// Trigger animation signal instead of direct dismiss
|
|
animateAndRemove(notification, i)
|
|
break
|
|
// Only remove one notification per check to avoid conflicts
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: Settings.data.notifications
|
|
function onDoNotDisturbChanged() {
|
|
const label = Settings.data.notifications.doNotDisturb ? "'Do Not Disturb' enabled" : "'Do Not Disturb' disabled"
|
|
const description = Settings.data.notifications.doNotDisturb ? "You'll find these notifications in your history." : "Showing all notifications."
|
|
ToastService.showNotice(label, description)
|
|
}
|
|
}
|
|
|
|
// Function to resolve app name from notification
|
|
function resolveAppName(notification) {
|
|
try {
|
|
const appName = notification.appName || ""
|
|
|
|
// If it's already a clean name (no dots or reverse domain notation), use it
|
|
if (!appName.includes(".") || appName.length < 10) {
|
|
return appName
|
|
}
|
|
|
|
// Try to find a desktop entry for this app ID
|
|
const desktopEntries = DesktopEntries.byId(appName)
|
|
if (desktopEntries && desktopEntries.length > 0) {
|
|
const entry = desktopEntries[0]
|
|
// Prefer name over genericName, fallback to original appName
|
|
return entry.name || entry.genericName || appName
|
|
}
|
|
|
|
// If no desktop entry found, try to clean up the app ID
|
|
// Convert "org.gnome.Nautilus" to "Nautilus"
|
|
const parts = appName.split(".")
|
|
if (parts.length > 1) {
|
|
// Take the last part and capitalize it
|
|
const lastPart = parts[parts.length - 1]
|
|
return lastPart.charAt(0).toUpperCase() + lastPart.slice(1)
|
|
}
|
|
|
|
return appName
|
|
} catch (e) {
|
|
// Fallback to original app name on any error
|
|
return notification.appName || ""
|
|
}
|
|
}
|
|
|
|
// Function to add notification to model
|
|
function addNotification(notification) {
|
|
const resolvedImage = resolveNotificationImage(notification)
|
|
const resolvedAppName = resolveAppName(notification)
|
|
|
|
notificationModel.insert(0, {
|
|
"rawNotification": notification,
|
|
"summary": notification.summary,
|
|
"body": notification.body,
|
|
"appName": resolvedAppName,
|
|
"desktopEntry": notification.desktopEntry,
|
|
"image": resolvedImage,
|
|
"appIcon": notification.appIcon,
|
|
"urgency": notification.urgency,
|
|
"timestamp": new Date()
|
|
})
|
|
|
|
// Remove oldest notifications if we exceed maxVisible
|
|
while (notificationModel.count > maxVisible) {
|
|
let oldestNotification = notificationModel.get(notificationModel.count - 1).rawNotification
|
|
if (oldestNotification) {
|
|
oldestNotification.dismiss()
|
|
}
|
|
notificationModel.remove(notificationModel.count - 1)
|
|
}
|
|
}
|
|
|
|
// Resolve an image path for a notification, supporting icon names and absolute paths
|
|
function resolveNotificationImage(notification) {
|
|
try {
|
|
// If an explicit image is already provided, prefer it
|
|
if (notification && notification.image && notification.image !== "") {
|
|
return notification.image
|
|
}
|
|
|
|
// Fallback to appIcon which may be a name or a path (notify-send -i)
|
|
const icon = notification ? (notification.appIcon || "") : ""
|
|
if (!icon)
|
|
return ""
|
|
|
|
// Accept absolute file paths or file URLs directly
|
|
if (icon.startsWith("/")) {
|
|
return icon
|
|
}
|
|
if (icon.startsWith("file://")) {
|
|
// Strip the scheme for QML image source compatibility
|
|
return icon.substring("file://".length)
|
|
}
|
|
|
|
// Resolve themed icon names to absolute paths
|
|
try {
|
|
const p = AppIcons.iconFromName(icon, "")
|
|
return p || ""
|
|
} catch (e2) {
|
|
return ""
|
|
}
|
|
} catch (e) {
|
|
return ""
|
|
}
|
|
}
|
|
|
|
function addToHistory(notification) {
|
|
const resolvedAppName = resolveAppName(notification)
|
|
const resolvedImage = resolveNotificationImage(notification)
|
|
|
|
historyModel.insert(0, {
|
|
"summary": notification.summary,
|
|
"body": notification.body,
|
|
"appName": resolvedAppName,
|
|
"desktopEntry": notification.desktopEntry || "",
|
|
"image": resolvedImage,
|
|
"appIcon": notification.appIcon || "",
|
|
"urgency": notification.urgency,
|
|
"timestamp": new Date()
|
|
})
|
|
while (historyModel.count > maxHistory) {
|
|
historyModel.remove(historyModel.count - 1)
|
|
}
|
|
saveHistory()
|
|
}
|
|
|
|
function clearHistory() {
|
|
historyModel.clear()
|
|
saveHistory()
|
|
}
|
|
|
|
function loadFromHistory() {
|
|
// Populate in-memory model from adapter
|
|
try {
|
|
historyModel.clear()
|
|
const items = historyAdapter.history || []
|
|
for (var i = 0; i < items.length; i++) {
|
|
const it = items[i]
|
|
// Coerce legacy second-based timestamps to milliseconds
|
|
var ts = it.timestamp
|
|
if (typeof ts === "number" && ts < 1e12) {
|
|
ts = ts * 1000
|
|
}
|
|
historyModel.append({
|
|
"summary": it.summary || "",
|
|
"body": it.body || "",
|
|
"appName": it.appName || "",
|
|
"desktopEntry": it.desktopEntry || "",
|
|
"image": it.image || "",
|
|
"appIcon": it.appIcon || "",
|
|
"urgency": it.urgency,
|
|
"timestamp": ts ? new Date(ts) : new Date()
|
|
})
|
|
}
|
|
} catch (e) {
|
|
Logger.error("Notifications", "Failed to load history:", e)
|
|
}
|
|
}
|
|
|
|
function saveHistory() {
|
|
try {
|
|
// Serialize model back to adapter
|
|
var arr = []
|
|
for (var i = 0; i < historyModel.count; i++) {
|
|
const n = historyModel.get(i)
|
|
arr.push({
|
|
"summary": n.summary,
|
|
"body": n.body,
|
|
"appName": n.appName,
|
|
"desktopEntry": n.desktopEntry,
|
|
"image": n.image,
|
|
"appIcon": n.appIcon,
|
|
"urgency": n.urgency,
|
|
"timestamp"// Always persist in milliseconds
|
|
: (n.timestamp instanceof Date) ? n.timestamp.getTime() : (typeof n.timestamp === "number" && n.timestamp < 1e12 ? n.timestamp * 1000 : n.timestamp)
|
|
})
|
|
}
|
|
historyAdapter.history = arr
|
|
historyAdapter.timestamp = Time.timestamp
|
|
|
|
Qt.callLater(function () {
|
|
historyFileView.writeAdapter()
|
|
})
|
|
} catch (e) {
|
|
Logger.error("Notifications", "Failed to save history:", e)
|
|
}
|
|
}
|
|
|
|
// Signal to trigger animation before removal
|
|
signal animateAndRemove(var notification, int index)
|
|
|
|
// Function to remove notification from model
|
|
function removeNotification(notification) {
|
|
for (var i = 0; i < notificationModel.count; i++) {
|
|
if (notificationModel.get(i).rawNotification === notification) {
|
|
// Emit signal to trigger animation first
|
|
animateAndRemove(notification, i)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function to actually remove notification after animation
|
|
function forceRemoveNotification(notification) {
|
|
for (var i = 0; i < notificationModel.count; i++) {
|
|
if (notificationModel.get(i).rawNotification === notification) {
|
|
notificationModel.remove(i)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function to format timestamp
|
|
function formatTimestamp(timestamp) {
|
|
if (!timestamp)
|
|
return ""
|
|
|
|
const now = new Date()
|
|
const diff = now - timestamp
|
|
|
|
// Less than 1 minute
|
|
if (diff < 60000) {
|
|
return "now"
|
|
} // Less than 1 hour
|
|
else if (diff < 3600000) {
|
|
const minutes = Math.floor(diff / 60000)
|
|
return `${minutes}m ago`
|
|
} // Less than 24 hours
|
|
else if (diff < 86400000) {
|
|
const hours = Math.floor(diff / 3600000)
|
|
return `${hours}h ago`
|
|
} // More than 24 hours
|
|
else {
|
|
const days = Math.floor(diff / 86400000)
|
|
return `${days}d ago`
|
|
}
|
|
}
|
|
}
|