379 lines
13 KiB
JavaScript
379 lines
13 KiB
JavaScript
/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
|
|
const DBus = imports.dbus;
|
|
const GLib = imports.gi.GLib;
|
|
const Lang = imports.lang;
|
|
const Shell = imports.gi.Shell;
|
|
const Mainloop = imports.mainloop;
|
|
const St = imports.gi.St;
|
|
|
|
const Main = imports.ui.main;
|
|
const MessageTray = imports.ui.messageTray;
|
|
const Params = imports.misc.params;
|
|
|
|
const EMPATHY = 'Empathy';
|
|
|
|
let nextNotificationId = 1;
|
|
|
|
// Should really be defined in dbus.js
|
|
const BusIface = {
|
|
name: 'org.freedesktop.DBus',
|
|
methods: [{ name: 'GetConnectionUnixProcessID',
|
|
inSignature: 's',
|
|
outSignature: 'i' }]
|
|
};
|
|
|
|
const Bus = function () {
|
|
this._init();
|
|
};
|
|
|
|
Bus.prototype = {
|
|
_init: function() {
|
|
DBus.session.proxifyObject(this, 'org.freedesktop.DBus', '/org/freedesktop/DBus');
|
|
}
|
|
};
|
|
|
|
DBus.proxifyPrototype(Bus.prototype, BusIface);
|
|
|
|
const NotificationDaemonIface = {
|
|
name: 'org.freedesktop.Notifications',
|
|
methods: [{ name: 'Notify',
|
|
inSignature: 'susssasa{sv}i',
|
|
outSignature: 'u'
|
|
},
|
|
{ name: 'CloseNotification',
|
|
inSignature: 'u',
|
|
outSignature: ''
|
|
},
|
|
{ name: 'GetCapabilities',
|
|
inSignature: '',
|
|
outSignature: 'as'
|
|
},
|
|
{ name: 'GetServerInformation',
|
|
inSignature: '',
|
|
outSignature: 'ssss'
|
|
}],
|
|
signals: [{ name: 'NotificationClosed',
|
|
inSignature: 'uu' },
|
|
{ name: 'ActionInvoked',
|
|
inSignature: 'us' }]
|
|
};
|
|
|
|
const NotificationClosedReason = {
|
|
EXPIRED: 1,
|
|
DISMISSED: 2,
|
|
APP_CLOSED: 3,
|
|
UNDEFINED: 4
|
|
};
|
|
|
|
const Urgency = {
|
|
LOW: 0,
|
|
NORMAL: 1,
|
|
CRITICAL: 2
|
|
};
|
|
|
|
const rewriteRules = {
|
|
'XChat': [
|
|
{ pattern: /^XChat: Private message from: (\S*) \(.*\)$/,
|
|
replacement: '<$1>' },
|
|
{ pattern: /^XChat: New public message from: (\S*) \((.*)\)$/,
|
|
replacement: '$2 <$1>' },
|
|
{ pattern: /^XChat: Highlighted message from: (\S*) \((.*)\)$/,
|
|
replacement: '$2 <$1>' }
|
|
]
|
|
};
|
|
function NotificationDaemon() {
|
|
this._init();
|
|
}
|
|
|
|
NotificationDaemon.prototype = {
|
|
_init: function() {
|
|
DBus.session.exportObject('/org/freedesktop/Notifications', this);
|
|
|
|
this._everAcquiredName = false;
|
|
DBus.session.acquire_name('org.freedesktop.Notifications',
|
|
// We pass MANY_INSTANCES so that if
|
|
// notification-daemon is running, we'll
|
|
// get queued behind it and then get the
|
|
// name after killing it below
|
|
DBus.MANY_INSTANCES,
|
|
Lang.bind(this, this._acquiredName),
|
|
Lang.bind(this, this._lostName));
|
|
|
|
this._currentNotifications = {};
|
|
|
|
Shell.WindowTracker.get_default().connect('notify::focus-app',
|
|
Lang.bind(this, this._onFocusAppChanged));
|
|
Main.overview.connect('hidden',
|
|
Lang.bind(this, this._onFocusAppChanged));
|
|
},
|
|
|
|
_acquiredName: function() {
|
|
this._everAcquiredName = true;
|
|
},
|
|
|
|
_lostName: function() {
|
|
if (this._everAcquiredName)
|
|
log('Lost name org.freedesktop.Notifications!');
|
|
else if (GLib.getenv('GNOME_SHELL_NO_REPLACE'))
|
|
log('Failed to acquire org.freedesktop.Notifications');
|
|
else {
|
|
log('Failed to acquire org.freedesktop.Notifications; trying again');
|
|
|
|
// kill the notification-daemon. pkill is more portable
|
|
// than killall, but on Linux at least it won't match if
|
|
// you pass more than 15 characters of the process name...
|
|
// However, if you use the "-f" flag to match the entire
|
|
// command line, it will work, but we have to be careful
|
|
// in that case that we don't match "gedit
|
|
// notification-daemon.c" or whatever...
|
|
let p = new Shell.Process({ args: ['pkill', '-f',
|
|
'^([^ ]*/)?(notification-daemon|notify-osd)$']});
|
|
p.run();
|
|
}
|
|
},
|
|
|
|
_sourceId: function(id) {
|
|
return 'source-' + id;
|
|
},
|
|
|
|
Notify: function(appName, replacesId, icon, summary, body,
|
|
actions, hints, timeout) {
|
|
let notification, id;
|
|
// We associate each application with a source and set the source id to be based on
|
|
// the appName. We support application updates by creating a new Notification object
|
|
// only if replacesId was not specified or if we no longer have the notification with
|
|
// the specified replacesId.
|
|
//
|
|
// We are planning to add Empathy-specific features in the message tray, but in the
|
|
// meantime we handle Empathy notifications received through the notification daemon
|
|
// differently from other notifications.
|
|
// 1) We display different people sending messages as different sources. So we use
|
|
// notification id instead of the appName when creating id for the source.
|
|
// 2) We queue notification with different messages to show them one after another,
|
|
// rather than replace the notification on the spot. So we create a new Notification
|
|
// object each time, disregarding the fact that we might already have another
|
|
// notification with the same replacesId.
|
|
// Empathy uses replacesId for all the notifications from the same window until the
|
|
// notification with that id is dismissed. Notifications from different people in
|
|
// different tabs have the same replacesId. So while being closer to the eventual design,
|
|
// our special-handling of Empathy notifications is somewhat buggy. The user might end up
|
|
// with multiple icons for the same person if the user dismisses the window for that person
|
|
// (which doesn't result in removing the icon) or the user might not get the icon for
|
|
// the person after a new notification in one of the tabs of the chat window for which
|
|
// another person's icon is already displayed.
|
|
|
|
let isEmpathy = appName == EMPATHY;
|
|
if (replacesId != 0) {
|
|
id = replacesId;
|
|
if (!isEmpathy)
|
|
notification = this._currentNotifications[id];
|
|
} else {
|
|
id = nextNotificationId++;
|
|
}
|
|
|
|
let sourceId = this._sourceId(isEmpathy ? id : appName);
|
|
let source = Main.messageTray.getSource(sourceId);
|
|
|
|
// Source may be null if we have never received a notification from
|
|
// this app or if all notifications from this app have been acknowledged.
|
|
if (source == null) {
|
|
source = new Source(sourceId, icon, hints);
|
|
Main.messageTray.add(source);
|
|
|
|
source.connect('clicked', Lang.bind(this,
|
|
function() {
|
|
source.destroy();
|
|
}));
|
|
|
|
let sender = DBus.getCurrentMessageContext().sender;
|
|
let busProxy = new Bus();
|
|
busProxy.GetConnectionUnixProcessIDRemote(sender, function (result, excp) {
|
|
let app = Shell.WindowTracker.get_default().get_app_from_pid(result);
|
|
source.setApp(app);
|
|
});
|
|
} else {
|
|
source.update(icon, hints);
|
|
}
|
|
|
|
summary = GLib.markup_escape_text(summary, -1);
|
|
|
|
let rewrites = rewriteRules[appName];
|
|
if (rewrites) {
|
|
for (let i = 0; i < rewrites.length; i++) {
|
|
let rule = rewrites[i];
|
|
if (summary.search(rule.pattern) != -1)
|
|
summary = summary.replace(rule.pattern, rule.replacement);
|
|
}
|
|
}
|
|
|
|
if (notification == null) {
|
|
notification = new MessageTray.Notification(id, source, summary, body, true);
|
|
// This will result in us keeping only the latest Empathy notification with the given
|
|
// id in this._currentNotifications, which will only affect not being able to close all
|
|
// the Empathy notifications with a given id in CloseNotification(). Since this not a
|
|
// a likely scenario and this special-casing of Empathy in the notification daemon is
|
|
// temporary, it doesn't seem worthwhile to change this._currentNotifications to
|
|
// {id, [array of notifications]} just for that case.
|
|
this._currentNotifications[id] = notification;
|
|
notification.connect('dismissed', Lang.bind(this,
|
|
function(n) {
|
|
n.destroy();
|
|
this._emitNotificationClosed(n.id, NotificationClosedReason.DISMISSED);
|
|
}));
|
|
} else {
|
|
// passing in true as the last parameter will clear out extra actors,
|
|
// such as actions
|
|
notification.update(summary, body, true);
|
|
}
|
|
|
|
if (actions.length) {
|
|
for (let i = 0; i < actions.length - 1; i += 2)
|
|
notification.addAction(actions[i], actions[i + 1]);
|
|
notification.connect('action-invoked', Lang.bind(this, this._actionInvoked, source, id));
|
|
}
|
|
|
|
source.notify(notification);
|
|
return id;
|
|
},
|
|
|
|
CloseNotification: function(id) {
|
|
let notification = this._currentNotifications[id];
|
|
if (notification)
|
|
notification.destroy();
|
|
this._emitNotificationClosed(id, NotificationClosedReason.APP_CLOSED);
|
|
},
|
|
|
|
GetCapabilities: function() {
|
|
return [
|
|
'actions',
|
|
'body',
|
|
// 'body-hyperlinks',
|
|
// 'body-images',
|
|
'body-markup',
|
|
// 'icon-multi',
|
|
'icon-static'
|
|
// 'sound',
|
|
];
|
|
},
|
|
|
|
GetServerInformation: function() {
|
|
return [
|
|
'GNOME Shell',
|
|
'GNOME',
|
|
'0.1', // FIXME, get this from somewhere
|
|
'1.0'
|
|
];
|
|
},
|
|
|
|
_onFocusAppChanged: function() {
|
|
let tracker = Shell.WindowTracker.get_default();
|
|
Main.messageTray.removeSourceByApp(tracker.focus_app);
|
|
},
|
|
|
|
_actionInvoked: function(notification, action, source, id) {
|
|
this._emitActionInvoked(id, action);
|
|
source.destroy();
|
|
},
|
|
|
|
_emitNotificationClosed: function(id, reason) {
|
|
delete this._currentNotifications[id];
|
|
DBus.session.emit_signal('/org/freedesktop/Notifications',
|
|
'org.freedesktop.Notifications',
|
|
'NotificationClosed', 'uu',
|
|
[id, reason]);
|
|
},
|
|
|
|
_emitActionInvoked: function(id, action) {
|
|
DBus.session.emit_signal('/org/freedesktop/Notifications',
|
|
'org.freedesktop.Notifications',
|
|
'ActionInvoked', 'us',
|
|
[id, action]);
|
|
}
|
|
};
|
|
|
|
DBus.conformExport(NotificationDaemon.prototype, NotificationDaemonIface);
|
|
|
|
function Source(sourceId, icon, hints) {
|
|
this._init(sourceId, icon, hints);
|
|
}
|
|
|
|
Source.prototype = {
|
|
__proto__: MessageTray.Source.prototype,
|
|
|
|
_init: function(sourceId, icon, hints) {
|
|
MessageTray.Source.prototype._init.call(this, sourceId);
|
|
|
|
this.app = null;
|
|
this._openAppRequested = false;
|
|
|
|
this.update(icon, hints);
|
|
},
|
|
|
|
update: function(icon, hints) {
|
|
hints = Params.parse(hints, { urgency: Urgency.NORMAL }, true);
|
|
|
|
this._icon = icon;
|
|
this._iconData = hints.icon_data;
|
|
this._urgency = hints.urgency;
|
|
},
|
|
|
|
createIcon: function(size) {
|
|
let textureCache = St.TextureCache.get_default();
|
|
|
|
if (this._icon) {
|
|
if (this._icon.substr(0, 7) == 'file://')
|
|
return textureCache.load_uri_async(this._icon, size, size);
|
|
else if (this._icon[0] == '/') {
|
|
let uri = GLib.filename_to_uri(this._icon, null);
|
|
return textureCache.load_uri_async(uri, size, size);
|
|
} else
|
|
return textureCache.load_icon_name(this._icon, size);
|
|
} else if (this._iconData) {
|
|
let [width, height, rowStride, hasAlpha,
|
|
bitsPerSample, nChannels, data] = this._iconData;
|
|
return textureCache.load_from_raw(data, data.length, hasAlpha,
|
|
width, height, rowStride, size);
|
|
} else {
|
|
let stockIcon;
|
|
switch (this._urgency) {
|
|
case Urgency.LOW:
|
|
case Urgency.NORMAL:
|
|
stockIcon = 'gtk-dialog-info';
|
|
break;
|
|
case Urgency.CRITICAL:
|
|
stockIcon = 'gtk-dialog-error';
|
|
break;
|
|
}
|
|
return textureCache.load_icon_name(stockIcon, size);
|
|
}
|
|
},
|
|
|
|
clicked: function() {
|
|
this.openApp();
|
|
MessageTray.Source.prototype.clicked.call(this);
|
|
},
|
|
|
|
setApp: function(app) {
|
|
this.app = app;
|
|
if (this._openAppRequested)
|
|
this.openApp();
|
|
|
|
if (app.get_name() == EMPATHY)
|
|
this.handleReplacing = false;
|
|
},
|
|
|
|
openApp: function() {
|
|
if (this.app == null) {
|
|
this._openAppRequested = true;
|
|
return;
|
|
}
|
|
let windows = this.app.get_windows();
|
|
if (windows.length > 0) {
|
|
let mostRecentWindow = windows[0];
|
|
Main.activateWindow(mostRecentWindow);
|
|
}
|
|
this._openAppRequested = false;
|
|
}
|
|
};
|