gio/gactiongroupexporter.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  * Copyright © 2011 Canonical Limited
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public License as published
   7  * by the Free Software Foundation; either version 2 of the licence or (at
   8  * 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
  47 static GVariant *
  48 g_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, G_VARIANT_TYPE ("(bgav)"));
  57
  58   enabled = g_action_group_get_action_enabled (action_group, name);
  59   g_variant_builder_add (&builder, "b", enabled);
  60
  61   if ((type = g_action_group_get_action_parameter_type (action_group, name)))
  62     {
  63       gchar *str = g_variant_type_dup_string (type);
  64       g_variant_builder_add (&builder, "g", str);
  65       g_free (str);
  66     }
  67   else
  68     g_variant_builder_add (&builder, "g", "");
  69
  70   g_variant_builder_open (&builder, G_VARIANT_TYPE ("av"));
  71   if ((state = g_action_group_get_action_state (action_group, name)))
  72     {
  73       g_variant_builder_add (&builder, "v", state);
  74       g_variant_unref (state);
  75     }
  76   g_variant_builder_close (&builder);
  77
  78   return g_variant_builder_end (&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  */
  90 const 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
 122 static GDBusInterfaceInfo *org_gtk_Actions;
 123
 124 typedef 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
 139 static gboolean
 140 g_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 (&removes, G_VARIANT_TYPE_STRING_ARRAY);
 152   g_variant_builder_init (&enabled_changes, G_VARIANT_TYPE ("a{sb}"));
 153   g_variant_builder_init (&state_changes, G_VARIANT_TYPE ("a{sv}"));
 154   g_variant_builder_init (&adds, G_VARIANT_TYPE ("a{s(bgav)}"));
 155
 156   g_hash_table_iter_init (&iter, exporter->pending_changes);
 157   while (g_hash_table_iter_next (&iter, &key, &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 (&removes, "s", name);
 170
 171       if (events & ACTION_ENABLED_CHANGED_EVENT)
 172         {
 173           gboolean enabled;
 174
 175           enabled = g_action_group_get_action_enabled (exporter->action_group, name);
 176           g_variant_builder_add (&enabled_changes, "{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 (exporter->action_group, name);
 184           g_variant_builder_add (&state_changes, "{sv}", name, state);
 185           g_variant_unref (state);
 186         }
 187
 188       if (events & ACTION_ADDED_EVENT)
 189         {
 190           GVariant *description;
 191
 192           description = g_action_group_describe_action (exporter->action_group, name);
 193           g_variant_builder_add (&adds, "{s@(bgav)}", name, description);
 194         }
 195     }
 196
 197   g_hash_table_remove_all (exporter->pending_changes);
 198
 199   g_dbus_connection_emit_signal (exporter->connection, NULL, exporter->object_path,
 200                                  "org.gtk.Actions", "Changed",
 201                                  g_variant_new ("(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
 211 static void
 212 g_action_group_exporter_flush_queue (GActionGroupExporter *exporter)
 213 {
 214   if (exporter->pending_source)
 215     {
 216       g_source_destroy (exporter->pending_source);
 217       g_action_group_exporter_dispatch_events (exporter);
 218       g_assert (exporter->pending_source == NULL);
 219     }
 220 }
 221
 222 static guint
 223 g_action_group_exporter_get_events (GActionGroupExporter *exporter,
 224                                     const gchar          *name)
 225 {
 226   return (gsize) g_hash_table_lookup (exporter->pending_changes, name);
 227 }
 228
 229 static void
 230 g_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 (exporter->pending_changes, g_strdup (name), GINT_TO_POINTER (events));
 239   else
 240     g_hash_table_remove (exporter->pending_changes, name);
 241
 242   have_events = g_hash_table_size (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, g_action_group_exporter_dispatch_events, exporter, NULL);
 252       g_source_set_name (source, "[gio] g_action_group_exporter_dispatch_events");
 253       g_source_attach (source, exporter->context);
 254       g_source_unref (source);
 255     }
 256
 257   if (!have_events && is_queued)
 258     {
 259       g_source_destroy (exporter->pending_source);
 260       exporter->pending_source = NULL;
 261     }
 262 }
 263
 264 static void
 265 g_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, 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, action_name, event_mask);
 283 }
 284
 285 static void
 286 g_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, 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, action_name, event_mask);
 316 }
 317
 318 static void
 319 g_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, 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, action_name, event_mask);
 343 }
 344
 345 static void
 346 g_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, 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, action_name, event_mask);
 364 }
 365
 366 static void
 367 org_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 (method_name, "List"))
 382     {
 383       gchar **list;
 384
 385       list = g_action_group_list_actions (exporter->action_group);
 386       result = g_variant_new ("(^as)", list);
 387       g_strfreev (list);
 388     }
 389
 390   else if (g_str_equal (method_name, "Describe"))
 391     {
 392       const gchar *name;
 393       GVariant *desc;
 394
 395       g_variant_get (parameters, "(&s)", &name);
 396
 397       if (!g_action_group_has_action (exporter->action_group, name))
 398         {
 399           g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
 400                                                  "The named action ('%s') does not exist.", name);
 401           return;
 402         }
 403
 404       desc = g_action_group_describe_action (exporter->action_group, name);
 405       result = g_variant_new ("(@(bgav))", desc);
 406     }
 407
 408   else if (g_str_equal (method_name, "DescribeAll"))
 409     {
 410       GVariantBuilder builder;
 411       gchar **list;
 412       gint i;
 413
 414       list = g_action_group_list_actions (exporter->action_group);
 415       g_variant_builder_init (&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 (exporter->action_group, name);
 422           g_variant_builder_add (&builder, "{s@(bgav)}", name, description);
 423         }
 424       result = g_variant_new ("(a{s(bgav)})", &builder);
 425       g_strfreev (list);
 426     }
 427
 428   else if (g_str_equal (method_name, "Activate"))
 429     {
 430       GVariant *parameter = NULL;
 431       GVariant *platform_data;
 432       GVariantIter *iter;
 433       const gchar *name;
 434
 435       g_variant_get (parameters, "(&sav@a{sv})", &name, &iter, &platform_data);
 436       g_variant_iter_next (iter, "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                                                     name, parameter, platform_data);
 442       else
 443         g_action_group_activate_action (exporter->action_group, name, parameter);
 444
 445       if (parameter)
 446         g_variant_unref (parameter);
 447
 448       g_variant_unref (platform_data);
 449     }
 450
 451   else if (g_str_equal (method_name, "SetState"))
 452     {
 453       GVariant *platform_data;
 454       const gchar *name;
 455       GVariant *state;
 456
 457       g_variant_get (parameters, "(&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                                                         name, state, platform_data);
 462       else
 463         g_action_group_change_action_state (exporter->action_group, name, state);
 464
 465       g_variant_unref (platform_data);
 466       g_variant_unref (state);
 467     }
 468
 469   else
 470     g_assert_not_reached ();
 471
 472   g_dbus_method_invocation_return_value (invocation, result);
 473 }
 474
 475 static void
 476 g_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 (exporter->pending_changes);
 490   if (exporter->pending_source)
 491     g_source_destroy (exporter->pending_source);
 492
 493   g_main_context_unref (exporter->context);
 494   g_object_unref (exporter->connection);
 495   g_object_unref (exporter->action_group);
 496   g_free (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  **/
 534 guint
 535 g_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
 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 (org_gtk_Actions_xml, &error);
 552       if G_UNLIKELY (info == NULL)
 553         g_error ("%s", error->message);
 554       org_gtk_Actions = g_dbus_node_info_lookup_interface (info, "org.gtk.Actions");
 555       g_assert (org_gtk_Actions != NULL);
 556       g_dbus_interface_info_ref (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, org_gtk_Actions, &vtable,
 562                                           exporter, 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 (g_str_hash, g_str_equal, 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 (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  **/
 603 void
 604 g_dbus_connection_unexport_action_group (GDBusConnection *connection,
 605                                          guint            export_id)
 606 {
 607   g_dbus_connection_unregister_object (connection, export_id);
 608 }