402 lines
17 KiB
QML
402 lines
17 KiB
QML
pragma Singleton
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// The freedesktop notification server, plus the two lists the UI renders:
|
|
//
|
|
// popups — what Toasts.qml is currently showing (transient, timed)
|
|
// history — GNOME's message tray, what NotificationList.qml shows
|
|
//
|
|
// A notification lives exactly as long as `tracked` is true, so history holds
|
|
// the *live* objects rather than copies: that keeps actions and inline replies
|
|
// working from the tray, which is what GNOME does. The cost is that a
|
|
// notification an app closes itself (progress bars, "download finished"
|
|
// replacing "downloading") disappears from history too — correct behavior,
|
|
// but the reason history is not append-only.
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import Quickshell.Services.Notifications
|
|
import QtQuick
|
|
import qs.config
|
|
|
|
Singleton {
|
|
id: root
|
|
|
|
readonly property alias server: server
|
|
|
|
// Live tracked set, straight from the server. Mostly useful for counting;
|
|
// the UI wants `popups` / `history`, which are ordered newest-first.
|
|
readonly property alias active: server.trackedNotifications
|
|
|
|
property var history: []
|
|
property var popups: []
|
|
|
|
// Suppresses toasts entirely. Notifications still reach history.
|
|
property bool doNotDisturb: false
|
|
|
|
// Cleared when the notification center is opened. The bar binds to this.
|
|
property int unreadCount: 0
|
|
|
|
// Kept separate from the persisted map so this version can safely run
|
|
// before the matching schema entry lands. A later accepted write folds the
|
|
// complete map into DesktopPreferences and clears this fallback.
|
|
property var fallbackAppRules: ({})
|
|
|
|
// Display metadata is intentionally session-only. The durable shape stays
|
|
// just the per-application rule map, while a fresh notification gives the
|
|
// settings page a human-readable name straight away.
|
|
property var rememberedApplications: ({})
|
|
|
|
readonly property var persistedAppRules: {
|
|
const stored = DesktopPreferences.get("notificationAppRules");
|
|
return stored && typeof stored === "object" && !Array.isArray(stored) ? stored : {};
|
|
}
|
|
|
|
// The schema change is the persistence boundary. This branch keeps a
|
|
// session fallback only so it remains usable while that companion change
|
|
// is being integrated; it intentionally makes no restart guarantee then.
|
|
readonly property bool appRulesSchemaAvailable: PreferenceSchema.has("notificationAppRules")
|
|
|
|
readonly property var appRules: Object.assign({}, root.persistedAppRules, root.fallbackAppRules)
|
|
|
|
readonly property var applications: {
|
|
// byId()/heuristicLookup() do not make a binding by themselves. This
|
|
// read updates persisted app labels once DesktopEntries finishes scan.
|
|
const entries = DesktopEntries.applications.values;
|
|
const remembered = root.rememberedApplications;
|
|
return Object.keys(root.appRules).map(appId => ({
|
|
id: appId,
|
|
name: root.applicationLabel(appId, entries, remembered)
|
|
})).sort((a, b) => a.name.localeCompare(b.name));
|
|
}
|
|
|
|
// Arrival times, keyed by notification id — the protocol carries no
|
|
// timestamp. Deliberately formatted once at arrival rather than shown as
|
|
// "5 minutes ago", which would need a clock ticking behind every card.
|
|
readonly property var arrivals: ({})
|
|
|
|
function timeText(id: int): string {
|
|
const at = root.arrivals[id];
|
|
return at ? Qt.formatDateTime(at, Settings.use24Hour ? "HH:mm" : "h:mm AP") : "";
|
|
}
|
|
|
|
// Freedesktop timeout resolution, shared by the toast countdown (Toast.qml)
|
|
// and the no-display expiry a transient notification gets while Do Not
|
|
// Disturb is on (below). Critical urgency and an explicit expireTimeout
|
|
// override policy; -1 ("server decides") falls back to it. 0 means "never
|
|
// auto-expire" per spec.
|
|
function notificationTimeoutMs(notification: var): int {
|
|
if (notification.urgency === NotificationUrgency.Critical)
|
|
return Settings.notificationTimeoutCriticalMs;
|
|
if (notification.expireTimeout === 0)
|
|
return 0;
|
|
if (notification.expireTimeout > 0)
|
|
return Math.round(notification.expireTimeout * 1000);
|
|
return Settings.notificationTimeoutMs;
|
|
}
|
|
|
|
readonly property bool hasNotifications: root.history.length > 0
|
|
|
|
function notificationAppId(notification: var): string {
|
|
const desktopEntry = String(notification.desktopEntry ?? "").trim();
|
|
return desktopEntry || String(notification.appName ?? "").trim() || "Notifications";
|
|
}
|
|
|
|
function applicationLabel(appId: string, entries: var, remembered: var): string {
|
|
const desktopId = appId.endsWith(".desktop") ? appId.slice(0, -8) : appId;
|
|
const entry = DesktopEntries.byId(appId)
|
|
|| DesktopEntries.byId(desktopId)
|
|
|| DesktopEntries.heuristicLookup(appId)
|
|
|| DesktopEntries.heuristicLookup(desktopId);
|
|
return entry?.name || remembered[appId]?.name || appId;
|
|
}
|
|
|
|
function normalizedAppRule(rule: var): var {
|
|
const source = rule && typeof rule === "object" && !Array.isArray(rule) ? rule : {};
|
|
// Only `enabled` -- see the lock-screen note below for why the rule
|
|
// model carries nothing else, and drops old fields on the way through.
|
|
return { enabled: source.enabled !== false };
|
|
}
|
|
|
|
function appRule(appId: string): var {
|
|
return root.normalizedAppRule(root.appRules[appId]);
|
|
}
|
|
|
|
function setAppRule(appId: string, patch: var): bool {
|
|
if (!appId)
|
|
return false;
|
|
|
|
const current = root.appRule(appId);
|
|
const next = {};
|
|
for (const knownAppId of Object.keys(root.appRules))
|
|
next[knownAppId] = root.appRule(knownAppId);
|
|
next[appId] = {
|
|
enabled: patch.enabled === undefined ? current.enabled : patch.enabled === true
|
|
};
|
|
|
|
if (root.appRulesSchemaAvailable && DesktopPreferences.set("notificationAppRules", next))
|
|
root.fallbackAppRules = {};
|
|
else
|
|
root.fallbackAppRules = next;
|
|
return true;
|
|
}
|
|
|
|
function rememberApplication(notification: var): string {
|
|
const appId = root.notificationAppId(notification);
|
|
const next = Object.assign({}, root.rememberedApplications);
|
|
next[appId] = {
|
|
name: String(notification.appName ?? "").trim() || appId
|
|
};
|
|
root.rememberedApplications = next;
|
|
|
|
if (root.appRules[appId] === undefined)
|
|
root.setAppRule(appId, {});
|
|
return appId;
|
|
}
|
|
|
|
// There are deliberately no lock-screen policy getters here, and no
|
|
// lock-screen switches on the Notifications page. The lock screen is
|
|
// hyprlock, which cannot render notifications, so two per-app privacy
|
|
// toggles shipped for a while that controlled nothing -- on the page a
|
|
// person checks precisely when they care. Stored rules may still carry
|
|
// showOnLockScreen fields from that era; nothing reads them. If a lock
|
|
// screen that can render notifications ever exists, the rule store and
|
|
// appRule() are the right place to hang its policy back onto.
|
|
|
|
// history grouped by app, in most-recent-app-first order — the shape
|
|
// NotificationList.qml renders directly.
|
|
readonly property var groups: {
|
|
const out = [];
|
|
const byApp = {};
|
|
for (const n of root.history) {
|
|
const key = n.appName || "Notifications";
|
|
let group = byApp[key];
|
|
if (!group) {
|
|
group = {
|
|
app: key,
|
|
icon: n.appIcon,
|
|
desktopEntry: n.desktopEntry,
|
|
items: []
|
|
};
|
|
byApp[key] = group;
|
|
out.push(group);
|
|
}
|
|
group.items.push(n);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
NotificationServer {
|
|
id: server
|
|
|
|
keepOnReload: true
|
|
persistenceSupported: true
|
|
bodySupported: true
|
|
bodyMarkupSupported: true
|
|
bodyImagesSupported: true
|
|
imageSupported: true
|
|
actionsSupported: true
|
|
actionIconsSupported: true
|
|
inlineReplySupported: true
|
|
|
|
onNotification: notification => root.handleNotification(notification)
|
|
}
|
|
|
|
function handleNotification(notification: var): void {
|
|
// Replayed from before a shell reload. Letting these through would
|
|
// re-toast and re-list everything on every edit, so they are left
|
|
// untracked and allowed to die.
|
|
if (notification.lastGeneration)
|
|
return;
|
|
|
|
const appId = root.rememberApplication(notification);
|
|
if (!root.appRule(appId).enabled)
|
|
return;
|
|
|
|
// Without this the object is destroyed the instant this returns.
|
|
notification.tracked = true;
|
|
root.arrivals[notification.id] = new Date();
|
|
|
|
// The object may go away at any time (app-side close, dismiss()).
|
|
// Drop our references synchronously when it does.
|
|
notification.closed.connect(() => root.forget(notification));
|
|
|
|
// `transient` is the volume-OSD case: show it, never file it.
|
|
if (!notification.transient) {
|
|
root.pushHistory(notification);
|
|
root.unreadCount += 1;
|
|
}
|
|
|
|
// An exception belongs to the focus mode that is in force. A Do Not
|
|
// Disturb switched on by hand has no exceptions and stays absolute,
|
|
// because FocusModes.allows is false whenever no mode is active.
|
|
if (!root.doNotDisturb || FocusModes.allows(root.notificationAppId(notification))) {
|
|
root.popups = [notification].concat(root.popups);
|
|
root.playBell(notification);
|
|
} else if (notification.transient) {
|
|
// Never shown, and (being transient) never filed in history
|
|
// either — nothing will otherwise dismiss() it, so schedule
|
|
// the same release its popup timeout would have given it.
|
|
root.scheduleTransientExpiry(notification);
|
|
}
|
|
}
|
|
|
|
// ── The chime ───────────────────────────────────────────────────────────
|
|
//
|
|
// A notification you can hear. GTK applications get this from libcanberra
|
|
// for free; Panama's own popups had no sound at all, so a notification that
|
|
// arrived while you were looking elsewhere simply did not happen. Same
|
|
// theme, same desktop preference: one switch covers the whole session
|
|
// rather than leaving Panama as the one thing that stays quiet -- or the
|
|
// one thing that will not shut up.
|
|
//
|
|
// Throttled to one bell a second. A burst -- a chat catching up after a
|
|
// suspend, ten build jobs finishing together -- would otherwise stack a
|
|
// dozen overlapping bells, which is a noise rather than a notification.
|
|
property real lastBellAt: 0
|
|
|
|
function playBell(notification: var): void {
|
|
if (!SoundFeedback.eventSounds)
|
|
return;
|
|
|
|
// Low urgency is the "you did not need to know this" tier -- battery
|
|
// reaching full, a sync completing. It stays silent by design.
|
|
if (notification.urgency === NotificationUrgency.Low)
|
|
return;
|
|
|
|
// The freedesktop sound hints. This is the fix for the double chime:
|
|
// an application that plays its own sound sets suppress-sound so the
|
|
// notification server stays quiet, and Panama ignoring it meant one
|
|
// notification made two noises a beat apart.
|
|
//
|
|
// The other two say what to play instead of the theme bell --
|
|
// sound-file is an absolute path the application supplies, sound-name
|
|
// is a theme sound resolved through the same chain the bell uses.
|
|
const hints = notification.hints ?? {};
|
|
if (hints["suppress-sound"] === true)
|
|
return;
|
|
|
|
const soundFile = String(hints["sound-file"] ?? "");
|
|
const soundName = String(hints["sound-name"] ?? "");
|
|
const candidates = soundFile.startsWith("/")
|
|
? [soundFile]
|
|
: (soundName !== ""
|
|
? SoundFeedback.soundCandidates(soundName)
|
|
: SoundFeedback.bellCandidates);
|
|
// A hint naming something unresolvable is a request for that sound, not
|
|
// a request for the bell -- substituting would be a lie about which
|
|
// notification arrived.
|
|
if (candidates.length === 0)
|
|
return;
|
|
|
|
const now = Date.now();
|
|
if (bell.running || now - root.lastBellAt < 1000)
|
|
return;
|
|
root.lastBellAt = now;
|
|
bell.command = SoundFeedback.playCommand(candidates);
|
|
bell.running = true;
|
|
}
|
|
|
|
Process { id: bell }
|
|
|
|
// Runs a DND-hidden transient notification through the same lifetime it
|
|
// would have gotten as a visible popup (Toast.qml's countdown), just
|
|
// without ever showing it, so it still gets released instead of staying
|
|
// tracked forever.
|
|
function scheduleTransientExpiry(notification: var): void {
|
|
const ms = root.notificationTimeoutMs(notification);
|
|
if (ms <= 0)
|
|
return;
|
|
|
|
const timer = Qt.createQmlObject("import QtQuick; Timer { repeat: false }", root);
|
|
timer.interval = ms;
|
|
timer.triggered.connect(() => {
|
|
timer.destroy();
|
|
root.releaseTransient(notification);
|
|
});
|
|
|
|
// Closed some other way first (app-side close, dismissAll()) — cancel
|
|
// the pending timer instead of firing a stale dismiss() later.
|
|
notification.closed.connect(() => timer.destroy());
|
|
timer.running = true;
|
|
}
|
|
|
|
// Transient notifications are never filed in history, so nothing else
|
|
// holds a reference once their lifetime ends — release tracked state
|
|
// directly. Shared by the DND-hidden expiry above and dismissAll() below.
|
|
function releaseTransient(n: var): void {
|
|
if (n.transient)
|
|
n.dismiss();
|
|
}
|
|
|
|
// ── Mutation ────────────────────────────────────────────────────────────
|
|
|
|
function pushHistory(n: var): void {
|
|
const next = [n].concat(root.history);
|
|
|
|
// Anything past the cap is released, otherwise it stays tracked
|
|
// forever and the server's set grows without bound.
|
|
const evicted = next.splice(Settings.notificationHistoryLimit);
|
|
root.history = next;
|
|
for (const old of evicted)
|
|
old.dismiss();
|
|
}
|
|
|
|
// Hide a toast without filing the notification away as read. Mirrors
|
|
// GNOME: closing a banner leaves it in the tray.
|
|
function dropPopup(n: Notification): void {
|
|
const next = root.popups.filter(x => x !== n);
|
|
if (next.length === root.popups.length)
|
|
return;
|
|
root.popups = next;
|
|
root.releaseTransient(n);
|
|
}
|
|
|
|
function dismiss(n: Notification): void {
|
|
n.dismiss();
|
|
}
|
|
|
|
function dismissAll(): void {
|
|
// Copy first: dismiss() re-enters through forget() and rewrites both
|
|
// lists while we iterate.
|
|
const all = root.history.slice();
|
|
|
|
// Transient notifications are never filed in history — whether
|
|
// currently shown as a popup or hidden by Do Not Disturb with a
|
|
// pending scheduleTransientExpiry() timer — so releasing them needs
|
|
// its own pass over the server's full tracked set.
|
|
const transients = root.active.values.filter(n => n.transient);
|
|
|
|
root.history = [];
|
|
root.popups = [];
|
|
for (const n of all)
|
|
n.dismiss();
|
|
for (const n of transients)
|
|
root.releaseTransient(n);
|
|
root.unreadCount = 0;
|
|
}
|
|
|
|
function dismissApp(appName: string): void {
|
|
const doomed = root.history.filter(n => (n.appName || "Notifications") === appName);
|
|
root.history = root.history.filter(n => doomed.indexOf(n) === -1);
|
|
root.popups = root.popups.filter(n => doomed.indexOf(n) === -1);
|
|
for (const n of doomed)
|
|
n.dismiss();
|
|
}
|
|
|
|
function markAllRead(): void {
|
|
root.unreadCount = 0;
|
|
}
|
|
|
|
// Called from the `closed` signal — the object is on its way out, so this
|
|
// only ever removes references, never touches the notification.
|
|
function forget(n: var): void {
|
|
delete root.arrivals[n.id];
|
|
if (root.history.indexOf(n) !== -1)
|
|
root.history = root.history.filter(x => x !== n);
|
|
if (root.popups.indexOf(n) !== -1)
|
|
root.popups = root.popups.filter(x => x !== n);
|
|
}
|
|
}
|