1/*
2 * Copyright © 2010 Codethink Limited
3 * Copyright © 2011 Canonical Limited
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Authors: Ryan Lortie <desrt@desrt.ca>
19 */
20
21#include "config.h"
22
23#include "gactiongroupexporter.h"
24
25#include "gdbusmethodinvocation.h"
26#include "gremoteactiongroup.h"
27#include "gdbusintrospection.h"
28#include "gdbusconnection.h"
29#include "gactiongroup.h"
30#include "gdbuserror.h"
31
32/**
33 * SECTION:gactiongroupexporter
34 * @title: GActionGroup exporter
35 * @include: gio/gio.h
36 * @short_description: Export GActionGroups on D-Bus
37 * @see_also: #GActionGroup, #GDBusActionGroup
38 *
39 * These functions support exporting a #GActionGroup on D-Bus.
40 * The D-Bus interface that is used is a private implementation
41 * detail.
42 *
43 * To access an exported #GActionGroup remotely, use
44 * g_dbus_action_group_get() to obtain a #GDBusActionGroup.
45 */
46
47static GVariant *
48g_action_group_describe_action (GActionGroup *action_group,
49 const gchar *name)
50{
51 const GVariantType *type;
52 GVariantBuilder builder;
53 gboolean enabled;
54 GVariant *state;
55
56 g_variant_builder_init (builder: &builder, G_VARIANT_TYPE ("(bgav)"));
57
58 enabled = g_action_group_get_action_enabled (action_group, action_name: name);
59 g_variant_builder_add (builder: &builder, format_string: "b", enabled);
60
61 if ((type = g_action_group_get_action_parameter_type (action_group, action_name: name)))
62 {
63 gchar *str = g_variant_type_dup_string (type);
64 g_variant_builder_add (builder: &builder, format_string: "g", str);
65 g_free (mem: str);
66 }
67 else
68 g_variant_builder_add (builder: &builder, format_string: "g", "");
69
70 g_variant_builder_open (builder: &builder, G_VARIANT_TYPE ("av"));
71 if ((state = g_action_group_get_action_state (action_group, action_name: name)))
72 {
73 g_variant_builder_add (builder: &builder, format_string: "v", state);
74 g_variant_unref (value: state);
75 }
76 g_variant_builder_close (builder: &builder);
77
78 return g_variant_builder_end (builder: &builder);
79}
80
81/* Using XML saves us dozens of relocations vs. using the introspection
82 * structure types. We only need to burn cycles and memory if we
83 * actually use the exporter -- not in every single app using GIO.
84 *
85 * It's also a lot easier to read. :)
86 *
87 * For documentation of this interface, see
88 * https://wiki.gnome.org/Projects/GLib/GApplication/DBusAPI
89 */
90const char org_gtk_Actions_xml[] =
91 "<node>"
92 " <interface name='org.gtk.Actions'>"
93 " <method name='List'>"
94 " <arg type='as' name='list' direction='out'/>"
95 " </method>"
96 " <method name='Describe'>"
97 " <arg type='s' name='action_name' direction='in'/>"
98 " <arg type='(bgav)' name='description' direction='out'/>"
99 " </method>"
100 " <method name='DescribeAll'>"
101 " <arg type='a{s(bgav)}' name='descriptions' direction='out'/>"
102 " </method>"
103 " <method name='Activate'>"
104 " <arg type='s' name='action_name' direction='in'/>"
105 " <arg type='av' name='parameter' direction='in'/>"
106 " <arg type='a{sv}' name='platform_data' direction='in'/>"
107 " </method>"
108 " <method name='SetState'>"
109 " <arg type='s' name='action_name' direction='in'/>"
110 " <arg type='v' name='value' direction='in'/>"
111 " <arg type='a{sv}' name='platform_data' direction='in'/>"
112 " </method>"
113 " <signal name='Changed'>"
114 " <arg type='as' name='removals'/>"
115 " <arg type='a{sb}' name='enable_changes'/>"
116 " <arg type='a{sv}' name='state_changes'/>"
117 " <arg type='a{s(bgav)}' name='additions'/>"
118 " </signal>"
119 " </interface>"
120 "</node>";
121
122static GDBusInterfaceInfo *org_gtk_Actions;
123
124typedef struct
125{
126 GActionGroup *action_group;
127 GDBusConnection *connection;
128 GMainContext *context;
129 gchar *object_path;
130 GHashTable *pending_changes;
131 GSource *pending_source;
132} GActionGroupExporter;
133
134#define ACTION_ADDED_EVENT (1u<<0)
135#define ACTION_REMOVED_EVENT (1u<<1)
136#define ACTION_STATE_CHANGED_EVENT (1u<<2)
137#define ACTION_ENABLED_CHANGED_EVENT (1u<<3)
138
139static gboolean
140g_action_group_exporter_dispatch_events (gpointer user_data)
141{
142 GActionGroupExporter *exporter = user_data;
143 GVariantBuilder removes;
144 GVariantBuilder enabled_changes;
145 GVariantBuilder state_changes;
146 GVariantBuilder adds;
147 GHashTableIter iter;
148 gpointer value;
149 gpointer key;
150
151 g_variant_builder_init (builder: &removes, G_VARIANT_TYPE_STRING_ARRAY);
152 g_variant_builder_init (builder: &enabled_changes, G_VARIANT_TYPE ("a{sb}"));
153 g_variant_builder_init (builder: &state_changes, G_VARIANT_TYPE ("a{sv}"));
154 g_variant_builder_init (builder: &adds, G_VARIANT_TYPE ("a{s(bgav)}"));
155
156 g_hash_table_iter_init (iter: &iter, hash_table: exporter->pending_changes);
157 while (g_hash_table_iter_next (iter: &iter, key: &key, value: &value))
158 {
159 guint events = GPOINTER_TO_INT (value);
160 const gchar *name = key;
161
162 /* Adds and removes are incompatible with enabled or state
163 * changes, but we must report at least one event.
164 */
165 g_assert (((events & (ACTION_ENABLED_CHANGED_EVENT | ACTION_STATE_CHANGED_EVENT)) == 0) !=
166 ((events & (ACTION_REMOVED_EVENT | ACTION_ADDED_EVENT)) == 0));
167
168 if (events & ACTION_REMOVED_EVENT)
169 g_variant_builder_add (builder: &removes, format_string: "s", name);
170
171 if (events & ACTION_ENABLED_CHANGED_EVENT)
172 {
173 gboolean enabled;
174
175 enabled = g_action_group_get_action_enabled (action_group: exporter->action_group, action_name: name);
176 g_variant_builder_add (builder: &enabled_changes, format_string: "{sb}", name, enabled);
177 }
178
179 if (events & ACTION_STATE_CHANGED_EVENT)
180 {
181 GVariant *state;
182
183 state = g_action_group_get_action_state (action_group: exporter->action_group, action_name: name);
184 g_variant_builder_add (builder: &state_changes, format_string: "{sv}", name, state);
185 g_variant_unref (value: state);
186 }
187
188 if (events & ACTION_ADDED_EVENT)
189 {
190 GVariant *description;
191
192 description = g_action_group_describe_action (action_group: exporter->action_group, name);
193 g_variant_builder_add (builder: &adds, format_string: "{s@(bgav)}", name, description);
194 }
195 }
196
197 g_hash_table_remove_all (hash_table: exporter->pending_changes);
198
199 g_dbus_connection_emit_signal (connection: exporter->connection, NULL, object_path: exporter->object_path,
200 interface_name: "org.gtk.Actions", signal_name: "Changed",
201 parameters: g_variant_new (format_string: "(asa{sb}a{sv}a{s(bgav)})",
202 &removes, &enabled_changes,
203 &state_changes, &adds),
204 NULL);
205
206 exporter->pending_source = NULL;
207
208 return FALSE;
209}
210
211static void
212g_action_group_exporter_flush_queue (GActionGroupExporter *exporter)
213{
214 if (exporter->pending_source)
215 {
216 g_source_destroy (source: exporter->pending_source);
217 g_action_group_exporter_dispatch_events (user_data: exporter);
218 g_assert (exporter->pending_source == NULL);
219 }
220}
221
222static guint
223g_action_group_exporter_get_events (GActionGroupExporter *exporter,
224 const gchar *name)
225{
226 return (gsize) g_hash_table_lookup (hash_table: exporter->pending_changes, key: name);
227}
228
229static void
230g_action_group_exporter_set_events (GActionGroupExporter *exporter,
231 const gchar *name,
232 guint events)
233{
234 gboolean have_events;
235 gboolean is_queued;
236
237 if (events != 0)
238 g_hash_table_insert (hash_table: exporter->pending_changes, key: g_strdup (str: name), GINT_TO_POINTER (events));
239 else
240 g_hash_table_remove (hash_table: exporter->pending_changes, key: name);
241
242 have_events = g_hash_table_size (hash_table: exporter->pending_changes) > 0;
243 is_queued = exporter->pending_source != NULL;
244
245 if (have_events && !is_queued)
246 {
247 GSource *source;
248
249 source = g_idle_source_new ();
250 exporter->pending_source = source;
251 g_source_set_callback (source, func: g_action_group_exporter_dispatch_events, data: exporter, NULL);
252 g_source_set_name (source, name: "[gio] g_action_group_exporter_dispatch_events");
253 g_source_attach (source, context: exporter->context);
254 g_source_unref (source);
255 }
256
257 if (!have_events && is_queued)
258 {
259 g_source_destroy (source: exporter->pending_source);
260 exporter->pending_source = NULL;
261 }
262}
263
264static void
265g_action_group_exporter_action_added (GActionGroup *action_group,
266 const gchar *action_name,
267 gpointer user_data)
268{
269 GActionGroupExporter *exporter = user_data;
270 guint event_mask;
271
272 event_mask = g_action_group_exporter_get_events (exporter, name: action_name);
273
274 /* The action is new, so we should not have any pending
275 * enabled-changed or state-changed signals for it.
276 */
277 g_assert (~event_mask & (ACTION_STATE_CHANGED_EVENT |
278 ACTION_ENABLED_CHANGED_EVENT));
279
280 event_mask |= ACTION_ADDED_EVENT;
281
282 g_action_group_exporter_set_events (exporter, name: action_name, events: event_mask);
283}
284
285static void
286g_action_group_exporter_action_removed (GActionGroup *action_group,
287 const gchar *action_name,
288 gpointer user_data)
289{
290 GActionGroupExporter *exporter = user_data;
291 guint event_mask;
292
293 event_mask = g_action_group_exporter_get_events (exporter, name: action_name);
294
295 /* If the add event for this is still queued then just cancel it since
296 * it's gone now.
297 *
298 * If the event was freshly added, there should not have been any
299 * enabled or state changed events.
300 */
301 if (event_mask & ACTION_ADDED_EVENT)
302 {
303 g_assert (~event_mask & ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT));
304 event_mask &= ~ACTION_ADDED_EVENT;
305 }
306
307 /* Otherwise, queue a remove event. Drop any state or enabled changes
308 * that were queued before the remove. */
309 else
310 {
311 event_mask |= ACTION_REMOVED_EVENT;
312 event_mask &= ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT);
313 }
314
315 g_action_group_exporter_set_events (exporter, name: action_name, events: event_mask);
316}
317
318static void
319g_action_group_exporter_action_state_changed (GActionGroup *action_group,
320 const gchar *action_name,
321 GVariant *value,
322 gpointer user_data)
323{
324 GActionGroupExporter *exporter = user_data;
325 guint event_mask;
326
327 event_mask = g_action_group_exporter_get_events (exporter, name: action_name);
328
329 /* If it was removed, it must have been added back. Otherwise, why
330 * are we hearing about changes?
331 */
332 g_assert (~event_mask & ACTION_REMOVED_EVENT ||
333 event_mask & ACTION_ADDED_EVENT);
334
335 /* If it is freshly added, don't also bother with the state change
336 * signal since the updated state will be sent as part of the pending
337 * add message.
338 */
339 if (~event_mask & ACTION_ADDED_EVENT)
340 event_mask |= ACTION_STATE_CHANGED_EVENT;
341
342 g_action_group_exporter_set_events (exporter, name: action_name, events: event_mask);
343}
344
345static void
346g_action_group_exporter_action_enabled_changed (GActionGroup *action_group,
347 const gchar *action_name,
348 gboolean enabled,
349 gpointer user_data)
350{
351 GActionGroupExporter *exporter = user_data;
352 guint event_mask;
353
354 event_mask = g_action_group_exporter_get_events (exporter, name: action_name);
355
356 /* Reasoning as above. */
357 g_assert (~event_mask & ACTION_REMOVED_EVENT ||
358 event_mask & ACTION_ADDED_EVENT);
359
360 if (~event_mask & ACTION_ADDED_EVENT)
361 event_mask |= ACTION_ENABLED_CHANGED_EVENT;
362
363 g_action_group_exporter_set_events (exporter, name: action_name, events: event_mask);
364}
365
366static void
367org_gtk_Actions_method_call (GDBusConnection *connection,
368 const gchar *sender,
369 const gchar *object_path,
370 const gchar *interface_name,
371 const gchar *method_name,
372 GVariant *parameters,
373 GDBusMethodInvocation *invocation,
374 gpointer user_data)
375{
376 GActionGroupExporter *exporter = user_data;
377 GVariant *result = NULL;
378
379 g_action_group_exporter_flush_queue (exporter);
380
381 if (g_str_equal (v1: method_name, v2: "List"))
382 {
383 gchar **list;
384
385 list = g_action_group_list_actions (action_group: exporter->action_group);
386 result = g_variant_new (format_string: "(^as)", list);
387 g_strfreev (str_array: list);
388 }
389
390 else if (g_str_equal (v1: method_name, v2: "Describe"))
391 {
392 const gchar *name;
393 GVariant *desc;
394
395 g_variant_get (value: parameters, format_string: "(&s)", &name);
396
397 if (!g_action_group_has_action (action_group: exporter->action_group, action_name: name))
398 {
399 g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, code: G_DBUS_ERROR_INVALID_ARGS,
400 format: "The named action ('%s') does not exist.", name);
401 return;
402 }
403
404 desc = g_action_group_describe_action (action_group: exporter->action_group, name);
405 result = g_variant_new (format_string: "(@(bgav))", desc);
406 }
407
408 else if (g_str_equal (v1: method_name, v2: "DescribeAll"))
409 {
410 GVariantBuilder builder;
411 gchar **list;
412 gint i;
413
414 list = g_action_group_list_actions (action_group: exporter->action_group);
415 g_variant_builder_init (builder: &builder, G_VARIANT_TYPE ("a{s(bgav)}"));
416 for (i = 0; list[i]; i++)
417 {
418 const gchar *name = list[i];
419 GVariant *description;
420
421 description = g_action_group_describe_action (action_group: exporter->action_group, name);
422 g_variant_builder_add (builder: &builder, format_string: "{s@(bgav)}", name, description);
423 }
424 result = g_variant_new (format_string: "(a{s(bgav)})", &builder);
425 g_strfreev (str_array: list);
426 }
427
428 else if (g_str_equal (v1: method_name, v2: "Activate"))
429 {
430 GVariant *parameter = NULL;
431 GVariant *platform_data;
432 GVariantIter *iter;
433 const gchar *name;
434
435 g_variant_get (value: parameters, format_string: "(&sav@a{sv})", &name, &iter, &platform_data);
436 g_variant_iter_next (iter, format_string: "v", &parameter);
437 g_variant_iter_free (iter);
438
439 if (G_IS_REMOTE_ACTION_GROUP (exporter->action_group))
440 g_remote_action_group_activate_action_full (G_REMOTE_ACTION_GROUP (exporter->action_group),
441 action_name: name, parameter, platform_data);
442 else
443 g_action_group_activate_action (action_group: exporter->action_group, action_name: name, parameter);
444
445 if (parameter)
446 g_variant_unref (value: parameter);
447
448 g_variant_unref (value: platform_data);
449 }
450
451 else if (g_str_equal (v1: method_name, v2: "SetState"))
452 {
453 GVariant *platform_data;
454 const gchar *name;
455 GVariant *state;
456
457 g_variant_get (value: parameters, format_string: "(&sv@a{sv})", &name, &state, &platform_data);
458
459 if (G_IS_REMOTE_ACTION_GROUP (exporter->action_group))
460 g_remote_action_group_change_action_state_full (G_REMOTE_ACTION_GROUP (exporter->action_group),
461 action_name: name, value: state, platform_data);
462 else
463 g_action_group_change_action_state (action_group: exporter->action_group, action_name: name, value: state);
464
465 g_variant_unref (value: platform_data);
466 g_variant_unref (value: state);
467 }
468
469 else
470 g_assert_not_reached ();
471
472 g_dbus_method_invocation_return_value (invocation, parameters: result);
473}
474
475static void
476g_action_group_exporter_free (gpointer user_data)
477{
478 GActionGroupExporter *exporter = user_data;
479
480 g_signal_handlers_disconnect_by_func (exporter->action_group,
481 g_action_group_exporter_action_added, exporter);
482 g_signal_handlers_disconnect_by_func (exporter->action_group,
483 g_action_group_exporter_action_enabled_changed, exporter);
484 g_signal_handlers_disconnect_by_func (exporter->action_group,
485 g_action_group_exporter_action_state_changed, exporter);
486 g_signal_handlers_disconnect_by_func (exporter->action_group,
487 g_action_group_exporter_action_removed, exporter);
488
489 g_hash_table_unref (hash_table: exporter->pending_changes);
490 if (exporter->pending_source)
491 g_source_destroy (source: exporter->pending_source);
492
493 g_main_context_unref (context: exporter->context);
494 g_object_unref (object: exporter->connection);
495 g_object_unref (object: exporter->action_group);
496 g_free (mem: exporter->object_path);
497
498 g_slice_free (GActionGroupExporter, exporter);
499}
500
501/**
502 * g_dbus_connection_export_action_group:
503 * @connection: a #GDBusConnection
504 * @object_path: a D-Bus object path
505 * @action_group: a #GActionGroup
506 * @error: a pointer to a %NULL #GError, or %NULL
507 *
508 * Exports @action_group on @connection at @object_path.
509 *
510 * The implemented D-Bus API should be considered private. It is
511 * subject to change in the future.
512 *
513 * A given object path can only have one action group exported on it.
514 * If this constraint is violated, the export will fail and 0 will be
515 * returned (with @error set accordingly).
516 *
517 * You can unexport the action group using
518 * g_dbus_connection_unexport_action_group() with the return value of
519 * this function.
520 *
521 * The thread default main context is taken at the time of this call.
522 * All incoming action activations and state change requests are
523 * reported from this context. Any changes on the action group that
524 * cause it to emit signals must also come from this same context.
525 * Since incoming action activations and state change requests are
526 * rather likely to cause changes on the action group, this effectively
527 * limits a given action group to being exported from only one main
528 * context.
529 *
530 * Returns: the ID of the export (never zero), or 0 in case of failure
531 *
532 * Since: 2.32
533 **/
534guint
535g_dbus_connection_export_action_group (GDBusConnection *connection,
536 const gchar *object_path,
537 GActionGroup *action_group,
538 GError **error)
539{
540 const GDBusInterfaceVTable vtable = {
541 org_gtk_Actions_method_call, NULL, NULL, { 0 }
542 };
543 GActionGroupExporter *exporter;
544 guint id;
545
546 if G_UNLIKELY (org_gtk_Actions == NULL)
547 {
548 GError *error = NULL;
549 GDBusNodeInfo *info;
550
551 info = g_dbus_node_info_new_for_xml (xml_data: org_gtk_Actions_xml, error: &error);
552 if G_UNLIKELY (info == NULL)
553 g_error ("%s", error->message);
554 org_gtk_Actions = g_dbus_node_info_lookup_interface (info, name: "org.gtk.Actions");
555 g_assert (org_gtk_Actions != NULL);
556 g_dbus_interface_info_ref (info: org_gtk_Actions);
557 g_dbus_node_info_unref (info);
558 }
559
560 exporter = g_slice_new (GActionGroupExporter);
561 id = g_dbus_connection_register_object (connection, object_path, interface_info: org_gtk_Actions, vtable: &vtable,
562 user_data: exporter, user_data_free_func: g_action_group_exporter_free, error);
563
564 if (id == 0)
565 {
566 g_slice_free (GActionGroupExporter, exporter);
567 return 0;
568 }
569
570 exporter->context = g_main_context_ref_thread_default ();
571 exporter->pending_changes = g_hash_table_new_full (hash_func: g_str_hash, key_equal_func: g_str_equal, key_destroy_func: g_free, NULL);
572 exporter->pending_source = NULL;
573 exporter->action_group = g_object_ref (action_group);
574 exporter->connection = g_object_ref (connection);
575 exporter->object_path = g_strdup (str: object_path);
576
577 g_signal_connect (action_group, "action-added",
578 G_CALLBACK (g_action_group_exporter_action_added), exporter);
579 g_signal_connect (action_group, "action-removed",
580 G_CALLBACK (g_action_group_exporter_action_removed), exporter);
581 g_signal_connect (action_group, "action-state-changed",
582 G_CALLBACK (g_action_group_exporter_action_state_changed), exporter);
583 g_signal_connect (action_group, "action-enabled-changed",
584 G_CALLBACK (g_action_group_exporter_action_enabled_changed), exporter);
585
586 return id;
587}
588
589/**
590 * g_dbus_connection_unexport_action_group:
591 * @connection: a #GDBusConnection
592 * @export_id: the ID from g_dbus_connection_export_action_group()
593 *
594 * Reverses the effect of a previous call to
595 * g_dbus_connection_export_action_group().
596 *
597 * It is an error to call this function with an ID that wasn't returned
598 * from g_dbus_connection_export_action_group() or to call it with the
599 * same ID more than once.
600 *
601 * Since: 2.32
602 **/
603void
604g_dbus_connection_unexport_action_group (GDBusConnection *connection,
605 guint export_id)
606{
607 g_dbus_connection_unregister_object (connection, registration_id: export_id);
608}
609

source code of gtk/subprojects/glib/gio/gactiongroupexporter.c