Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-3.0-or-later
2 : : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
3 : :
4 : : #define G_LOG_DOMAIN "valent-notification-plugin"
5 : :
6 : : #include "config.h"
7 : :
8 : : #include <libportal/portal.h>
9 : : #include <gio/gio.h>
10 : : #include <json-glib/json-glib.h>
11 : : #include <valent.h>
12 : :
13 : : #include "valent-notification-plugin.h"
14 : : #include "valent-notification-upload.h"
15 : :
16 : : #define DEFAULT_ICON_SIZE 512
17 : :
18 : :
19 : : struct _ValentNotificationPlugin
20 : : {
21 : : ValentDevicePlugin parent_instance;
22 : :
23 : : GCancellable *cancellable;
24 : : ValentNotifications *notifications;
25 : : ValentSession *session;
26 : :
27 : : GHashTable *cache;
28 : : unsigned int notifications_watch : 1;
29 : : };
30 : :
31 [ + + + - ]: 140 : G_DEFINE_FINAL_TYPE (ValentNotificationPlugin, valent_notification_plugin, VALENT_TYPE_DEVICE_PLUGIN)
32 : :
33 : : static void valent_notification_plugin_handle_notification (ValentNotificationPlugin *self,
34 : : JsonNode *packet);
35 : : static void valent_notification_plugin_handle_notification_action (ValentNotificationPlugin *self,
36 : : JsonNode *packet);
37 : : static void valent_notification_plugin_handle_notification_reply (ValentNotificationPlugin *self,
38 : : JsonNode *packet);
39 : : static void valent_notification_plugin_handle_notification_request (ValentNotificationPlugin *self,
40 : : JsonNode *packet);
41 : :
42 : : static void valent_notification_plugin_close_notification (ValentNotificationPlugin *self,
43 : : const char *id);
44 : : static void valent_notification_plugin_request_notifications (ValentNotificationPlugin *self);
45 : : static void valent_notification_plugin_send_notification (ValentNotificationPlugin *self,
46 : : const char *id,
47 : : const char *appName,
48 : : const char *title,
49 : : const char *body,
50 : : GIcon *icon);
51 : : static void valent_notification_plugin_show_notification (ValentNotificationPlugin *self,
52 : : JsonNode *packet,
53 : : GIcon *gicon);
54 : :
55 : :
56 : : /*
57 : : * ValentNotifications Callbacks
58 : : */
59 : : static void
60 : 5 : on_notification_added (ValentNotifications *listener,
61 : : ValentNotification *notification,
62 : : ValentNotificationPlugin *self)
63 : : {
64 : 5 : GSettings *settings;
65 : 5 : const char *application;
66 : 10 : g_auto (GStrv) deny = NULL;
67 : :
68 [ + - ]: 5 : g_assert (VALENT_IS_NOTIFICATIONS (listener));
69 [ - + ]: 5 : g_assert (VALENT_IS_NOTIFICATION (notification));
70 [ - + ]: 5 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
71 : :
72 : 5 : settings = valent_extension_get_settings (VALENT_EXTENSION (self));
73 : :
74 [ + - ]: 5 : if (!g_settings_get_boolean (settings, "forward-notifications"))
75 : : return;
76 : :
77 [ - + - - ]: 5 : if (!g_settings_get_boolean (settings, "forward-when-active") &&
78 : 0 : valent_session_get_active (self->session))
79 : : return;
80 : :
81 : 5 : application = valent_notification_get_application (notification);
82 : 5 : deny = g_settings_get_strv (settings, "forward-deny");
83 : :
84 [ + + - + ]: 5 : if (application && g_strv_contains ((const char * const *)deny, application))
85 [ # # ]: 0 : return;
86 : :
87 [ + - ]: 5 : valent_notification_plugin_send_notification (self,
88 : : valent_notification_get_id (notification),
89 : : valent_notification_get_application (notification),
90 : : valent_notification_get_title (notification),
91 : : valent_notification_get_body (notification),
92 : : valent_notification_get_icon (notification));
93 : : }
94 : :
95 : : static void
96 : 1 : on_notification_removed (ValentNotifications *notifications,
97 : : const char *id,
98 : : ValentNotificationPlugin *self)
99 : : {
100 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATIONS (notifications));
101 [ - + ]: 1 : g_assert (id != NULL);
102 : :
103 : 1 : valent_notification_plugin_close_notification (self, id);
104 : 1 : }
105 : :
106 : : static void
107 : 29 : valent_notification_plugin_watch_notifications (ValentNotificationPlugin *self,
108 : : gboolean watch)
109 : : {
110 : 29 : ValentNotifications *notifications = valent_notifications_get_default ();
111 : :
112 [ + - ]: 29 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
113 : :
114 [ + + ]: 29 : if (self->notifications_watch == watch)
115 : : return;
116 : :
117 [ + + ]: 10 : if (watch)
118 : : {
119 : 5 : g_signal_connect_object (notifications,
120 : : "notification-added",
121 : : G_CALLBACK (on_notification_added),
122 : : self, 0);
123 : 5 : g_signal_connect_object (notifications,
124 : : "notification-removed",
125 : : G_CALLBACK (on_notification_removed),
126 : : self, 0);
127 : 5 : self->notifications_watch = TRUE;
128 : : }
129 : : else
130 : : {
131 : 5 : g_signal_handlers_disconnect_by_data (notifications, self);
132 : 5 : self->notifications_watch = FALSE;
133 : : }
134 : : }
135 : :
136 : : /*
137 : : * Icon Transfers
138 : : */
139 : : typedef struct
140 : : {
141 : : GRecMutex mutex;
142 : : ValentDevice *device;
143 : : JsonNode *packet;
144 : : } IconTransferData;
145 : :
146 : : static void
147 : 1 : icon_transfer_data_free (gpointer data)
148 : : {
149 : 1 : IconTransferData *transfer = (IconTransferData *)data;
150 : :
151 : 1 : g_rec_mutex_lock (&transfer->mutex);
152 [ - + ]: 1 : g_clear_object (&transfer->device);
153 [ - + ]: 1 : g_clear_pointer (&transfer->packet, json_node_unref);
154 : 1 : g_rec_mutex_unlock (&transfer->mutex);
155 : 1 : g_rec_mutex_clear (&transfer->mutex);
156 : 1 : g_clear_pointer (&transfer, g_free);
157 : 1 : }
158 : :
159 : : static GFile *
160 : 1 : valent_notification_plugin_get_icon_file (ValentNotificationPlugin *self,
161 : : JsonNode *packet)
162 : : {
163 : 2 : g_autoptr (GFile) file = NULL;
164 : 1 : const char *payload_hash;
165 : :
166 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
167 [ - + ]: 1 : g_assert (VALENT_IS_PACKET (packet));
168 : :
169 [ + - ]: 1 : if (valent_packet_get_string (packet, "payloadHash", &payload_hash))
170 : : {
171 : 1 : ValentContext *context = NULL;
172 : :
173 : 1 : context = valent_extension_get_context (VALENT_EXTENSION (self));
174 : 1 : file = valent_context_get_cache_file (context, payload_hash);
175 : : }
176 : : else
177 : : {
178 : 0 : g_autoptr (GFileIOStream) stream = NULL;
179 : :
180 [ # # ]: 0 : file = g_file_new_tmp ("valent-notification-icon.XXXXXX", &stream, NULL);
181 : : }
182 : :
183 : 1 : return g_steal_pointer (&file);
184 : : }
185 : :
186 : : static void
187 : 1 : download_icon_task (GTask *task,
188 : : gpointer source_object,
189 : : gpointer task_data,
190 : : GCancellable *cancellable)
191 : : {
192 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (source_object);
193 : 1 : IconTransferData *transfer = (IconTransferData *)task_data;
194 : 1 : g_autoptr (ValentDevice) device = NULL;
195 [ + - - - ]: 1 : g_autoptr (JsonNode) packet = NULL;
196 [ + - - - ]: 1 : g_autoptr (GFile) file = NULL;
197 : 1 : GError *error = NULL;
198 : :
199 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
200 [ - + ]: 1 : g_assert (transfer != NULL);
201 : :
202 [ + - ]: 1 : if (g_task_return_error_if_cancelled (task))
203 : : return;
204 : :
205 : 1 : g_rec_mutex_lock (&transfer->mutex);
206 : 1 : device = g_steal_pointer (&transfer->device);
207 : 1 : packet = g_steal_pointer (&transfer->packet);
208 : 1 : g_rec_mutex_unlock (&transfer->mutex);
209 : :
210 : 1 : file = valent_notification_plugin_get_icon_file (self, packet);
211 : :
212 : : /* Check if we've already downloaded this icon */
213 [ + - ]: 1 : if (!g_file_query_exists (file, cancellable))
214 : : {
215 [ - - ]: 1 : g_autoptr (GIOStream) source = NULL;
216 [ - - ]: 1 : g_autoptr (GFileOutputStream) target = NULL;
217 [ - - ]: 1 : g_autoptr (GFile) cache_dir = NULL;
218 [ + - - - ]: 1 : g_autoptr (ValentChannel) channel = NULL;
219 : :
220 : : /* Ensure the cache directory exists */
221 : 1 : cache_dir = g_file_get_parent (file);
222 : :
223 [ - + ]: 1 : if (g_mkdir_with_parents (g_file_peek_path (cache_dir), 0700) != 0)
224 : : {
225 : 0 : return g_task_return_new_error (task,
226 : : G_IO_ERROR,
227 : : G_IO_ERROR_FAILED,
228 : : "Error: %s",
229 : 0 : g_strerror (errno));
230 : : }
231 : :
232 : : /* Get the device channel */
233 [ - + ]: 1 : if ((channel = valent_device_ref_channel (device)) == NULL)
234 : : {
235 : 0 : return g_task_return_new_error (task,
236 : : G_IO_ERROR,
237 : : G_IO_ERROR_NOT_CONNECTED,
238 : : "Device is disconnected");
239 : : }
240 : :
241 : 1 : source = valent_channel_download (channel, packet, cancellable, &error);
242 : :
243 [ - + ]: 1 : if (source == NULL)
244 : : {
245 : 0 : g_file_delete (file, NULL, NULL);
246 : 0 : return g_task_return_error (task, error);
247 : : }
248 : :
249 : : /* Get the output stream */
250 : 1 : target = g_file_replace (file,
251 : : NULL,
252 : : FALSE,
253 : : G_FILE_CREATE_REPLACE_DESTINATION,
254 : : cancellable,
255 : : &error);
256 : :
257 [ - + ]: 1 : if (target == NULL)
258 : : {
259 : 0 : g_file_delete (file, NULL, NULL);
260 : 0 : return g_task_return_error (task, error);
261 : : }
262 : :
263 : : /* Start download */
264 : 1 : g_output_stream_splice (G_OUTPUT_STREAM (target),
265 : : g_io_stream_get_input_stream (source),
266 : : (G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
267 : : G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET),
268 : : cancellable,
269 : : &error);
270 : :
271 [ - + ]: 1 : if (error != NULL)
272 : : {
273 : 0 : g_file_delete (file, NULL, NULL);
274 : 0 : return g_task_return_error (task, error);
275 : : }
276 : : }
277 : :
278 : : /* If we're in a sandbox, send the file as a GBytesIcon in case the file path
279 : : * is not valid for the host system. */
280 [ - + ]: 1 : if (xdp_portal_running_under_sandbox ())
281 : : {
282 : 0 : g_autoptr (GBytes) bytes = NULL;
283 : :
284 : 0 : bytes = g_file_load_bytes (file, cancellable, NULL, &error);
285 : :
286 [ # # ]: 0 : if (bytes == NULL)
287 : : {
288 : 0 : g_file_delete (file, NULL, NULL);
289 : 0 : return g_task_return_error (task, error);
290 : : }
291 : :
292 : 0 : g_task_return_pointer (task, g_bytes_icon_new (bytes), g_object_unref);
293 : : }
294 : : else
295 : : {
296 : 1 : g_task_return_pointer (task, g_file_icon_new (file), g_object_unref);
297 : : }
298 : : }
299 : :
300 : : static void
301 : 1 : valent_notification_plugin_download_icon (ValentNotificationPlugin *self,
302 : : JsonNode *packet,
303 : : GCancellable *cancellable,
304 : : GAsyncReadyCallback callback,
305 : : gpointer user_data)
306 : : {
307 : 1 : ValentExtension *extension = VALENT_EXTENSION (self);
308 : 2 : g_autoptr (GTask) task = NULL;
309 : 1 : IconTransferData *transfer = NULL;
310 : :
311 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
312 [ - + ]: 1 : g_assert (VALENT_IS_PACKET (packet));
313 [ + - + - : 1 : g_assert (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
- + - - ]
314 : :
315 : 1 : transfer = g_new0 (IconTransferData, 1);
316 : 1 : g_rec_mutex_init (&transfer->mutex);
317 : 1 : g_rec_mutex_lock (&transfer->mutex);
318 : 1 : transfer->device = g_object_ref (valent_extension_get_object (extension));
319 : 1 : transfer->packet = json_node_ref (packet);
320 : 1 : g_rec_mutex_unlock (&transfer->mutex);
321 : :
322 : 1 : task = g_task_new (self, cancellable, callback, user_data);
323 [ + - ]: 1 : g_task_set_source_tag (task, valent_notification_plugin_download_icon);
324 : 1 : g_task_set_task_data (task, transfer, icon_transfer_data_free);
325 [ + - ]: 1 : g_task_run_in_thread (task, download_icon_task);
326 : 1 : }
327 : :
328 : : static GIcon *
329 : 1 : valent_notification_plugin_download_icon_finish (ValentNotificationPlugin *self,
330 : : GAsyncResult *result,
331 : : GError **error)
332 : : {
333 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
334 [ - + ]: 1 : g_assert (g_task_is_valid (result, self));
335 [ + - - + ]: 1 : g_assert (error == NULL || *error == NULL);
336 : :
337 : 1 : return g_task_propagate_pointer (G_TASK (result), error);
338 : : }
339 : :
340 : : /*
341 : : * Remote Notifications
342 : : */
343 : : static void
344 : 4 : valent_notification_plugin_show_notification (ValentNotificationPlugin *self,
345 : : JsonNode *packet,
346 : : GIcon *gicon)
347 : : {
348 : 4 : ValentDevice *device;
349 : 4 : g_autoptr (GNotification) notification = NULL;
350 [ + - ]: 4 : g_autoptr (GIcon) icon = NULL;
351 : 4 : const char *id;
352 : 4 : const char *app_name = NULL;
353 : 4 : const char *title = NULL;
354 : 4 : const char *text = NULL;
355 : 4 : const char *reply_id;
356 : 4 : JsonArray *actions;
357 : :
358 : : /* Finish the icon task */
359 [ + + + - : 4 : if (G_IS_ICON (gicon))
+ - + - ]
360 : 1 : icon = g_object_ref (gicon);
361 : :
362 : : /* Ensure we have a notification id, appName and title */
363 [ - + ]: 4 : if (!valent_packet_get_string (packet, "id", &id))
364 : : {
365 : 0 : g_debug ("%s(): expected \"id\" field holding a string",
366 : : G_STRFUNC);
367 : 0 : return;
368 : : }
369 : :
370 [ - + ]: 4 : if (!valent_packet_get_string (packet, "appName", &app_name))
371 : : {
372 : 0 : g_debug ("%s(): expected \"appName\" field holding a string",
373 : : G_STRFUNC);
374 : 0 : return;
375 : : }
376 : :
377 [ - + ]: 4 : if (!valent_packet_get_string (packet, "title", &title))
378 : : {
379 : 0 : g_debug ("%s(): expected \"title\" field holding a string",
380 : : G_STRFUNC);
381 : 0 : return;
382 : : }
383 : :
384 [ - + ]: 4 : if (!valent_packet_get_string (packet, "text", &text))
385 : : {
386 [ # # ]: 0 : if (g_strcmp0 (app_name, title) != 0)
387 : : {
388 : 0 : text = title;
389 : 0 : title = app_name;
390 : : }
391 : : }
392 : :
393 : 4 : device = valent_extension_get_object (VALENT_EXTENSION (self));
394 : :
395 : 4 : notification = g_notification_new (title);
396 : 4 : g_notification_set_body (notification, text);
397 : :
398 [ + + ]: 4 : if (icon != NULL)
399 : 1 : g_notification_set_icon (notification, icon);
400 : :
401 : : /* Notification Actions */
402 [ + + ]: 4 : if (valent_packet_get_array (packet, "actions", &actions))
403 : : {
404 : 1 : unsigned int n_actions;
405 : :
406 : 1 : n_actions = json_array_get_length (actions);
407 : :
408 [ + + ]: 4 : for (unsigned int i = 0; i < n_actions; i++)
409 : : {
410 : 3 : JsonNode *element;
411 : 3 : const char *action;
412 : 3 : GVariant *target;
413 : :
414 [ + - - + ]: 6 : if ((element = json_array_get_element (actions, i)) == NULL ||
415 : 3 : json_node_get_value_type (element) != G_TYPE_STRING)
416 : 0 : continue;
417 : :
418 : 3 : action = json_node_get_string (element);
419 : 3 : target = g_variant_new ("(ss)", id, action);
420 : 3 : valent_notification_add_device_button (notification,
421 : : device,
422 : : action,
423 : : "notification.action",
424 : : target);
425 : : }
426 : : }
427 : :
428 : : /* Repliable Notification */
429 [ + + ]: 4 : if (valent_packet_get_string (packet, "requestReplyId", &reply_id))
430 : : {
431 : 1 : g_autoptr (ValentNotification) incoming = NULL;
432 : 1 : const char *time_str = NULL;
433 : 1 : int64_t time = 0;
434 : 1 : GVariant *target;
435 : :
436 [ + - ]: 1 : if (valent_packet_get_string (packet, "time", &time_str))
437 : 1 : time = g_ascii_strtoll (time_str, NULL, 10);
438 : :
439 : 1 : incoming = g_object_new (VALENT_TYPE_NOTIFICATION,
440 : : "id", id,
441 : : "application", app_name,
442 : : "icon", icon,
443 : : "title", title,
444 : : "body", text,
445 : : "time", time,
446 : : NULL);
447 : 1 : target = g_variant_new ("(ssv)",
448 : : reply_id,
449 : : "",
450 : : valent_notification_serialize (incoming));
451 : :
452 [ + - ]: 1 : valent_notification_set_device_action (notification,
453 : : device,
454 : : "notification.reply",
455 : : target);
456 : : }
457 : :
458 [ + + ]: 4 : valent_device_plugin_show_notification (VALENT_DEVICE_PLUGIN (self),
459 : : id,
460 : : notification);
461 : : }
462 : :
463 : : static void
464 : 1 : valent_notification_plugin_download_icon_cb (ValentNotificationPlugin *self,
465 : : GAsyncResult *result,
466 : : gpointer user_data)
467 : : {
468 : 1 : g_autoptr (JsonNode) packet = user_data;
469 [ - - + - ]: 1 : g_autoptr (GIcon) icon = NULL;
470 [ - - + - ]: 1 : g_autoptr (GError) error = NULL;
471 : :
472 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
473 [ - + ]: 1 : g_assert (g_task_is_valid (result, self));
474 : :
475 : 1 : icon = valent_notification_plugin_download_icon_finish (self, result, &error);
476 : :
477 [ - + ]: 1 : if (icon == NULL)
478 : : {
479 : : /* If the operation was cancelled, the plugin is being disposed */
480 [ # # ]: 0 : if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
481 [ # # ]: 0 : return;
482 : :
483 : 0 : g_warning ("Downloading icon: %s", error->message);
484 : : }
485 : :
486 [ - + ]: 1 : valent_notification_plugin_show_notification (self, packet, icon);
487 : : }
488 : :
489 : : static void
490 : 4 : valent_notification_plugin_handle_notification (ValentNotificationPlugin *self,
491 : : JsonNode *packet)
492 : : {
493 : 4 : const char *id;
494 : :
495 [ + - ]: 4 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
496 [ - + ]: 4 : g_assert (VALENT_IS_PACKET (packet));
497 : :
498 [ - + ]: 4 : if (!valent_packet_get_string (packet, "id", &id))
499 : : {
500 : 0 : g_debug ("%s(): expected \"id\" field holding a string",
501 : : G_STRFUNC);
502 : 0 : return;
503 : : }
504 : :
505 : : /* A report that a remote notification has been dismissed */
506 [ - + ]: 4 : if (valent_packet_check_field (packet, "isCancel"))
507 : : {
508 : 0 : g_hash_table_remove (self->cache, id);
509 : 0 : valent_device_plugin_hide_notification (VALENT_DEVICE_PLUGIN (self), id);
510 : 0 : return;
511 : : }
512 : :
513 : : /* A notification that should only be shown once, already existed on the
514 : : * device, and is already in the cache. This typically means the device just
515 : : * re-connected and is re-sending known notifications. */
516 [ - + - - ]: 4 : if (valent_packet_check_field (packet, "onlyOnce") &&
517 [ # # ]: 0 : valent_packet_check_field (packet, "silent") &&
518 : 0 : g_hash_table_contains (self->cache, id))
519 : : {
520 : : VALENT_NOTE ("skipping existing notification: %s", id);
521 : : return;
522 : : }
523 : :
524 [ - + ]: 4 : g_hash_table_replace (self->cache,
525 : 4 : g_strdup (id),
526 : 4 : json_node_ref (packet));
527 : :
528 [ + + ]: 4 : if (valent_packet_has_payload (packet))
529 : : {
530 : 1 : valent_notification_plugin_download_icon (self,
531 : : packet,
532 : : self->cancellable,
533 : : (GAsyncReadyCallback)valent_notification_plugin_download_icon_cb,
534 : 1 : json_node_ref (packet));
535 : : }
536 : : else
537 : : {
538 : 3 : valent_notification_plugin_show_notification (self, packet, NULL);
539 : : }
540 : : }
541 : :
542 : : static void
543 : 0 : valent_notification_plugin_handle_notification_action (ValentNotificationPlugin *self,
544 : : JsonNode *packet)
545 : : {
546 [ # # ]: 0 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
547 [ # # ]: 0 : g_assert (VALENT_IS_PACKET (packet));
548 : :
549 : 0 : VALENT_NOTE ("TODO: kdeconnect.notification.action");
550 : 0 : }
551 : :
552 : : static void
553 : 0 : valent_notification_plugin_handle_notification_reply (ValentNotificationPlugin *self,
554 : : JsonNode *packet)
555 : : {
556 [ # # ]: 0 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
557 [ # # ]: 0 : g_assert (VALENT_IS_PACKET (packet));
558 : :
559 : 0 : VALENT_NOTE ("TODO: kdeconnect.notification.reply");
560 : 0 : }
561 : :
562 : : static void
563 : 0 : valent_notification_plugin_handle_notification_request (ValentNotificationPlugin *self,
564 : : JsonNode *packet)
565 : : {
566 [ # # ]: 0 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
567 [ # # ]: 0 : g_assert (VALENT_IS_PACKET (packet));
568 : :
569 : 0 : VALENT_NOTE ("TODO: kdeconnect.notification.request");
570 : 0 : }
571 : :
572 : : static void
573 : 5 : valent_notification_plugin_request_notifications (ValentNotificationPlugin *self)
574 : : {
575 : 10 : g_autoptr (JsonBuilder) builder = NULL;
576 [ - + ]: 5 : g_autoptr (JsonNode) packet = NULL;
577 : :
578 [ + - ]: 5 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
579 : :
580 : 5 : valent_packet_init (&builder, "kdeconnect.notification.request");
581 : 5 : json_builder_set_member_name (builder, "request");
582 : 5 : json_builder_add_boolean_value (builder, TRUE);
583 : 5 : packet = valent_packet_end (&builder);
584 : :
585 [ + - ]: 5 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
586 : 5 : }
587 : :
588 : : static void
589 : 2 : valent_notification_plugin_close_notification (ValentNotificationPlugin *self,
590 : : const char *id)
591 : : {
592 : 4 : g_autoptr (JsonBuilder) builder = NULL;
593 [ - + ]: 2 : g_autoptr (JsonNode) packet = NULL;
594 : :
595 [ + - ]: 2 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
596 [ - + ]: 2 : g_assert (id != NULL);
597 : :
598 : 2 : valent_packet_init (&builder, "kdeconnect.notification.request");
599 : 2 : json_builder_set_member_name (builder, "cancel");
600 : 2 : json_builder_add_string_value (builder, id);
601 : 2 : packet = valent_packet_end (&builder);
602 : :
603 [ + - ]: 2 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
604 : 2 : }
605 : :
606 : : static void
607 : 4 : valent_notification_upload_execute_cb (GObject *object,
608 : : GAsyncResult *result,
609 : : gpointer user_data)
610 : : {
611 : 4 : ValentTransfer *transfer = VALENT_TRANSFER (object);
612 : 8 : g_autoptr (GError) error = NULL;
613 : :
614 [ + + + - ]: 6 : if (!valent_transfer_execute_finish (transfer, result, &error) &&
615 : 2 : !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
616 : : {
617 : 2 : g_autoptr (ValentDevice) device = NULL;
618 [ + - ]: 2 : g_autoptr (JsonNode) packet = NULL;
619 : :
620 : 2 : g_object_get (transfer,
621 : : "device", &device,
622 : : "packet", &packet,
623 : : NULL);
624 [ + - ]: 2 : valent_device_send_packet (device, packet, NULL, NULL, NULL);
625 : : }
626 : 4 : }
627 : :
628 : : static void
629 : 4 : valent_notification_plugin_send_notification_with_icon (ValentNotificationPlugin *self,
630 : : JsonNode *packet,
631 : : GIcon *icon)
632 : : {
633 [ + - ]: 4 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
634 [ - + ]: 4 : g_assert (VALENT_IS_PACKET (packet));
635 [ + - + - : 4 : g_assert (icon == NULL || G_IS_ICON (icon));
+ - - + ]
636 : :
637 [ + - + - : 4 : if (G_IS_ICON (icon))
+ - + - ]
638 : : {
639 : 4 : ValentDevice *device;
640 : 8 : g_autoptr (ValentTransfer) transfer = NULL;
641 : :
642 : 4 : device = valent_extension_get_object (VALENT_EXTENSION (self));
643 : 4 : transfer = valent_notification_upload_new (device, packet, icon);
644 : 4 : valent_transfer_execute (transfer,
645 : : NULL,
646 : : valent_notification_upload_execute_cb,
647 : : NULL);
648 [ + - ]: 4 : return;
649 : : }
650 : :
651 : 0 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
652 : : }
653 : :
654 : : /**
655 : : * valent_notification_plugin_send_notification:
656 : : * @self: a `ValentNotificationPlugin`
657 : : * @id: the notification id
658 : : * @appName: (nullable): the notifying application
659 : : * @title: (nullable): the notification title
660 : : * @body: (nullable): the notification body
661 : : * @icon: (nullable): a `GIcon`
662 : : *
663 : : * Send a notification to the remote device.
664 : : */
665 : : static void
666 : 6 : valent_notification_plugin_send_notification (ValentNotificationPlugin *self,
667 : : const char *id,
668 : : const char *appName,
669 : : const char *title,
670 : : const char *body,
671 : : GIcon *icon)
672 : : {
673 : 6 : g_autoptr (JsonBuilder) builder = NULL;
674 [ - + - - ]: 6 : g_autoptr (JsonNode) packet = NULL;
675 [ + - - - ]: 6 : g_autofree char *ticker = NULL;
676 : :
677 [ + - ]: 6 : g_return_if_fail (VALENT_IS_NOTIFICATION_PLUGIN (self));
678 [ - + ]: 6 : g_return_if_fail (id != NULL);
679 [ + + + - : 6 : g_return_if_fail (icon == NULL || G_IS_ICON (icon));
+ - - + ]
680 : :
681 : : /* Build packet */
682 : 6 : valent_packet_init (&builder, "kdeconnect.notification");
683 : 6 : json_builder_set_member_name (builder, "id");
684 : 6 : json_builder_add_string_value (builder, id);
685 : :
686 : : /* Application Name */
687 : 6 : json_builder_set_member_name (builder, "appName");
688 [ + + ]: 7 : json_builder_add_string_value (builder, appName ? appName : "Valent");
689 : :
690 : : /* Title & Body (aka Ticker) */
691 : 6 : json_builder_set_member_name (builder, "title");
692 [ + + ]: 7 : json_builder_add_string_value (builder, title ? title : "");
693 : 6 : json_builder_set_member_name (builder, "body");
694 [ + + ]: 7 : json_builder_add_string_value (builder, body ? body : "");
695 : :
696 : 6 : ticker = g_strdup_printf ("%s: %s", title, body);
697 : 6 : json_builder_set_member_name (builder, "ticker");
698 : 6 : json_builder_add_string_value (builder, ticker);
699 : :
700 : 6 : packet = valent_packet_end (&builder);
701 : :
702 [ + + ]: 6 : if (icon == NULL)
703 : 2 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
704 : : else
705 : 4 : valent_notification_plugin_send_notification_with_icon (self, packet, icon);
706 : : }
707 : :
708 : : /*
709 : : * GActions
710 : : */
711 : : static void
712 : 1 : notification_action_action (GSimpleAction *action,
713 : : GVariant *parameter,
714 : : gpointer user_data)
715 : : {
716 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (user_data);
717 : 2 : g_autoptr (JsonBuilder) builder = NULL;
718 [ - + ]: 1 : g_autoptr (JsonNode) packet = NULL;
719 : 1 : char *id;
720 : 1 : char *name;
721 : :
722 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
723 : :
724 : 1 : g_variant_get (parameter, "(&s&s)", &id, &name);
725 : :
726 : 1 : valent_packet_init (&builder, "kdeconnect.notification.action");
727 : 1 : json_builder_set_member_name (builder, "key");
728 : 1 : json_builder_add_string_value (builder, id);
729 : 1 : json_builder_set_member_name (builder, "action");
730 : 1 : json_builder_add_string_value (builder, name);
731 : 1 : packet = valent_packet_end (&builder);
732 : :
733 [ + - ]: 1 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
734 : 1 : }
735 : :
736 : : static void
737 : 1 : notification_cancel_action (GSimpleAction *action,
738 : : GVariant *parameter,
739 : : gpointer user_data)
740 : : {
741 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (user_data);
742 : 1 : const char *id;
743 : 2 : g_autoptr (JsonBuilder) builder = NULL;
744 [ - + ]: 1 : g_autoptr (JsonNode) packet = NULL;
745 : :
746 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
747 : :
748 : 1 : id = g_variant_get_string (parameter, NULL);
749 : :
750 : 1 : valent_packet_init (&builder, "kdeconnect.notification");
751 : 1 : json_builder_set_member_name (builder, "id");
752 : 1 : json_builder_add_string_value (builder, id);
753 : 1 : json_builder_set_member_name (builder, "isCancel");
754 : 1 : json_builder_add_boolean_value (builder, TRUE);
755 : 1 : packet = valent_packet_end (&builder);
756 : :
757 [ + - ]: 1 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
758 : 1 : }
759 : :
760 : : static void
761 : 1 : notification_close_action (GSimpleAction *action,
762 : : GVariant *parameter,
763 : : gpointer user_data)
764 : : {
765 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (user_data);
766 : 1 : const char *id;
767 : :
768 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
769 : :
770 : 1 : id = g_variant_get_string (parameter, NULL);
771 : 1 : valent_notification_plugin_close_notification (self, id);
772 : 1 : }
773 : :
774 : : static void
775 : 1 : notification_reply_action (GSimpleAction *action,
776 : : GVariant *parameter,
777 : : gpointer user_data)
778 : : {
779 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (user_data);
780 : 1 : const char *reply_id;
781 : 1 : const char *message;
782 : 1 : g_autoptr (GVariant) notificationv = NULL;
783 : :
784 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
785 : :
786 : 1 : g_variant_get (parameter, "(&s&sv)", &reply_id, &message, ¬ificationv);
787 : :
788 : : /* If the reply ID is empty, we've received a broken request */
789 [ + - - + ]: 1 : if (reply_id == NULL || *reply_id == '\0')
790 : : {
791 : 0 : g_debug ("%s(): expected requestReplyId", G_STRFUNC);
792 [ # # ]: 0 : return;
793 : : }
794 : :
795 : : /* If the message is empty, we're being asked to show the dialog */
796 [ + - - + ]: 1 : if (message == NULL || *message == '\0')
797 : : {
798 : 0 : g_warning ("%s(): reply is empty", G_STRFUNC);
799 : : }
800 : : else
801 : : {
802 : 1 : g_autoptr (JsonBuilder) builder = NULL;
803 [ - + ]: 1 : g_autoptr (JsonNode) packet = NULL;
804 : :
805 : 1 : valent_packet_init (&builder, "kdeconnect.notification.reply");
806 : 1 : json_builder_set_member_name (builder, "requestReplyId");
807 : 1 : json_builder_add_string_value (builder, reply_id);
808 : 1 : json_builder_set_member_name (builder, "message");
809 : 1 : json_builder_add_string_value (builder, message);
810 : 1 : packet = valent_packet_end (&builder);
811 : :
812 [ + - ]: 1 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
813 : : }
814 : : }
815 : :
816 : : static void
817 : 1 : notification_send_action (GSimpleAction *action,
818 : : GVariant *parameter,
819 : : gpointer user_data)
820 : : {
821 : 1 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (user_data);
822 : 1 : GVariantDict dict;
823 : 2 : g_autofree char *id = NULL;
824 : 1 : const char *app = NULL;
825 : 1 : const char *title = NULL;
826 : 1 : const char *body = NULL;
827 : 1 : g_autoptr (GVariant) iconv = NULL;
828 [ + - ]: 1 : g_autoptr (GIcon) icon = NULL;
829 : :
830 [ + - ]: 1 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
831 : :
832 : 1 : g_variant_dict_init (&dict, parameter);
833 : :
834 : : /* Use a random ID as a fallback */
835 [ - + ]: 1 : if (!g_variant_dict_lookup (&dict, "id", "s", &id))
836 : 0 : id = g_uuid_string_random ();
837 : :
838 : 1 : g_variant_dict_lookup (&dict, "application", "&s", &app);
839 : 1 : g_variant_dict_lookup (&dict, "title", "&s", &title);
840 : 1 : g_variant_dict_lookup (&dict, "body", "&s", &body);
841 : :
842 : : /* Check for a serialized GIcon */
843 : 1 : iconv = g_variant_dict_lookup_value (&dict, "icon", G_VARIANT_TYPE ("(sv)"));
844 : :
845 [ + - ]: 1 : if (iconv != NULL)
846 : 1 : icon = g_icon_deserialize (iconv);
847 : :
848 : 1 : valent_notification_plugin_send_notification (self, id, app, title, body, icon);
849 : :
850 [ + - ]: 1 : g_variant_dict_clear (&dict);
851 : 1 : }
852 : :
853 : : static const GActionEntry actions[] = {
854 : : {"action", notification_action_action, "(ss)", NULL, NULL},
855 : : {"cancel", notification_cancel_action, "s", NULL, NULL},
856 : : {"close", notification_close_action, "s", NULL, NULL},
857 : : {"reply", notification_reply_action, "(ssv)", NULL, NULL},
858 : : {"send", notification_send_action, "a{sv}", NULL, NULL},
859 : : };
860 : :
861 : : /*
862 : : * ValentDevicePlugin
863 : : */
864 : : static void
865 : 17 : valent_notification_plugin_update_state (ValentDevicePlugin *plugin,
866 : : ValentDeviceState state)
867 : : {
868 : 17 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (plugin);
869 : 17 : gboolean available;
870 : :
871 [ + - ]: 17 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (self));
872 : :
873 : 17 : available = (state & VALENT_DEVICE_STATE_CONNECTED) != 0 &&
874 : : (state & VALENT_DEVICE_STATE_PAIRED) != 0;
875 : :
876 : 17 : valent_extension_toggle_actions (VALENT_EXTENSION (plugin), available);
877 : 17 : valent_notification_plugin_watch_notifications (self, available);
878 : :
879 : : /* Request Notifications */
880 [ + + ]: 17 : if (available)
881 : : {
882 : 5 : valent_notification_plugin_request_notifications (self);
883 : 17 : VALENT_NOTE ("TODO: send active notifications");
884 : : }
885 : 17 : }
886 : :
887 : : static void
888 : 4 : valent_notification_plugin_handle_packet (ValentDevicePlugin *plugin,
889 : : const char *type,
890 : : JsonNode *packet)
891 : : {
892 : 4 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (plugin);
893 : :
894 [ + - ]: 4 : g_assert (VALENT_IS_NOTIFICATION_PLUGIN (plugin));
895 [ - + ]: 4 : g_assert (type != NULL);
896 [ - + ]: 4 : g_assert (VALENT_IS_PACKET (packet));
897 : :
898 [ + - ]: 4 : if (g_str_equal (type, "kdeconnect.notification"))
899 : 4 : valent_notification_plugin_handle_notification (self, packet);
900 : :
901 [ # # ]: 0 : else if (g_str_equal (type, "kdeconnect.notification.action"))
902 : 0 : valent_notification_plugin_handle_notification_action (self, packet);
903 : :
904 [ # # ]: 0 : else if (g_str_equal (type, "kdeconnect.notification.reply"))
905 : 0 : valent_notification_plugin_handle_notification_reply (self, packet);
906 : :
907 [ # # ]: 0 : else if (g_str_equal (type, "kdeconnect.notification.request"))
908 : 0 : valent_notification_plugin_handle_notification_request (self, packet);
909 : :
910 : : else
911 : 0 : g_assert_not_reached ();
912 : 4 : }
913 : :
914 : : /*
915 : : * ValentObject
916 : : */
917 : : static void
918 : 12 : valent_notification_plugin_destroy (ValentObject *object)
919 : : {
920 : 12 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (object);
921 : :
922 : 12 : valent_notification_plugin_watch_notifications (self, FALSE);
923 : :
924 : : /* Clear the cache and cancel any pending operations
925 : : */
926 [ + + ]: 12 : g_clear_pointer (&self->cache, g_hash_table_unref);
927 : 12 : g_cancellable_cancel (self->cancellable);
928 [ + + ]: 12 : g_clear_object (&self->cancellable);
929 : :
930 : 12 : VALENT_OBJECT_CLASS (valent_notification_plugin_parent_class)->destroy (object);
931 : 12 : }
932 : :
933 : : /*
934 : : * GObject
935 : : */
936 : : static void
937 : 6 : valent_notification_plugin_constructed (GObject *object)
938 : : {
939 : 6 : ValentNotificationPlugin *self = VALENT_NOTIFICATION_PLUGIN (object);
940 : 6 : ValentDevicePlugin *plugin = VALENT_DEVICE_PLUGIN (object);
941 : :
942 : 6 : self->cancellable = g_cancellable_new ();
943 : 6 : self->notifications = valent_notifications_get_default();
944 : 6 : self->session = valent_session_get_default ();
945 : :
946 : 6 : g_action_map_add_action_entries (G_ACTION_MAP (plugin),
947 : : actions,
948 : : G_N_ELEMENTS (actions),
949 : : plugin);
950 : :
951 : 6 : self->cache = g_hash_table_new_full (g_str_hash,
952 : : g_str_equal,
953 : : g_free,
954 : : (GDestroyNotify)json_node_unref);
955 : :
956 : 6 : G_OBJECT_CLASS (valent_notification_plugin_parent_class)->constructed (object);
957 : 6 : }
958 : :
959 : : static void
960 : 18 : valent_notification_plugin_class_init (ValentNotificationPluginClass *klass)
961 : : {
962 : 18 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
963 : 18 : ValentObjectClass *vobject_class = VALENT_OBJECT_CLASS (klass);
964 : 18 : ValentDevicePluginClass *plugin_class = VALENT_DEVICE_PLUGIN_CLASS (klass);
965 : :
966 : 18 : object_class->constructed = valent_notification_plugin_constructed;
967 : :
968 : 18 : vobject_class->destroy = valent_notification_plugin_destroy;
969 : :
970 : 18 : plugin_class->handle_packet = valent_notification_plugin_handle_packet;
971 : 18 : plugin_class->update_state = valent_notification_plugin_update_state;
972 : : }
973 : :
974 : : static void
975 : 6 : valent_notification_plugin_init (ValentNotificationPlugin *self)
976 : : {
977 : 6 : }
978 : :
|
