1 /*
2 * Copyright © 2013 Lars Uebernickel
3 *
4 * SPDX-License-Identifier: LGPL-2.1-or-later
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 * Authors: Lars Uebernickel <lars@uebernic.de>
20 */
21
22 #include "config.h"
23
24 #include "gnotificationbackend.h"
25
26 #include "gapplication.h"
27 #include "giomodule-priv.h"
28 #include "gnotification-private.h"
29 #include "gdbusconnection.h"
30 #include "gdbusnamewatching.h"
31 #include "gactiongroup.h"
32 #include "gaction.h"
33 #include "gthemedicon.h"
34 #include "gfileicon.h"
35 #include "gfile.h"
36 #include "gdbusutils.h"
37
38 #define G_TYPE_FDO_NOTIFICATION_BACKEND (g_fdo_notification_backend_get_type ())
39 #define G_FDO_NOTIFICATION_BACKEND(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_FDO_NOTIFICATION_BACKEND, GFdoNotificationBackend))
40
41 typedef struct _GFdoNotificationBackend GFdoNotificationBackend;
42 typedef GNotificationBackendClass GFdoNotificationBackendClass;
43
44 struct _GFdoNotificationBackend
45 {
46 GNotificationBackend parent;
47
48 guint bus_name_id;
49
50 guint notify_subscription;
51 GSList *notifications;
52 };
53
54 GType g_fdo_notification_backend_get_type (void);
55
56 G_DEFINE_TYPE_WITH_CODE (GFdoNotificationBackend, g_fdo_notification_backend, G_TYPE_NOTIFICATION_BACKEND,
57 _g_io_modules_ensure_extension_points_registered ();
58 g_io_extension_point_implement (G_NOTIFICATION_BACKEND_EXTENSION_POINT_NAME,
59 g_define_type_id, "freedesktop", 0))
60
61 typedef struct
62 {
63 GFdoNotificationBackend *backend;
64 gchar *id;
65 guint32 notify_id;
66 gchar *default_action; /* (nullable) (owned) */
67 GVariant *default_action_target; /* (nullable) (owned), not floating */
68 } FreedesktopNotification;
69
70 static void
71 freedesktop_notification_free (gpointer data)
72 {
73 FreedesktopNotification *n = data;
74
75 g_object_unref (n->backend);
76 g_free (n->id);
77 g_free (n->default_action);
78 if (n->default_action_target)
79 g_variant_unref (n->default_action_target);
80
81 g_slice_free (FreedesktopNotification, n);
82 }
83
84 static FreedesktopNotification *
85 freedesktop_notification_new (GFdoNotificationBackend *backend,
86 const gchar *id,
87 GNotification *notification)
88 {
89 FreedesktopNotification *n;
90
91 n = g_slice_new0 (FreedesktopNotification);
92 n->backend = g_object_ref (backend);
93 n->id = g_strdup (id);
94 n->notify_id = 0;
95 g_notification_get_default_action (notification,
96 &n->default_action,
97 &n->default_action_target);
98
99 return n;
100 }
101
102 static FreedesktopNotification *
103 g_fdo_notification_backend_find_notification (GFdoNotificationBackend *backend,
104 const gchar *id)
105 {
106 GSList *it;
107
108 for (it = backend->notifications; it != NULL; it = it->next)
109 {
110 FreedesktopNotification *n = it->data;
111 if (g_str_equal (n->id, id))
112 return n;
113 }
114
115 return NULL;
116 }
117
118 static FreedesktopNotification *
119 g_fdo_notification_backend_find_notification_by_notify_id (GFdoNotificationBackend *backend,
120 guint32 id)
121 {
122 GSList *it;
123
124 for (it = backend->notifications; it != NULL; it = it->next)
125 {
126 FreedesktopNotification *n = it->data;
127 if (n->notify_id == id)
128 return n;
129 }
130
131 return NULL;
132 }
133
134 static gboolean
135 activate_action (GFdoNotificationBackend *backend,
136 const gchar *name,
137 GVariant *parameter)
138 {
139 GNotificationBackend *g_backend = G_NOTIFICATION_BACKEND (backend);
140
141 /* Callers should not provide a floating variant here */
142 g_assert (parameter == NULL || !g_variant_is_floating (parameter));
143
144 if (name != NULL &&
145 g_str_has_prefix (name, "app."))
146 {
147 const GVariantType *parameter_type = NULL;
148 const gchar *action_name = name + strlen ("app.");
149
150 /* @name and @parameter come as untrusted input over D-Bus, so validate them first */
151 if (g_action_group_query_action (G_ACTION_GROUP (g_backend->application),
152 action_name, NULL, ¶meter_type,
153 NULL, NULL, NULL) &&
154 ((parameter_type == NULL && parameter == NULL) ||
155 (parameter_type != NULL && parameter != NULL && g_variant_is_of_type (parameter, parameter_type))))
156 {
157 g_action_group_activate_action (G_ACTION_GROUP (g_backend->application), action_name, parameter);
158 return TRUE;
159 }
160 }
161 else if (name == NULL)
162 {
163 g_application_activate (g_backend->application);
164 return TRUE;
165 }
166
167 return FALSE;
168 }
169
170 static void
171 notify_signal (GDBusConnection *connection,
172 const gchar *sender_name,
173 const gchar *object_path,
174 const gchar *interface_name,
175 const gchar *signal_name,
176 GVariant *parameters,
177 gpointer user_data)
178 {
179 GFdoNotificationBackend *backend = user_data;
180 guint32 id = 0;
181 const gchar *action = NULL;
182 FreedesktopNotification *n;
183 gboolean notification_closed = TRUE;
184
185 if (g_str_equal (signal_name, "NotificationClosed") &&
186 g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(uu)")))
187 {
188 g_variant_get (parameters, "(uu)", &id, NULL);
189 }
190 else if (g_str_equal (signal_name, "ActionInvoked") &&
191 g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(us)")))
192 {
193 g_variant_get (parameters, "(u&s)", &id, &action);
194 }
195 else
196 return;
197
198 n = g_fdo_notification_backend_find_notification_by_notify_id (backend, id);
199 if (n == NULL)
200 return;
201
202 if (action)
203 {
204 if (g_str_equal (action, "default"))
205 {
206 if (!activate_action (backend, n->default_action, n->default_action_target))
207 notification_closed = FALSE;
208 }
209 else
210 {
211 gchar *name = NULL;
212 GVariant *target = NULL;
213
214 if (!g_action_parse_detailed_name (action, &name, &target, NULL) ||
215 !activate_action (backend, name, target))
216 notification_closed = FALSE;
217
218 g_free (name);
219 g_clear_pointer (&target, g_variant_unref);
220 }
221 }
222
223 /* Remove the notification, as it’s either been explicitly closed
224 * (`NotificationClosed` signal) or has been closed as a result of activating
225 * an action successfully. GLib doesn’t currently support the `resident` hint
226 * on notifications which would allow them to stay around after having an
227 * action invoked on them (see
228 * https://specifications.freedesktop.org/notification-spec/notification-spec-latest.html#idm45877717456448)
229 *
230 * First, get the notification again in case the action redrew it */
231 if (notification_closed)
232 {
233 n = g_fdo_notification_backend_find_notification_by_notify_id (backend, id);
234 if (n != NULL)
235 {
236 backend->notifications = g_slist_remove (backend->notifications, n);
237 freedesktop_notification_free (n);
238 }
239 }
240 }
241
242 static void
243 name_vanished_handler_cb (GDBusConnection *connection,
244 const gchar *name,
245 gpointer user_data)
246 {
247 GFdoNotificationBackend *backend = user_data;
248
249 if (backend->notifications)
250 {
251 g_slist_free_full (backend->notifications, freedesktop_notification_free);
252 backend->notifications = NULL;
253 }
254 }
255
256 /* Converts a GNotificationPriority to an urgency level as defined by
257 * the freedesktop spec (0: low, 1: normal, 2: critical).
258 */
259 static guchar
260 urgency_from_priority (GNotificationPriority priority)
261 {
262 switch (priority)
263 {
264 case G_NOTIFICATION_PRIORITY_LOW:
265 return 0;
266
267 default:
268 case G_NOTIFICATION_PRIORITY_NORMAL:
269 case G_NOTIFICATION_PRIORITY_HIGH:
270 return 1;
271
272 case G_NOTIFICATION_PRIORITY_URGENT:
273 return 2;
274 }
275 }
276
277 static void
278 call_notify (GDBusConnection *con,
279 GApplication *app,
280 guint32 replace_id,
281 GNotification *notification,
282 GAsyncReadyCallback callback,
283 gpointer user_data)
284 {
285 GVariantBuilder action_builder;
286 guint n_buttons;
287 guint i;
288 GVariantBuilder hints_builder;
289 GIcon *icon;
290 GVariant *parameters;
291 const gchar *app_name;
292 const gchar *body;
293 guchar urgency;
294
295 g_variant_builder_init (&action_builder, G_VARIANT_TYPE_STRING_ARRAY);
296 if (g_notification_get_default_action (notification, NULL, NULL))
297 {
298 g_variant_builder_add (&action_builder, "s", "default");
299 g_variant_builder_add (&action_builder, "s", "");
300 }
301
302 n_buttons = g_notification_get_n_buttons (notification);
303 for (i = 0; i < n_buttons; i++)
304 {
305 gchar *label;
306 gchar *action;
307 GVariant *target;
308 gchar *detailed_name;
309
310 g_notification_get_button (notification, i, &label, &action, &target);
311 detailed_name = g_action_print_detailed_name (action, target);
312
313 /* Actions named 'default' collide with libnotify's naming of the
314 * default action. Rewriting them to something unique is enough,
315 * because those actions can never be activated (they aren't
316 * prefixed with 'app.').
317 */
318 if (g_str_equal (detailed_name, "default"))
319 {
320 g_free (detailed_name);
321 detailed_name = g_dbus_generate_guid ();
322 }
323
324 g_variant_builder_add_value (&action_builder, g_variant_new_take_string (detailed_name));
325 g_variant_builder_add_value (&action_builder, g_variant_new_take_string (label));
326
327 g_free (action);
328 if (target)
329 g_variant_unref (target);
330 }
331
332 g_variant_builder_init (&hints_builder, G_VARIANT_TYPE ("a{sv}"));
333 g_variant_builder_add (&hints_builder, "{sv}", "desktop-entry",
334 g_variant_new_string (g_application_get_application_id (app)));
335 urgency = urgency_from_priority (g_notification_get_priority (notification));
336 g_variant_builder_add (&hints_builder, "{sv}", "urgency", g_variant_new_byte (urgency));
337 if (g_notification_get_category (notification))
338 {
339 g_variant_builder_add (&hints_builder, "{sv}", "category",
340 g_variant_new_string (g_notification_get_category (notification)));
341 }
342
343 icon = g_notification_get_icon (notification);
344 if (icon != NULL)
345 {
346 if (G_IS_FILE_ICON (icon))
347 {
348 GFile *file;
349
350 file = g_file_icon_get_file (G_FILE_ICON (icon));
351 g_variant_builder_add (&hints_builder, "{sv}", "image-path",
352 g_variant_new_take_string (g_file_get_path (file)));
353 }
354 else if (G_IS_THEMED_ICON (icon))
355 {
356 const gchar* const* icon_names = g_themed_icon_get_names(G_THEMED_ICON (icon));
357 /* Take first name from GThemedIcon */
358 g_variant_builder_add (&hints_builder, "{sv}", "image-path",
359 g_variant_new_string (icon_names[0]));
360 }
361 }
362
363 app_name = g_get_application_name ();
364 body = g_notification_get_body (notification);
365
366 parameters = g_variant_new ("(susssasa{sv}i)",
367 app_name ? app_name : "",
368 replace_id,
369 "", /* app icon */
370 g_notification_get_title (notification),
371 body ? body : "",
372 &action_builder,
373 &hints_builder,
374 -1); /* expire_timeout */
375
376 g_dbus_connection_call (con, "org.freedesktop.Notifications", "/org/freedesktop/Notifications",
377 "org.freedesktop.Notifications", "Notify",
378 parameters, G_VARIANT_TYPE ("(u)"),
379 G_DBUS_CALL_FLAGS_NONE, -1, NULL,
380 callback, user_data);
381 }
382
383 static void
384 notification_sent (GObject *source_object,
385 GAsyncResult *result,
386 gpointer user_data)
387 {
388 FreedesktopNotification *n = user_data;
389 GVariant *val;
390 GError *error = NULL;
391 static gboolean warning_printed = FALSE;
392
393 val = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object), result, &error);
394 if (val)
395 {
396 GFdoNotificationBackend *backend = n->backend;
397 FreedesktopNotification *match;
398
399 g_variant_get (val, "(u)", &n->notify_id);
400 g_variant_unref (val);
401
402 match = g_fdo_notification_backend_find_notification_by_notify_id (backend, n->notify_id);
403 if (match != NULL)
404 {
405 backend->notifications = g_slist_remove (backend->notifications, match);
406 freedesktop_notification_free (match);
407 }
408 backend->notifications = g_slist_prepend (backend->notifications, n);
409 }
410 else
411 {
412 if (!warning_printed)
413 {
414 g_warning ("unable to send notifications through org.freedesktop.Notifications: %s",
415 error->message);
416 warning_printed = TRUE;
417 }
418
419 freedesktop_notification_free (n);
420 g_error_free (error);
421 }
422 }
423
424 static void
425 g_fdo_notification_backend_dispose (GObject *object)
426 {
427 GFdoNotificationBackend *backend = G_FDO_NOTIFICATION_BACKEND (object);
428
429 if (backend->bus_name_id)
430 {
431 g_bus_unwatch_name (backend->bus_name_id);
432 backend->bus_name_id = 0;
433 }
434
435 if (backend->notify_subscription)
436 {
437 GDBusConnection *session_bus;
438
439 session_bus = G_NOTIFICATION_BACKEND (backend)->dbus_connection;
440 g_dbus_connection_signal_unsubscribe (session_bus, backend->notify_subscription);
441 backend->notify_subscription = 0;
442 }
443
444 if (backend->notifications)
445 {
446 g_slist_free_full (backend->notifications, freedesktop_notification_free);
447 backend->notifications = NULL;
448 }
449
450 G_OBJECT_CLASS (g_fdo_notification_backend_parent_class)->dispose (object);
451 }
452
453 static gboolean
454 g_fdo_notification_backend_is_supported (void)
455 {
456 /* This is the fallback backend with the lowest priority. To avoid an
457 * unnecessary synchronous dbus call to check for
458 * org.freedesktop.Notifications, this function always succeeds. A
459 * warning will be printed when sending the first notification fails.
460 */
461 return TRUE;
462 }
463
464 static void
465 g_fdo_notification_backend_send_notification (GNotificationBackend *backend,
466 const gchar *id,
467 GNotification *notification)
468 {
469 GFdoNotificationBackend *self = G_FDO_NOTIFICATION_BACKEND (backend);
470 FreedesktopNotification *n, *tmp;
471
472 if (self->bus_name_id == 0)
473 {
474 self->bus_name_id = g_bus_watch_name_on_connection (backend->dbus_connection,
475 "org.freedesktop.Notifications",
476 G_BUS_NAME_WATCHER_FLAGS_NONE,
477 NULL,
478 name_vanished_handler_cb,
479 backend,
480 NULL);
481 }
482
483 if (self->notify_subscription == 0)
484 {
485 self->notify_subscription =
486 g_dbus_connection_signal_subscribe (backend->dbus_connection,
487 "org.freedesktop.Notifications",
488 "org.freedesktop.Notifications", NULL,
489 "/org/freedesktop/Notifications", NULL,
490 G_DBUS_SIGNAL_FLAGS_NONE,
491 notify_signal, backend, NULL);
492 }
493
494 n = freedesktop_notification_new (self, id, notification);
495
496 tmp = g_fdo_notification_backend_find_notification (self, id);
497 if (tmp)
498 n->notify_id = tmp->notify_id;
499
500 call_notify (backend->dbus_connection, backend->application, n->notify_id, notification, notification_sent, n);
501 }
502
503 static void
504 g_fdo_notification_backend_withdraw_notification (GNotificationBackend *backend,
505 const gchar *id)
506 {
507 GFdoNotificationBackend *self = G_FDO_NOTIFICATION_BACKEND (backend);
508 FreedesktopNotification *n;
509
510 n = g_fdo_notification_backend_find_notification (self, id);
511 if (n)
512 {
513 if (n->notify_id > 0)
514 {
515 g_dbus_connection_call (backend->dbus_connection,
516 "org.freedesktop.Notifications",
517 "/org/freedesktop/Notifications",
518 "org.freedesktop.Notifications", "CloseNotification",
519 g_variant_new ("(u)", n->notify_id), NULL,
520 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
521 }
522
523 self->notifications = g_slist_remove (self->notifications, n);
524 freedesktop_notification_free (n);
525 }
526 }
527
528 static void
529 g_fdo_notification_backend_init (GFdoNotificationBackend *backend)
530 {
531 }
532
533 static void
534 g_fdo_notification_backend_class_init (GFdoNotificationBackendClass *class)
535 {
536 GObjectClass *object_class = G_OBJECT_CLASS (class);
537 GNotificationBackendClass *backend_class = G_NOTIFICATION_BACKEND_CLASS (class);
538
539 object_class->dispose = g_fdo_notification_backend_dispose;
540
541 backend_class->is_supported = g_fdo_notification_backend_is_supported;
542 backend_class->send_notification = g_fdo_notification_backend_send_notification;
543 backend_class->withdraw_notification = g_fdo_notification_backend_withdraw_notification;
544 }