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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Authors: Ryan Lortie <desrt@desrt.ca>
  21  */
  22
  23 #include "config.h"
  24
  25 #include "gactiongroupexporter.h"
  26
  27 #include "gdbusmethodinvocation.h"
  28 #include "gdbusintrospection.h"
  29 #include "gdbusconnection.h"
  30 #include "gactiongroup.h"
  31 #include "gapplication.h"
  32 #include "gdbuserror.h"
  33
  34 /**
  35  * SECTION:gactiongroupexporter
  36  * @title: GActionGroup exporter
  37  * @short_description: Export GActionGroups on D-Bus
  38  * @see_also: #GActionGroup, #GDBusActionGroup
  39  *
  40  * These functions support exporting a #GActionGroup on D-Bus.
  41  * The D-Bus interface that is used is a private implementation
  42  * detail.
  43  *
  44  * To access an exported #GActionGroup remotely, use
  45  * g_dbus_action_group_new() to obtain a #GDBusActionGroup.
  46  */
  47
  48 G_GNUC_INTERNAL GVariant *
  49 g_action_group_describe_action (GActionGroup *action_group,
  50                                 const gchar  *name)
  51 {
  52   const GVariantType *type;
  53   GVariantBuilder builder;
  54   gboolean enabled;
  55   GVariant *state;
  56
  57   g_variant_builder_init (&builder, G_VARIANT_TYPE ("(bgav)"));
  58
  59   enabled = g_action_group_get_action_enabled (action_group, name);
  60   g_variant_builder_add (&builder, "b", enabled);
  61
  62   if ((type = g_action_group_get_action_parameter_type (action_group, name)))
  63     {
  64       gchar *str = g_variant_type_dup_string (type);
  65       g_variant_builder_add (&builder, "g", str);
  66       g_free (str);
  67     }
  68   else
  69     g_variant_builder_add (&builder, "g", "");
  70
  71   g_variant_builder_open (&builder, G_VARIANT_TYPE ("av"));
  72   if ((state = g_action_group_get_action_state (action_group, name)))
  73     {
  74       g_variant_builder_add (&builder, "v", state);
  75       g_variant_unref (state);
  76     }
  77   g_variant_builder_close (&builder);
  78
  79   return g_variant_builder_end (&builder);
  80 }
  81
  82 /* Using XML saves us dozens of relocations vs. using the introspection
  83  * structure types.  We only need to burn cycles and memory if we
  84  * actually use the exporter -- not in every single app using GIO.
  85  *
  86  * It's also a lot easier to read. :)
  87  */
  88 const char org_gtk_Actions_xml[] =
  89   "<node>"
  90   "  <interface name='org.gtk.Actions'>"
  91   "    <method name='List'>"
  92   "      <arg type='as' name='list' direction='out'/>"
  93   "    </method>"
  94   "    <method name='Describe'>"
  95   "      <arg type='s' name='action_name' direction='in'/>"
  96   "      <arg type='(bgav)' name='description' direction='out'/>"
  97   "    </method>"
  98   "    <method name='DescribeAll'>"
  99   "      <arg type='a{s(bgav)}' name='descriptions' direction='out'/>"
 100   "    </method>"
 101   "    <method name='Activate'>"
 102   "      <arg type='s' name='action_name' direction='in'/>"
 103   "      <arg type='av' name='parameter' direction='in'/>"
 104   "      <arg type='a{sv}' name='platform_data' direction='in'/>"
 105   "    </method>"
 106   "    <method name='SetState'>"
 107   "      <arg type='s' name='action_name' direction='in'/>"
 108   "      <arg type='v' name='value' direction='in'/>"
 109   "      <arg type='a{sv}' name='platform_data' direction='in'/>"
 110   "    </method>"
 111   "    <signal name='Changed'>"
 112   "      <arg type='as' name='removals'/>"
 113   "      <arg type='a{sb}' name='enable_changes'/>"
 114   "      <arg type='a{sv}' name='state_changes'/>"
 115   "      <arg type='a{s(bgav)}' name='additions'/>"
 116   "    </signal>"
 117   "  </interface>"
 118   "</node>";
 119
 120 static GDBusInterfaceInfo *org_gtk_Actions;
 121 static GHashTable *exported_groups;
 122
 123 typedef struct
 124 {
 125   GActionGroup    *action_group;
 126   GDBusConnection *connection;
 127   gchar           *object_path;
 128   guint            registration_id;
 129   GHashTable      *pending_changes;
 130   guint            pending_id;
 131   gulong           signal_ids[4];
 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_id = 0;
 207
 208   return FALSE;
 209 }
 210
 211 static guint
 212 g_action_group_exporter_get_events (GActionGroupExporter *exporter,
 213                                     const gchar          *name)
 214 {
 215   return (gsize) g_hash_table_lookup (exporter->pending_changes, name);
 216 }
 217
 218 static void
 219 g_action_group_exporter_set_events (GActionGroupExporter *exporter,
 220                                     const gchar          *name,
 221                                     guint                 events)
 222 {
 223   gboolean have_events;
 224   gboolean is_queued;
 225
 226   if (events != 0)
 227     g_hash_table_insert (exporter->pending_changes, g_strdup (name), GINT_TO_POINTER (events));
 228   else
 229     g_hash_table_remove (exporter->pending_changes, name);
 230
 231   have_events = g_hash_table_size (exporter->pending_changes) > 0;
 232   is_queued = exporter->pending_id > 0;
 233
 234   if (have_events && !is_queued)
 235     exporter->pending_id = g_idle_add (g_action_group_exporter_dispatch_events, exporter);
 236
 237   if (!have_events && is_queued)
 238     {
 239       g_source_remove (exporter->pending_id);
 240       exporter->pending_id = 0;
 241     }
 242 }
 243
 244 static void
 245 g_action_group_exporter_action_added (GActionGroup *action_group,
 246                                       const gchar  *action_name,
 247                                       gpointer      user_data)
 248 {
 249   GActionGroupExporter *exporter = user_data;
 250   guint event_mask;
 251
 252   event_mask = g_action_group_exporter_get_events (exporter, action_name);
 253
 254   /* The action is new, so we should not have any pending
 255    * enabled-changed or state-changed signals for it.
 256    */
 257   g_assert (~event_mask & (ACTION_STATE_CHANGED_EVENT |
 258                            ACTION_ENABLED_CHANGED_EVENT));
 259
 260   event_mask |= ACTION_ADDED_EVENT;
 261
 262   g_action_group_exporter_set_events (exporter, action_name, event_mask);
 263 }
 264
 265 static void
 266 g_action_group_exporter_action_removed (GActionGroup *action_group,
 267                                         const gchar  *action_name,
 268                                         gpointer      user_data)
 269 {
 270   GActionGroupExporter *exporter = user_data;
 271   guint event_mask;
 272
 273   event_mask = g_action_group_exporter_get_events (exporter, action_name);
 274
 275   /* If the add event for this is still queued then just cancel it since
 276    * it's gone now.
 277    *
 278    * If the event was freshly added, there should not have been any
 279    * enabled or state changed events.
 280    */
 281   if (event_mask & ACTION_ADDED_EVENT)
 282     {
 283       g_assert (~event_mask & ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT));
 284       event_mask &= ~ACTION_ADDED_EVENT;
 285     }
 286
 287   /* Otherwise, queue a remove event.  Drop any state or enabled changes
 288    * that were queued before the remove. */
 289   else
 290     {
 291       event_mask |= ACTION_REMOVED_EVENT;
 292       event_mask &= ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT);
 293     }
 294
 295   g_action_group_exporter_set_events (exporter, action_name, event_mask);
 296 }
 297
 298 static void
 299 g_action_group_exporter_action_state_changed (GActionGroup *action_group,
 300                                               const gchar  *action_name,
 301                                               GVariant     *value,
 302                                               gpointer      user_data)
 303 {
 304   GActionGroupExporter *exporter = user_data;
 305   guint event_mask;
 306
 307   event_mask = g_action_group_exporter_get_events (exporter, action_name);
 308
 309   /* If it was removed, it must have been added back.  Otherwise, why
 310    * are we hearing about changes?
 311    */
 312   g_assert (~event_mask & ACTION_REMOVED_EVENT ||
 313             event_mask & ACTION_ADDED_EVENT);
 314
 315   /* If it is freshly added, don't also bother with the state change
 316    * signal since the updated state will be sent as part of the pending
 317    * add message.
 318    */
 319   if (~event_mask & ACTION_ADDED_EVENT)
 320     event_mask |= ACTION_STATE_CHANGED_EVENT;
 321
 322   g_action_group_exporter_set_events (exporter, action_name, event_mask);
 323 }
 324
 325 static void
 326 g_action_group_exporter_action_enabled_changed (GActionGroup *action_group,
 327                                                 const gchar  *action_name,
 328                                                 gboolean      enabled,
 329                                                 gpointer      user_data)
 330 {
 331   GActionGroupExporter *exporter = user_data;
 332   guint event_mask;
 333
 334   event_mask = g_action_group_exporter_get_events (exporter, action_name);
 335
 336   /* Reasoning as above. */
 337   g_assert (~event_mask & ACTION_REMOVED_EVENT ||
 338             event_mask & ACTION_ADDED_EVENT);
 339
 340   if (~event_mask & ACTION_ADDED_EVENT)
 341     event_mask |= ACTION_ENABLED_CHANGED_EVENT;
 342
 343   g_action_group_exporter_set_events (exporter, action_name, event_mask);
 344 }
 345
 346 static void
 347 g_action_group_exporter_pre_emit (GActionGroupExporter *exporter,
 348                                   GVariant             *platform_data)
 349 {
 350   if (G_IS_APPLICATION (exporter->action_group))
 351     G_APPLICATION_GET_CLASS (exporter->action_group)
 352       ->before_emit (G_APPLICATION (exporter->action_group), platform_data);
 353 }
 354
 355 static void
 356 g_action_group_exporter_post_emit (GActionGroupExporter *exporter,
 357                                    GVariant             *platform_data)
 358 {
 359   if (G_IS_APPLICATION (exporter->action_group))
 360     G_APPLICATION_GET_CLASS (exporter->action_group)
 361       ->after_emit (G_APPLICATION (exporter->action_group), platform_data);
 362 }
 363
 364 static void
 365 org_gtk_Actions_method_call (GDBusConnection       *connection,
 366                              const gchar           *sender,
 367                              const gchar           *object_path,
 368                              const gchar           *interface_name,
 369                              const gchar           *method_name,
 370                              GVariant              *parameters,
 371                              GDBusMethodInvocation *invocation,
 372                              gpointer               user_data)
 373 {
 374   GActionGroupExporter *exporter = user_data;
 375   GVariant *result = NULL;
 376
 377   if (g_str_equal (method_name, "List"))
 378     {
 379       gchar **list;
 380
 381       list = g_action_group_list_actions (exporter->action_group);
 382       result = g_variant_new ("(^as)", list);
 383       g_strfreev (list);
 384     }
 385
 386   else if (g_str_equal (method_name, "Describe"))
 387     {
 388       const gchar *name;
 389       GVariant *desc;
 390
 391       g_variant_get (parameters, "(&s)", &name);
 392       desc = g_action_group_describe_action (exporter->action_group, name);
 393       result = g_variant_new ("(@(bgav))", desc);
 394     }
 395
 396   else if (g_str_equal (method_name, "DescribeAll"))
 397     {
 398       GVariantBuilder builder;
 399       gchar **list;
 400       gint i;
 401
 402       list = g_action_group_list_actions (exporter->action_group);
 403       g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{s(bgav)}"));
 404       for (i = 0; list[i]; i++)
 405         {
 406           const gchar *name = list[i];
 407           GVariant *description;
 408
 409           description = g_action_group_describe_action (exporter->action_group, name);
 410           g_variant_builder_add (&builder, "{s@(bgav)}", name, description);
 411         }
 412       result = g_variant_new ("(a{s(bgav)})", &builder);
 413       g_strfreev (list);
 414     }
 415
 416   else if (g_str_equal (method_name, "Activate"))
 417     {
 418       GVariant *parameter = NULL;
 419       GVariant *platform_data;
 420       GVariantIter *iter;
 421       const gchar *name;
 422
 423       g_variant_get (parameters, "(&sav@a{sv})", &name, &iter, &platform_data);
 424       g_variant_iter_next (iter, "v", &parameter);
 425       g_variant_iter_free (iter);
 426
 427       g_action_group_exporter_pre_emit (exporter, platform_data);
 428       g_action_group_activate_action (exporter->action_group, name, parameter);
 429       g_action_group_exporter_post_emit (exporter, platform_data);
 430
 431       if (parameter)
 432         g_variant_unref (parameter);
 433
 434       g_variant_unref (platform_data);
 435     }
 436
 437   else if (g_str_equal (method_name, "SetState"))
 438     {
 439       GVariant *platform_data;
 440       const gchar *name;
 441       GVariant *state;
 442
 443       g_variant_get (parameters, "(&sv@a{sv})", &name, &state, &platform_data);
 444       g_action_group_exporter_pre_emit (exporter, platform_data);
 445       g_action_group_change_action_state (exporter->action_group, name, state);
 446       g_action_group_exporter_post_emit (exporter, platform_data);
 447       g_variant_unref (platform_data);
 448       g_variant_unref (state);
 449     }
 450
 451   else
 452     g_assert_not_reached ();
 453
 454   g_dbus_method_invocation_return_value (invocation, result);
 455 }
 456
 457 /**
 458  * g_action_group_dbus_export_start:
 459  * @connection: a #GDBusConnection
 460  * @object_path: a D-Bus object path
 461  * @action_group: a #GActionGroup
 462  * @error: a pointer to a %NULL #GError, or %NULL
 463  *
 464  * Exports @action_group on @connection at @object_path.
 465  *
 466  * The implemented D-Bus API should be considered private.  It is
 467  * subject to change in the future.
 468  *
 469  * A given action group can only be exported on one object path and an
 470  * object path can only have one action group exported on it. If either
 471  * constraint is violated, the export will fail and %FALSE will be
 472  * returned (with @error set accordingly).
 473  *
 474  * Use g_action_group_dbus_export_stop() to stop exporting @action_group,
 475  * or g_action_group_dbus_export_query() to find out if and where a given
 476  * action group is exported.
 477  *
 478  * Returns: %TRUE if the export is successful, or %FALSE (with @error
 479  *          set) in the event of a failure.
 480  **/
 481 gboolean
 482 g_action_group_dbus_export_start (GDBusConnection  *connection,
 483                                   const gchar      *object_path,
 484                                   GActionGroup     *action_group,
 485                                   GError          **error)
 486 {
 487   const GDBusInterfaceVTable vtable = {
 488     org_gtk_Actions_method_call
 489   };
 490   GActionGroupExporter *exporter;
 491
 492   if G_UNLIKELY (exported_groups == NULL)
 493     exported_groups = g_hash_table_new (NULL, NULL);
 494
 495   if G_UNLIKELY (org_gtk_Actions == NULL)
 496     {
 497       GError *error = NULL;
 498       GDBusNodeInfo *info;
 499
 500       info = g_dbus_node_info_new_for_xml (org_gtk_Actions_xml, &error);
 501       if G_UNLIKELY (info == NULL)
 502         g_error ("%s", error->message);
 503       org_gtk_Actions = g_dbus_node_info_lookup_interface (info, "org.gtk.Actions");
 504       g_assert (org_gtk_Actions != NULL);
 505       g_dbus_interface_info_ref (org_gtk_Actions);
 506       g_dbus_node_info_unref (info);
 507     }
 508
 509   if G_UNLIKELY (g_hash_table_lookup (exported_groups, action_group))
 510     {
 511       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FILE_EXISTS,
 512                    "The given GActionGroup has already been exported");
 513       return FALSE;
 514     }
 515
 516   exporter = g_slice_new (GActionGroupExporter);
 517   exporter->registration_id = g_dbus_connection_register_object (connection, object_path, org_gtk_Actions,
 518                                                                  &vtable, exporter, NULL, error);
 519
 520   if (exporter->registration_id == 0)
 521     {
 522       g_slice_free (GActionGroupExporter, exporter);
 523       return FALSE;
 524     }
 525
 526   g_hash_table_insert (exported_groups, action_group, exporter);
 527   exporter->pending_changes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 528   exporter->pending_id = 0;
 529   exporter->action_group = g_object_ref (action_group);
 530   exporter->connection = g_object_ref (connection);
 531   exporter->object_path = g_strdup (object_path);
 532
 533   exporter->signal_ids[0] =
 534     g_signal_connect (action_group, "action-added",
 535                       G_CALLBACK (g_action_group_exporter_action_added), exporter);
 536   exporter->signal_ids[1] =
 537     g_signal_connect (action_group, "action-removed",
 538                       G_CALLBACK (g_action_group_exporter_action_removed), exporter);
 539   exporter->signal_ids[2] =
 540     g_signal_connect (action_group, "action-state-changed",
 541                       G_CALLBACK (g_action_group_exporter_action_state_changed), exporter);
 542   exporter->signal_ids[3] =
 543     g_signal_connect (action_group, "action-enabled-changed",
 544                       G_CALLBACK (g_action_group_exporter_action_enabled_changed), exporter);
 545
 546   return TRUE;
 547 }
 548
 549 /**
 550  * g_action_group_dbus_export_stop:
 551  * @action_group: a #GActionGroup
 552  *
 553  * Stops the export of @action_group.
 554  *
 555  * This reverses the effect of a previous call to
 556  * g_action_group_dbus_export_start() for @action_group.
 557  *
 558  * Returns: %TRUE if an export was stopped or %FALSE if @action_group
 559  *          was not exported in the first place
 560  **/
 561 gboolean
 562 g_action_group_dbus_export_stop (GActionGroup *action_group)
 563 {
 564   GActionGroupExporter *exporter;
 565   gint i;
 566
 567   if G_UNLIKELY (exported_groups == NULL)
 568     return FALSE;
 569
 570   exporter = g_hash_table_lookup (exported_groups, action_group);
 571   if G_UNLIKELY (exporter == NULL)
 572     return FALSE;
 573
 574   g_dbus_connection_unregister_object (exporter->connection, exporter->registration_id);
 575   for (i = 0; i < G_N_ELEMENTS (exporter->signal_ids); i++)
 576     g_signal_handler_disconnect (exporter->action_group, exporter->signal_ids[i]);
 577   g_object_unref (exporter->connection);
 578   g_object_unref (exporter->action_group);
 579   g_free (exporter->object_path);
 580
 581   g_slice_free (GActionGroupExporter, exporter);
 582
 583   return TRUE;
 584 }
 585
 586 /**
 587  * g_action_group_dbus_export_query:
 588  * @action_group: a #GActionGroup
 589  * @connection: (out): the #GDBusConnection used for exporting
 590  * @object_path: (out): the object path used for exporting
 591  *
 592  * Queries if and where @action_group is exported.
 593  *
 594  * If @action_group is exported, %TRUE is returned.  If @connection is
 595  * non-%NULL then it is set to the #GDBusConnection used for the export.
 596  * If @object_path is non-%NULL then it is set to the object path.
 597  *
 598  * If the @action_group is not exported, %FALSE is returned and
 599  * @connection and @object_path remain unmodified.
 600  *
 601  * Returns: %TRUE if @action_group was exported, else %FALSE
 602  **/
 603 gboolean
 604 g_action_group_dbus_export_query (GActionGroup     *action_group,
 605                                   GDBusConnection **connection,
 606                                   const gchar     **object_path)
 607 {
 608   GActionGroupExporter *exporter;
 609
 610   if (exported_groups == NULL)
 611     return FALSE;
 612
 613   exporter = g_hash_table_lookup (exported_groups, action_group);
 614   if (exporter == NULL)
 615     return FALSE;
 616
 617   if (connection)
 618     *connection = exporter->connection;
 619
 620   if (object_path)
 621     *object_path = exporter->object_path;
 622
 623   return TRUE;
 624 }