plugins/common/bluetoothmanagerproxy.c

   1 /*
   2  * Generated by gdbus-codegen 2.32.1. DO NOT EDIT.
   3  *
   4  * The license of this code is the same as for the source it was derived from.
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #  include "config.h"
   9 #endif
  10
  11 #include "bluetoothmanagerproxy.h"
  12
  13 #ifdef G_OS_UNIX
  14 #  include <gio/gunixfdlist.h>
  15 #endif
  16
  17 typedef struct
  18 {
  19   GDBusArgInfo parent_struct;
  20   gboolean use_gvariant;
  21 } _ExtendedGDBusArgInfo;
  22
  23 typedef struct
  24 {
  25   GDBusMethodInfo parent_struct;
  26   const gchar *signal_name;
  27   gboolean pass_fdlist;
  28 } _ExtendedGDBusMethodInfo;
  29
  30 typedef struct
  31 {
  32   GDBusSignalInfo parent_struct;
  33   const gchar *signal_name;
  34 } _ExtendedGDBusSignalInfo;
  35
  36 typedef struct
  37 {
  38   GDBusPropertyInfo parent_struct;
  39   const gchar *hyphen_name;
  40   gboolean use_gvariant;
  41 } _ExtendedGDBusPropertyInfo;
  42
  43 typedef struct
  44 {
  45   GDBusInterfaceInfo parent_struct;
  46   const gchar *hyphen_name;
  47 } _ExtendedGDBusInterfaceInfo;
  48
  49 typedef struct
  50 {
  51   const _ExtendedGDBusPropertyInfo *info;
  52   guint prop_id;
  53   GValue orig_value; /* the value before the change */
  54 } ChangedProperty;
  55
  56 static void
  57 _changed_property_free (ChangedProperty *data)
  58 {
  59   g_value_unset (&data->orig_value);
  60   g_free (data);
  61 }
  62
  63 static gboolean
  64 _g_strv_equal0 (gchar **a, gchar **b)
  65 {
  66   gboolean ret = FALSE;
  67   guint n;
  68   if (a == NULL && b == NULL)
  69     {
  70       ret = TRUE;
  71       goto out;
  72     }
  73   if (a == NULL || b == NULL)
  74     goto out;
  75   if (g_strv_length (a) != g_strv_length (b))
  76     goto out;
  77   for (n = 0; a[n] != NULL; n++)
  78     if (g_strcmp0 (a[n], b[n]) != 0)
  79       goto out;
  80   ret = TRUE;
  81 out:
  82   return ret;
  83 }
  84
  85 static gboolean
  86 _g_variant_equal0 (GVariant *a, GVariant *b)
  87 {
  88   gboolean ret = FALSE;
  89   if (a == NULL && b == NULL)
  90     {
  91       ret = TRUE;
  92       goto out;
  93     }
  94   if (a == NULL || b == NULL)
  95     goto out;
  96   ret = g_variant_equal (a, b);
  97 out:
  98   return ret;
  99 }
 100
 101 G_GNUC_UNUSED static gboolean
 102 _g_value_equal (const GValue *a, const GValue *b)
 103 {
 104   gboolean ret = FALSE;
 105   g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
 106   switch (G_VALUE_TYPE (a))
 107     {
 108       case G_TYPE_BOOLEAN:
 109         ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
 110         break;
 111       case G_TYPE_UCHAR:
 112         ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
 113         break;
 114       case G_TYPE_INT:
 115         ret = (g_value_get_int (a) == g_value_get_int (b));
 116         break;
 117       case G_TYPE_UINT:
 118         ret = (g_value_get_uint (a) == g_value_get_uint (b));
 119         break;
 120       case G_TYPE_INT64:
 121         ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
 122         break;
 123       case G_TYPE_UINT64:
 124         ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
 125         break;
 126       case G_TYPE_DOUBLE:
 127         ret = (g_value_get_double (a) == g_value_get_double (b));
 128         break;
 129       case G_TYPE_STRING:
 130         ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
 131         break;
 132       case G_TYPE_VARIANT:
 133         ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
 134         break;
 135       default:
 136         if (G_VALUE_TYPE (a) == G_TYPE_STRV)
 137           ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
 138         else
 139           g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
 140         break;
 141     }
 142   return ret;
 143 }
 144
 145 /* ------------------------------------------------------------------------
 146  * Code for interface org.bluez.Manager
 147  * ------------------------------------------------------------------------
 148  */
 149
 150 /**
 151  * SECTION:OrgBluezManager
 152  * @title: OrgBluezManager
 153  * @short_description: Generated C code for the org.bluez.Manager D-Bus interface
 154  *
 155  * This section contains code for working with the <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link> D-Bus interface in C.
 156  */
 157
 158 /* ---- Introspection data for org.bluez.Manager ---- */
 159
 160 static const _ExtendedGDBusArgInfo _org_bluez_manager_method_info_get_properties_OUT_ARG_unnamed_arg0 =
 161 {
 162   {
 163     -1,
 164     "unnamed_arg0",
 165     "a{sv}",
 166     NULL
 167   },
 168   FALSE
 169 };
 170
 171 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_method_info_get_properties_OUT_ARG_pointers[] =
 172 {
 173   &_org_bluez_manager_method_info_get_properties_OUT_ARG_unnamed_arg0,
 174   NULL
 175 };
 176
 177 static const GDBusAnnotationInfo _org_bluez_manager_method_get_properties_annotation_info_0 =
 178 {
 179   -1,
 180   "com.trolltech.QtDBus.QtTypeName.Out0",
 181   "QVariantMap",
 182   NULL
 183 };
 184
 185 static const GDBusAnnotationInfo * const _org_bluez_manager_method_get_properties_annotation_info_pointers[] =
 186 {
 187   &_org_bluez_manager_method_get_properties_annotation_info_0,
 188   NULL
 189 };
 190
 191 static const _ExtendedGDBusMethodInfo _org_bluez_manager_method_info_get_properties =
 192 {
 193   {
 194     -1,
 195     "GetProperties",
 196     NULL,
 197     (GDBusArgInfo **) &_org_bluez_manager_method_info_get_properties_OUT_ARG_pointers,
 198     (GDBusAnnotationInfo **) &_org_bluez_manager_method_get_properties_annotation_info_pointers
 199   },
 200   "handle-get-properties",
 201   FALSE
 202 };
 203
 204 static const _ExtendedGDBusArgInfo _org_bluez_manager_method_info_default_adapter_OUT_ARG_unnamed_arg0 =
 205 {
 206   {
 207     -1,
 208     "unnamed_arg0",
 209     "o",
 210     NULL
 211   },
 212   FALSE
 213 };
 214
 215 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_method_info_default_adapter_OUT_ARG_pointers[] =
 216 {
 217   &_org_bluez_manager_method_info_default_adapter_OUT_ARG_unnamed_arg0,
 218   NULL
 219 };
 220
 221 static const _ExtendedGDBusMethodInfo _org_bluez_manager_method_info_default_adapter =
 222 {
 223   {
 224     -1,
 225     "DefaultAdapter",
 226     NULL,
 227     (GDBusArgInfo **) &_org_bluez_manager_method_info_default_adapter_OUT_ARG_pointers,
 228     NULL
 229   },
 230   "handle-default-adapter",
 231   FALSE
 232 };
 233
 234 static const _ExtendedGDBusArgInfo _org_bluez_manager_method_info_find_adapter_IN_ARG_unnamed_arg0 =
 235 {
 236   {
 237     -1,
 238     "unnamed_arg0",
 239     "s",
 240     NULL
 241   },
 242   FALSE
 243 };
 244
 245 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_method_info_find_adapter_IN_ARG_pointers[] =
 246 {
 247   &_org_bluez_manager_method_info_find_adapter_IN_ARG_unnamed_arg0,
 248   NULL
 249 };
 250
 251 static const _ExtendedGDBusArgInfo _org_bluez_manager_method_info_find_adapter_OUT_ARG_unnamed_arg1 =
 252 {
 253   {
 254     -1,
 255     "unnamed_arg1",
 256     "o",
 257     NULL
 258   },
 259   FALSE
 260 };
 261
 262 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_method_info_find_adapter_OUT_ARG_pointers[] =
 263 {
 264   &_org_bluez_manager_method_info_find_adapter_OUT_ARG_unnamed_arg1,
 265   NULL
 266 };
 267
 268 static const _ExtendedGDBusMethodInfo _org_bluez_manager_method_info_find_adapter =
 269 {
 270   {
 271     -1,
 272     "FindAdapter",
 273     (GDBusArgInfo **) &_org_bluez_manager_method_info_find_adapter_IN_ARG_pointers,
 274     (GDBusArgInfo **) &_org_bluez_manager_method_info_find_adapter_OUT_ARG_pointers,
 275     NULL
 276   },
 277   "handle-find-adapter",
 278   FALSE
 279 };
 280
 281 static const _ExtendedGDBusArgInfo _org_bluez_manager_method_info_list_adapters_OUT_ARG_unnamed_arg0 =
 282 {
 283   {
 284     -1,
 285     "unnamed_arg0",
 286     "ao",
 287     NULL
 288   },
 289   FALSE
 290 };
 291
 292 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_method_info_list_adapters_OUT_ARG_pointers[] =
 293 {
 294   &_org_bluez_manager_method_info_list_adapters_OUT_ARG_unnamed_arg0,
 295   NULL
 296 };
 297
 298 static const _ExtendedGDBusMethodInfo _org_bluez_manager_method_info_list_adapters =
 299 {
 300   {
 301     -1,
 302     "ListAdapters",
 303     NULL,
 304     (GDBusArgInfo **) &_org_bluez_manager_method_info_list_adapters_OUT_ARG_pointers,
 305     NULL
 306   },
 307   "handle-list-adapters",
 308   FALSE
 309 };
 310
 311 static const _ExtendedGDBusMethodInfo * const _org_bluez_manager_method_info_pointers[] =
 312 {
 313   &_org_bluez_manager_method_info_get_properties,
 314   &_org_bluez_manager_method_info_default_adapter,
 315   &_org_bluez_manager_method_info_find_adapter,
 316   &_org_bluez_manager_method_info_list_adapters,
 317   NULL
 318 };
 319
 320 static const _ExtendedGDBusArgInfo _org_bluez_manager_signal_info_property_changed_ARG_unnamed_arg0 =
 321 {
 322   {
 323     -1,
 324     "unnamed_arg0",
 325     "s",
 326     NULL
 327   },
 328   FALSE
 329 };
 330
 331 static const _ExtendedGDBusArgInfo _org_bluez_manager_signal_info_property_changed_ARG_unnamed_arg1 =
 332 {
 333   {
 334     -1,
 335     "unnamed_arg1",
 336     "v",
 337     NULL
 338   },
 339   FALSE
 340 };
 341
 342 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_signal_info_property_changed_ARG_pointers[] =
 343 {
 344   &_org_bluez_manager_signal_info_property_changed_ARG_unnamed_arg0,
 345   &_org_bluez_manager_signal_info_property_changed_ARG_unnamed_arg1,
 346   NULL
 347 };
 348
 349 static const _ExtendedGDBusSignalInfo _org_bluez_manager_signal_info_property_changed =
 350 {
 351   {
 352     -1,
 353     "PropertyChanged",
 354     (GDBusArgInfo **) &_org_bluez_manager_signal_info_property_changed_ARG_pointers,
 355     NULL
 356   },
 357   "property-changed"
 358 };
 359
 360 static const _ExtendedGDBusArgInfo _org_bluez_manager_signal_info_adapter_added_ARG_unnamed_arg0 =
 361 {
 362   {
 363     -1,
 364     "unnamed_arg0",
 365     "o",
 366     NULL
 367   },
 368   FALSE
 369 };
 370
 371 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_signal_info_adapter_added_ARG_pointers[] =
 372 {
 373   &_org_bluez_manager_signal_info_adapter_added_ARG_unnamed_arg0,
 374   NULL
 375 };
 376
 377 static const _ExtendedGDBusSignalInfo _org_bluez_manager_signal_info_adapter_added =
 378 {
 379   {
 380     -1,
 381     "AdapterAdded",
 382     (GDBusArgInfo **) &_org_bluez_manager_signal_info_adapter_added_ARG_pointers,
 383     NULL
 384   },
 385   "adapter-added"
 386 };
 387
 388 static const _ExtendedGDBusArgInfo _org_bluez_manager_signal_info_adapter_removed_ARG_unnamed_arg0 =
 389 {
 390   {
 391     -1,
 392     "unnamed_arg0",
 393     "o",
 394     NULL
 395   },
 396   FALSE
 397 };
 398
 399 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_signal_info_adapter_removed_ARG_pointers[] =
 400 {
 401   &_org_bluez_manager_signal_info_adapter_removed_ARG_unnamed_arg0,
 402   NULL
 403 };
 404
 405 static const _ExtendedGDBusSignalInfo _org_bluez_manager_signal_info_adapter_removed =
 406 {
 407   {
 408     -1,
 409     "AdapterRemoved",
 410     (GDBusArgInfo **) &_org_bluez_manager_signal_info_adapter_removed_ARG_pointers,
 411     NULL
 412   },
 413   "adapter-removed"
 414 };
 415
 416 static const _ExtendedGDBusArgInfo _org_bluez_manager_signal_info_default_adapter_changed_ARG_unnamed_arg0 =
 417 {
 418   {
 419     -1,
 420     "unnamed_arg0",
 421     "o",
 422     NULL
 423   },
 424   FALSE
 425 };
 426
 427 static const _ExtendedGDBusArgInfo * const _org_bluez_manager_signal_info_default_adapter_changed_ARG_pointers[] =
 428 {
 429   &_org_bluez_manager_signal_info_default_adapter_changed_ARG_unnamed_arg0,
 430   NULL
 431 };
 432
 433 static const _ExtendedGDBusSignalInfo _org_bluez_manager_signal_info_default_adapter_changed =
 434 {
 435   {
 436     -1,
 437     "DefaultAdapterChanged",
 438     (GDBusArgInfo **) &_org_bluez_manager_signal_info_default_adapter_changed_ARG_pointers,
 439     NULL
 440   },
 441   "default-adapter-changed"
 442 };
 443
 444 static const _ExtendedGDBusSignalInfo * const _org_bluez_manager_signal_info_pointers[] =
 445 {
 446   &_org_bluez_manager_signal_info_property_changed,
 447   &_org_bluez_manager_signal_info_adapter_added,
 448   &_org_bluez_manager_signal_info_adapter_removed,
 449   &_org_bluez_manager_signal_info_default_adapter_changed,
 450   NULL
 451 };
 452
 453 static const _ExtendedGDBusInterfaceInfo _org_bluez_manager_interface_info =
 454 {
 455   {
 456     -1,
 457     "org.bluez.Manager",
 458     (GDBusMethodInfo **) &_org_bluez_manager_method_info_pointers,
 459     (GDBusSignalInfo **) &_org_bluez_manager_signal_info_pointers,
 460     NULL,
 461     NULL
 462   },
 463   "org-bluez-manager",
 464 };
 465
 466
 467 /**
 468  * org_bluez_manager_interface_info:
 469  *
 470  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link> D-Bus interface.
 471  *
 472  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 473  */
 474 GDBusInterfaceInfo *
 475 org_bluez_manager_interface_info (void)
 476 {
 477   return (GDBusInterfaceInfo *) &_org_bluez_manager_interface_info;
 478 }
 479
 480 /**
 481  * org_bluez_manager_override_properties:
 482  * @klass: The class structure for a #GObject<!-- -->-derived class.
 483  * @property_id_begin: The property id to assign to the first overridden property.
 484  *
 485  * Overrides all #GObject properties in the #OrgBluezManager interface for a concrete class.
 486  * The properties are overridden in the order they are defined.
 487  *
 488  * Returns: The last property id.
 489  */
 490 guint
 491 org_bluez_manager_override_properties (GObjectClass *klass, guint property_id_begin)
 492 {
 493   return property_id_begin - 1;
 494 }
 495
 496
 497
 498 /**
 499  * OrgBluezManager:
 500  *
 501  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link>.
 502  */
 503
 504 /**
 505  * OrgBluezManagerIface:
 506  * @parent_iface: The parent interface.
 507  * @handle_default_adapter: Handler for the #OrgBluezManager::handle-default-adapter signal.
 508  * @handle_find_adapter: Handler for the #OrgBluezManager::handle-find-adapter signal.
 509  * @handle_get_properties: Handler for the #OrgBluezManager::handle-get-properties signal.
 510  * @handle_list_adapters: Handler for the #OrgBluezManager::handle-list-adapters signal.
 511  * @adapter_added: Handler for the #OrgBluezManager::adapter-added signal.
 512  * @adapter_removed: Handler for the #OrgBluezManager::adapter-removed signal.
 513  * @default_adapter_changed: Handler for the #OrgBluezManager::default-adapter-changed signal.
 514  * @property_changed: Handler for the #OrgBluezManager::property-changed signal.
 515  *
 516  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link>.
 517  */
 518
 519 static void
 520 org_bluez_manager_default_init (OrgBluezManagerIface *iface)
 521 {
 522   /* GObject signals for incoming D-Bus method calls: */
 523   /**
 524    * OrgBluezManager::handle-get-properties:
 525    * @object: A #OrgBluezManager.
 526    * @invocation: A #GDBusMethodInvocation.
 527    *
 528    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Manager.GetProperties">GetProperties()</link> D-Bus method.
 529    *
 530    * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_bluez_manager_complete_get_properties() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
 531    *
 532    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 533    */
 534   g_signal_new ("handle-get-properties",
 535     G_TYPE_FROM_INTERFACE (iface),
 536     G_SIGNAL_RUN_LAST,
 537     G_STRUCT_OFFSET (OrgBluezManagerIface, handle_get_properties),
 538     g_signal_accumulator_true_handled,
 539     NULL,
 540     g_cclosure_marshal_generic,
 541     G_TYPE_BOOLEAN,
 542     1,
 543     G_TYPE_DBUS_METHOD_INVOCATION);
 544
 545   /**
 546    * OrgBluezManager::handle-default-adapter:
 547    * @object: A #OrgBluezManager.
 548    * @invocation: A #GDBusMethodInvocation.
 549    *
 550    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Manager.DefaultAdapter">DefaultAdapter()</link> D-Bus method.
 551    *
 552    * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_bluez_manager_complete_default_adapter() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
 553    *
 554    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 555    */
 556   g_signal_new ("handle-default-adapter",
 557     G_TYPE_FROM_INTERFACE (iface),
 558     G_SIGNAL_RUN_LAST,
 559     G_STRUCT_OFFSET (OrgBluezManagerIface, handle_default_adapter),
 560     g_signal_accumulator_true_handled,
 561     NULL,
 562     g_cclosure_marshal_generic,
 563     G_TYPE_BOOLEAN,
 564     1,
 565     G_TYPE_DBUS_METHOD_INVOCATION);
 566
 567   /**
 568    * OrgBluezManager::handle-find-adapter:
 569    * @object: A #OrgBluezManager.
 570    * @invocation: A #GDBusMethodInvocation.
 571    * @arg_unnamed_arg0: Argument passed by remote caller.
 572    *
 573    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Manager.FindAdapter">FindAdapter()</link> D-Bus method.
 574    *
 575    * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_bluez_manager_complete_find_adapter() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
 576    *
 577    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 578    */
 579   g_signal_new ("handle-find-adapter",
 580     G_TYPE_FROM_INTERFACE (iface),
 581     G_SIGNAL_RUN_LAST,
 582     G_STRUCT_OFFSET (OrgBluezManagerIface, handle_find_adapter),
 583     g_signal_accumulator_true_handled,
 584     NULL,
 585     g_cclosure_marshal_generic,
 586     G_TYPE_BOOLEAN,
 587     2,
 588     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
 589
 590   /**
 591    * OrgBluezManager::handle-list-adapters:
 592    * @object: A #OrgBluezManager.
 593    * @invocation: A #GDBusMethodInvocation.
 594    *
 595    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Manager.ListAdapters">ListAdapters()</link> D-Bus method.
 596    *
 597    * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_bluez_manager_complete_list_adapters() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
 598    *
 599    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 600    */
 601   g_signal_new ("handle-list-adapters",
 602     G_TYPE_FROM_INTERFACE (iface),
 603     G_SIGNAL_RUN_LAST,
 604     G_STRUCT_OFFSET (OrgBluezManagerIface, handle_list_adapters),
 605     g_signal_accumulator_true_handled,
 606     NULL,
 607     g_cclosure_marshal_generic,
 608     G_TYPE_BOOLEAN,
 609     1,
 610     G_TYPE_DBUS_METHOD_INVOCATION);
 611
 612   /* GObject signals for received D-Bus signals: */
 613   /**
 614    * OrgBluezManager::property-changed:
 615    * @object: A #OrgBluezManager.
 616    * @arg_unnamed_arg0: Argument.
 617    * @arg_unnamed_arg1: Argument.
 618    *
 619    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Manager.PropertyChanged">"PropertyChanged"</link> is received.
 620    *
 621    * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
 622    */
 623   g_signal_new ("property-changed",
 624     G_TYPE_FROM_INTERFACE (iface),
 625     G_SIGNAL_RUN_LAST,
 626     G_STRUCT_OFFSET (OrgBluezManagerIface, property_changed),
 627     NULL,
 628     NULL,
 629     g_cclosure_marshal_generic,
 630     G_TYPE_NONE,
 631     2, G_TYPE_STRING, G_TYPE_VARIANT);
 632
 633   /**
 634    * OrgBluezManager::adapter-added:
 635    * @object: A #OrgBluezManager.
 636    * @arg_unnamed_arg0: Argument.
 637    *
 638    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Manager.AdapterAdded">"AdapterAdded"</link> is received.
 639    *
 640    * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
 641    */
 642   g_signal_new ("adapter-added",
 643     G_TYPE_FROM_INTERFACE (iface),
 644     G_SIGNAL_RUN_LAST,
 645     G_STRUCT_OFFSET (OrgBluezManagerIface, adapter_added),
 646     NULL,
 647     NULL,
 648     g_cclosure_marshal_generic,
 649     G_TYPE_NONE,
 650     1, G_TYPE_STRING);
 651
 652   /**
 653    * OrgBluezManager::adapter-removed:
 654    * @object: A #OrgBluezManager.
 655    * @arg_unnamed_arg0: Argument.
 656    *
 657    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Manager.AdapterRemoved">"AdapterRemoved"</link> is received.
 658    *
 659    * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
 660    */
 661   g_signal_new ("adapter-removed",
 662     G_TYPE_FROM_INTERFACE (iface),
 663     G_SIGNAL_RUN_LAST,
 664     G_STRUCT_OFFSET (OrgBluezManagerIface, adapter_removed),
 665     NULL,
 666     NULL,
 667     g_cclosure_marshal_generic,
 668     G_TYPE_NONE,
 669     1, G_TYPE_STRING);
 670
 671   /**
 672    * OrgBluezManager::default-adapter-changed:
 673    * @object: A #OrgBluezManager.
 674    * @arg_unnamed_arg0: Argument.
 675    *
 676    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Manager.DefaultAdapterChanged">"DefaultAdapterChanged"</link> is received.
 677    *
 678    * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
 679    */
 680   g_signal_new ("default-adapter-changed",
 681     G_TYPE_FROM_INTERFACE (iface),
 682     G_SIGNAL_RUN_LAST,
 683     G_STRUCT_OFFSET (OrgBluezManagerIface, default_adapter_changed),
 684     NULL,
 685     NULL,
 686     g_cclosure_marshal_generic,
 687     G_TYPE_NONE,
 688     1, G_TYPE_STRING);
 689
 690 }
 691
 692 typedef OrgBluezManagerIface OrgBluezManagerInterface;
 693 G_DEFINE_INTERFACE (OrgBluezManager, org_bluez_manager, G_TYPE_OBJECT);
 694
 695 /**
 696  * org_bluez_manager_emit_property_changed:
 697  * @object: A #OrgBluezManager.
 698  * @arg_unnamed_arg0: Argument to pass with the signal.
 699  * @arg_unnamed_arg1: Argument to pass with the signal.
 700  *
 701  * Emits the <link linkend="gdbus-signal-org-bluez-Manager.PropertyChanged">"PropertyChanged"</link> D-Bus signal.
 702  */
 703 void
 704 org_bluez_manager_emit_property_changed (
 705     OrgBluezManager *object,
 706     const gchar *arg_unnamed_arg0,
 707     GVariant *arg_unnamed_arg1)
 708 {
 709   g_signal_emit_by_name (object, "property-changed", arg_unnamed_arg0, arg_unnamed_arg1);
 710 }
 711
 712 /**
 713  * org_bluez_manager_emit_adapter_added:
 714  * @object: A #OrgBluezManager.
 715  * @arg_unnamed_arg0: Argument to pass with the signal.
 716  *
 717  * Emits the <link linkend="gdbus-signal-org-bluez-Manager.AdapterAdded">"AdapterAdded"</link> D-Bus signal.
 718  */
 719 void
 720 org_bluez_manager_emit_adapter_added (
 721     OrgBluezManager *object,
 722     const gchar *arg_unnamed_arg0)
 723 {
 724   g_signal_emit_by_name (object, "adapter-added", arg_unnamed_arg0);
 725 }
 726
 727 /**
 728  * org_bluez_manager_emit_adapter_removed:
 729  * @object: A #OrgBluezManager.
 730  * @arg_unnamed_arg0: Argument to pass with the signal.
 731  *
 732  * Emits the <link linkend="gdbus-signal-org-bluez-Manager.AdapterRemoved">"AdapterRemoved"</link> D-Bus signal.
 733  */
 734 void
 735 org_bluez_manager_emit_adapter_removed (
 736     OrgBluezManager *object,
 737     const gchar *arg_unnamed_arg0)
 738 {
 739   g_signal_emit_by_name (object, "adapter-removed", arg_unnamed_arg0);
 740 }
 741
 742 /**
 743  * org_bluez_manager_emit_default_adapter_changed:
 744  * @object: A #OrgBluezManager.
 745  * @arg_unnamed_arg0: Argument to pass with the signal.
 746  *
 747  * Emits the <link linkend="gdbus-signal-org-bluez-Manager.DefaultAdapterChanged">"DefaultAdapterChanged"</link> D-Bus signal.
 748  */
 749 void
 750 org_bluez_manager_emit_default_adapter_changed (
 751     OrgBluezManager *object,
 752     const gchar *arg_unnamed_arg0)
 753 {
 754   g_signal_emit_by_name (object, "default-adapter-changed", arg_unnamed_arg0);
 755 }
 756
 757 /**
 758  * org_bluez_manager_call_get_properties:
 759  * @proxy: A #OrgBluezManagerProxy.
 760  * @cancellable: (allow-none): A #GCancellable or %NULL.
 761  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 762  * @user_data: User data to pass to @callback.
 763  *
 764  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.GetProperties">GetProperties()</link> D-Bus method on @proxy.
 765  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 766  * You can then call org_bluez_manager_call_get_properties_finish() to get the result of the operation.
 767  *
 768  * See org_bluez_manager_call_get_properties_sync() for the synchronous, blocking version of this method.
 769  */
 770 void
 771 org_bluez_manager_call_get_properties (
 772     OrgBluezManager *proxy,
 773     GCancellable *cancellable,
 774     GAsyncReadyCallback callback,
 775     gpointer user_data)
 776 {
 777   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
 778     "GetProperties",
 779     g_variant_new ("()"),
 780     G_DBUS_CALL_FLAGS_NONE,
 781     -1,
 782     cancellable,
 783     callback,
 784     user_data);
 785 }
 786
 787 /**
 788  * org_bluez_manager_call_get_properties_finish:
 789  * @proxy: A #OrgBluezManagerProxy.
 790  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
 791  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_call_get_properties().
 792  * @error: Return location for error or %NULL.
 793  *
 794  * Finishes an operation started with org_bluez_manager_call_get_properties().
 795  *
 796  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 797  */
 798 gboolean
 799 org_bluez_manager_call_get_properties_finish (
 800     OrgBluezManager *proxy,
 801     GVariant **out_unnamed_arg0,
 802     GAsyncResult *res,
 803     GError **error)
 804 {
 805   GVariant *_ret;
 806   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
 807   if (_ret == NULL)
 808     goto _out;
 809   g_variant_get (_ret,
 810                  "(@a{sv})",
 811                  out_unnamed_arg0);
 812   g_variant_unref (_ret);
 813 _out:
 814   return _ret != NULL;
 815 }
 816
 817 /**
 818  * org_bluez_manager_call_get_properties_sync:
 819  * @proxy: A #OrgBluezManagerProxy.
 820  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
 821  * @cancellable: (allow-none): A #GCancellable or %NULL.
 822  * @error: Return location for error or %NULL.
 823  *
 824  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.GetProperties">GetProperties()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 825  *
 826  * See org_bluez_manager_call_get_properties() for the asynchronous version of this method.
 827  *
 828  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 829  */
 830 gboolean
 831 org_bluez_manager_call_get_properties_sync (
 832     OrgBluezManager *proxy,
 833     GVariant **out_unnamed_arg0,
 834     GCancellable *cancellable,
 835     GError **error)
 836 {
 837   GVariant *_ret;
 838   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
 839     "GetProperties",
 840     g_variant_new ("()"),
 841     G_DBUS_CALL_FLAGS_NONE,
 842     -1,
 843     cancellable,
 844     error);
 845   if (_ret == NULL)
 846     goto _out;
 847   g_variant_get (_ret,
 848                  "(@a{sv})",
 849                  out_unnamed_arg0);
 850   g_variant_unref (_ret);
 851 _out:
 852   return _ret != NULL;
 853 }
 854
 855 /**
 856  * org_bluez_manager_call_default_adapter:
 857  * @proxy: A #OrgBluezManagerProxy.
 858  * @cancellable: (allow-none): A #GCancellable or %NULL.
 859  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 860  * @user_data: User data to pass to @callback.
 861  *
 862  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.DefaultAdapter">DefaultAdapter()</link> D-Bus method on @proxy.
 863  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 864  * You can then call org_bluez_manager_call_default_adapter_finish() to get the result of the operation.
 865  *
 866  * See org_bluez_manager_call_default_adapter_sync() for the synchronous, blocking version of this method.
 867  */
 868 void
 869 org_bluez_manager_call_default_adapter (
 870     OrgBluezManager *proxy,
 871     GCancellable *cancellable,
 872     GAsyncReadyCallback callback,
 873     gpointer user_data)
 874 {
 875   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
 876     "DefaultAdapter",
 877     g_variant_new ("()"),
 878     G_DBUS_CALL_FLAGS_NONE,
 879     -1,
 880     cancellable,
 881     callback,
 882     user_data);
 883 }
 884
 885 /**
 886  * org_bluez_manager_call_default_adapter_finish:
 887  * @proxy: A #OrgBluezManagerProxy.
 888  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
 889  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_call_default_adapter().
 890  * @error: Return location for error or %NULL.
 891  *
 892  * Finishes an operation started with org_bluez_manager_call_default_adapter().
 893  *
 894  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 895  */
 896 gboolean
 897 org_bluez_manager_call_default_adapter_finish (
 898     OrgBluezManager *proxy,
 899     gchar **out_unnamed_arg0,
 900     GAsyncResult *res,
 901     GError **error)
 902 {
 903   GVariant *_ret;
 904   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
 905   if (_ret == NULL)
 906     goto _out;
 907   g_variant_get (_ret,
 908                  "(o)",
 909                  out_unnamed_arg0);
 910   g_variant_unref (_ret);
 911 _out:
 912   return _ret != NULL;
 913 }
 914
 915 /**
 916  * org_bluez_manager_call_default_adapter_sync:
 917  * @proxy: A #OrgBluezManagerProxy.
 918  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
 919  * @cancellable: (allow-none): A #GCancellable or %NULL.
 920  * @error: Return location for error or %NULL.
 921  *
 922  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.DefaultAdapter">DefaultAdapter()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 923  *
 924  * See org_bluez_manager_call_default_adapter() for the asynchronous version of this method.
 925  *
 926  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 927  */
 928 gboolean
 929 org_bluez_manager_call_default_adapter_sync (
 930     OrgBluezManager *proxy,
 931     gchar **out_unnamed_arg0,
 932     GCancellable *cancellable,
 933     GError **error)
 934 {
 935   GVariant *_ret;
 936   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
 937     "DefaultAdapter",
 938     g_variant_new ("()"),
 939     G_DBUS_CALL_FLAGS_NONE,
 940     -1,
 941     cancellable,
 942     error);
 943   if (_ret == NULL)
 944     goto _out;
 945   g_variant_get (_ret,
 946                  "(o)",
 947                  out_unnamed_arg0);
 948   g_variant_unref (_ret);
 949 _out:
 950   return _ret != NULL;
 951 }
 952
 953 /**
 954  * org_bluez_manager_call_find_adapter:
 955  * @proxy: A #OrgBluezManagerProxy.
 956  * @arg_unnamed_arg0: Argument to pass with the method invocation.
 957  * @cancellable: (allow-none): A #GCancellable or %NULL.
 958  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 959  * @user_data: User data to pass to @callback.
 960  *
 961  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.FindAdapter">FindAdapter()</link> D-Bus method on @proxy.
 962  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
 963  * You can then call org_bluez_manager_call_find_adapter_finish() to get the result of the operation.
 964  *
 965  * See org_bluez_manager_call_find_adapter_sync() for the synchronous, blocking version of this method.
 966  */
 967 void
 968 org_bluez_manager_call_find_adapter (
 969     OrgBluezManager *proxy,
 970     const gchar *arg_unnamed_arg0,
 971     GCancellable *cancellable,
 972     GAsyncReadyCallback callback,
 973     gpointer user_data)
 974 {
 975   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
 976     "FindAdapter",
 977     g_variant_new ("(s)",
 978                    arg_unnamed_arg0),
 979     G_DBUS_CALL_FLAGS_NONE,
 980     -1,
 981     cancellable,
 982     callback,
 983     user_data);
 984 }
 985
 986 /**
 987  * org_bluez_manager_call_find_adapter_finish:
 988  * @proxy: A #OrgBluezManagerProxy.
 989  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
 990  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_call_find_adapter().
 991  * @error: Return location for error or %NULL.
 992  *
 993  * Finishes an operation started with org_bluez_manager_call_find_adapter().
 994  *
 995  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
 996  */
 997 gboolean
 998 org_bluez_manager_call_find_adapter_finish (
 999     OrgBluezManager *proxy,
1000     gchar **out_unnamed_arg1,
1001     GAsyncResult *res,
1002     GError **error)
1003 {
1004   GVariant *_ret;
1005   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1006   if (_ret == NULL)
1007     goto _out;
1008   g_variant_get (_ret,
1009                  "(o)",
1010                  out_unnamed_arg1);
1011   g_variant_unref (_ret);
1012 _out:
1013   return _ret != NULL;
1014 }
1015
1016 /**
1017  * org_bluez_manager_call_find_adapter_sync:
1018  * @proxy: A #OrgBluezManagerProxy.
1019  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1020  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
1021  * @cancellable: (allow-none): A #GCancellable or %NULL.
1022  * @error: Return location for error or %NULL.
1023  *
1024  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.FindAdapter">FindAdapter()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1025  *
1026  * See org_bluez_manager_call_find_adapter() for the asynchronous version of this method.
1027  *
1028  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1029  */
1030 gboolean
1031 org_bluez_manager_call_find_adapter_sync (
1032     OrgBluezManager *proxy,
1033     const gchar *arg_unnamed_arg0,
1034     gchar **out_unnamed_arg1,
1035     GCancellable *cancellable,
1036     GError **error)
1037 {
1038   GVariant *_ret;
1039   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1040     "FindAdapter",
1041     g_variant_new ("(s)",
1042                    arg_unnamed_arg0),
1043     G_DBUS_CALL_FLAGS_NONE,
1044     -1,
1045     cancellable,
1046     error);
1047   if (_ret == NULL)
1048     goto _out;
1049   g_variant_get (_ret,
1050                  "(o)",
1051                  out_unnamed_arg1);
1052   g_variant_unref (_ret);
1053 _out:
1054   return _ret != NULL;
1055 }
1056
1057 /**
1058  * org_bluez_manager_call_list_adapters:
1059  * @proxy: A #OrgBluezManagerProxy.
1060  * @cancellable: (allow-none): A #GCancellable or %NULL.
1061  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1062  * @user_data: User data to pass to @callback.
1063  *
1064  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.ListAdapters">ListAdapters()</link> D-Bus method on @proxy.
1065  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
1066  * You can then call org_bluez_manager_call_list_adapters_finish() to get the result of the operation.
1067  *
1068  * See org_bluez_manager_call_list_adapters_sync() for the synchronous, blocking version of this method.
1069  */
1070 void
1071 org_bluez_manager_call_list_adapters (
1072     OrgBluezManager *proxy,
1073     GCancellable *cancellable,
1074     GAsyncReadyCallback callback,
1075     gpointer user_data)
1076 {
1077   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1078     "ListAdapters",
1079     g_variant_new ("()"),
1080     G_DBUS_CALL_FLAGS_NONE,
1081     -1,
1082     cancellable,
1083     callback,
1084     user_data);
1085 }
1086
1087 /**
1088  * org_bluez_manager_call_list_adapters_finish:
1089  * @proxy: A #OrgBluezManagerProxy.
1090  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1091  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_call_list_adapters().
1092  * @error: Return location for error or %NULL.
1093  *
1094  * Finishes an operation started with org_bluez_manager_call_list_adapters().
1095  *
1096  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1097  */
1098 gboolean
1099 org_bluez_manager_call_list_adapters_finish (
1100     OrgBluezManager *proxy,
1101     gchar ***out_unnamed_arg0,
1102     GAsyncResult *res,
1103     GError **error)
1104 {
1105   GVariant *_ret;
1106   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1107   if (_ret == NULL)
1108     goto _out;
1109   g_variant_get (_ret,
1110                  "(^ao)",
1111                  out_unnamed_arg0);
1112   g_variant_unref (_ret);
1113 _out:
1114   return _ret != NULL;
1115 }
1116
1117 /**
1118  * org_bluez_manager_call_list_adapters_sync:
1119  * @proxy: A #OrgBluezManagerProxy.
1120  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1121  * @cancellable: (allow-none): A #GCancellable or %NULL.
1122  * @error: Return location for error or %NULL.
1123  *
1124  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Manager.ListAdapters">ListAdapters()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1125  *
1126  * See org_bluez_manager_call_list_adapters() for the asynchronous version of this method.
1127  *
1128  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1129  */
1130 gboolean
1131 org_bluez_manager_call_list_adapters_sync (
1132     OrgBluezManager *proxy,
1133     gchar ***out_unnamed_arg0,
1134     GCancellable *cancellable,
1135     GError **error)
1136 {
1137   GVariant *_ret;
1138   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1139     "ListAdapters",
1140     g_variant_new ("()"),
1141     G_DBUS_CALL_FLAGS_NONE,
1142     -1,
1143     cancellable,
1144     error);
1145   if (_ret == NULL)
1146     goto _out;
1147   g_variant_get (_ret,
1148                  "(^ao)",
1149                  out_unnamed_arg0);
1150   g_variant_unref (_ret);
1151 _out:
1152   return _ret != NULL;
1153 }
1154
1155 /**
1156  * org_bluez_manager_complete_get_properties:
1157  * @object: A #OrgBluezManager.
1158  * @invocation: (transfer full): A #GDBusMethodInvocation.
1159  * @unnamed_arg0: Parameter to return.
1160  *
1161  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Manager.GetProperties">GetProperties()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
1162  *
1163  * This method will free @invocation, you cannot use it afterwards.
1164  */
1165 void
1166 org_bluez_manager_complete_get_properties (
1167     OrgBluezManager *object,
1168     GDBusMethodInvocation *invocation,
1169     GVariant *unnamed_arg0)
1170 {
1171   g_dbus_method_invocation_return_value (invocation,
1172     g_variant_new ("(@a{sv})",
1173                    unnamed_arg0));
1174 }
1175
1176 /**
1177  * org_bluez_manager_complete_default_adapter:
1178  * @object: A #OrgBluezManager.
1179  * @invocation: (transfer full): A #GDBusMethodInvocation.
1180  * @unnamed_arg0: Parameter to return.
1181  *
1182  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Manager.DefaultAdapter">DefaultAdapter()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
1183  *
1184  * This method will free @invocation, you cannot use it afterwards.
1185  */
1186 void
1187 org_bluez_manager_complete_default_adapter (
1188     OrgBluezManager *object,
1189     GDBusMethodInvocation *invocation,
1190     const gchar *unnamed_arg0)
1191 {
1192   g_dbus_method_invocation_return_value (invocation,
1193     g_variant_new ("(o)",
1194                    unnamed_arg0));
1195 }
1196
1197 /**
1198  * org_bluez_manager_complete_find_adapter:
1199  * @object: A #OrgBluezManager.
1200  * @invocation: (transfer full): A #GDBusMethodInvocation.
1201  * @unnamed_arg1: Parameter to return.
1202  *
1203  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Manager.FindAdapter">FindAdapter()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
1204  *
1205  * This method will free @invocation, you cannot use it afterwards.
1206  */
1207 void
1208 org_bluez_manager_complete_find_adapter (
1209     OrgBluezManager *object,
1210     GDBusMethodInvocation *invocation,
1211     const gchar *unnamed_arg1)
1212 {
1213   g_dbus_method_invocation_return_value (invocation,
1214     g_variant_new ("(o)",
1215                    unnamed_arg1));
1216 }
1217
1218 /**
1219  * org_bluez_manager_complete_list_adapters:
1220  * @object: A #OrgBluezManager.
1221  * @invocation: (transfer full): A #GDBusMethodInvocation.
1222  * @unnamed_arg0: Parameter to return.
1223  *
1224  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Manager.ListAdapters">ListAdapters()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
1225  *
1226  * This method will free @invocation, you cannot use it afterwards.
1227  */
1228 void
1229 org_bluez_manager_complete_list_adapters (
1230     OrgBluezManager *object,
1231     GDBusMethodInvocation *invocation,
1232     const gchar *const *unnamed_arg0)
1233 {
1234   g_dbus_method_invocation_return_value (invocation,
1235     g_variant_new ("(^ao)",
1236                    unnamed_arg0));
1237 }
1238
1239 /* ------------------------------------------------------------------------ */
1240
1241 /**
1242  * OrgBluezManagerProxy:
1243  *
1244  * The #OrgBluezManagerProxy structure contains only private data and should only be accessed using the provided API.
1245  */
1246
1247 /**
1248  * OrgBluezManagerProxyClass:
1249  * @parent_class: The parent class.
1250  *
1251  * Class structure for #OrgBluezManagerProxy.
1252  */
1253
1254 struct _OrgBluezManagerProxyPrivate
1255 {
1256   GData *qdata;
1257 };
1258
1259 static void org_bluez_manager_proxy_iface_init (OrgBluezManagerIface *iface);
1260
1261 G_DEFINE_TYPE_WITH_CODE (OrgBluezManagerProxy, org_bluez_manager_proxy, G_TYPE_DBUS_PROXY,
1262                          G_IMPLEMENT_INTERFACE (TYPE_ORG_BLUEZ_MANAGER, org_bluez_manager_proxy_iface_init));
1263
1264 static void
1265 org_bluez_manager_proxy_finalize (GObject *object)
1266 {
1267   OrgBluezManagerProxy *proxy = ORG_BLUEZ_MANAGER_PROXY (object);
1268   g_datalist_clear (&proxy->priv->qdata);
1269   G_OBJECT_CLASS (org_bluez_manager_proxy_parent_class)->finalize (object);
1270 }
1271
1272 static void
1273 org_bluez_manager_proxy_get_property (GObject      *object,
1274   guint         prop_id,
1275   GValue       *value,
1276   GParamSpec   *pspec)
1277 {
1278 }
1279
1280 static void
1281 org_bluez_manager_proxy_set_property (GObject      *object,
1282   guint         prop_id,
1283   const GValue *value,
1284   GParamSpec   *pspec)
1285 {
1286 }
1287
1288 static void
1289 org_bluez_manager_proxy_g_signal (GDBusProxy *proxy,
1290   const gchar *sender_name,
1291   const gchar *signal_name,
1292   GVariant *parameters)
1293 {
1294   _ExtendedGDBusSignalInfo *info;
1295   GVariantIter iter;
1296   GVariant *child;
1297   GValue *paramv;
1298   guint num_params;
1299   guint n;
1300   guint signal_id;
1301   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_bluez_manager_interface_info, signal_name);
1302   if (info == NULL)
1303     return;
1304   num_params = g_variant_n_children (parameters);
1305   paramv = g_new0 (GValue, num_params + 1);
1306   g_value_init (&paramv[0], TYPE_ORG_BLUEZ_MANAGER);
1307   g_value_set_object (&paramv[0], proxy);
1308   g_variant_iter_init (&iter, parameters);
1309   n = 1;
1310   while ((child = g_variant_iter_next_value (&iter)) != NULL)
1311     {
1312       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
1313       if (arg_info->use_gvariant)
1314         {
1315           g_value_init (&paramv[n], G_TYPE_VARIANT);
1316           g_value_set_variant (&paramv[n], child);
1317           n++;
1318         }
1319       else
1320         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
1321       g_variant_unref (child);
1322     }
1323   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_BLUEZ_MANAGER);
1324   g_signal_emitv (paramv, signal_id, 0, NULL);
1325   for (n = 0; n < num_params + 1; n++)
1326     g_value_unset (&paramv[n]);
1327   g_free (paramv);
1328 }
1329
1330 static void
1331 org_bluez_manager_proxy_g_properties_changed (GDBusProxy *_proxy,
1332   GVariant *changed_properties,
1333   const gchar *const *invalidated_properties)
1334 {
1335   OrgBluezManagerProxy *proxy = ORG_BLUEZ_MANAGER_PROXY (_proxy);
1336   guint n;
1337   const gchar *key;
1338   GVariantIter *iter;
1339   _ExtendedGDBusPropertyInfo *info;
1340   g_variant_get (changed_properties, "a{sv}", &iter);
1341   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
1342     {
1343       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_manager_interface_info, key);
1344       g_datalist_remove_data (&proxy->priv->qdata, key);
1345       if (info != NULL)
1346         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
1347     }
1348   g_variant_iter_free (iter);
1349   for (n = 0; invalidated_properties[n] != NULL; n++)
1350     {
1351       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_manager_interface_info, invalidated_properties[n]);
1352       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
1353       if (info != NULL)
1354         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
1355     }
1356 }
1357
1358 static void
1359 org_bluez_manager_proxy_init (OrgBluezManagerProxy *proxy)
1360 {
1361   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_BLUEZ_MANAGER_PROXY, OrgBluezManagerProxyPrivate);
1362   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_bluez_manager_interface_info ());
1363 }
1364
1365 static void
1366 org_bluez_manager_proxy_class_init (OrgBluezManagerProxyClass *klass)
1367 {
1368   GObjectClass *gobject_class;
1369   GDBusProxyClass *proxy_class;
1370
1371   g_type_class_add_private (klass, sizeof (OrgBluezManagerProxyPrivate));
1372
1373   gobject_class = G_OBJECT_CLASS (klass);
1374   gobject_class->finalize     = org_bluez_manager_proxy_finalize;
1375   gobject_class->get_property = org_bluez_manager_proxy_get_property;
1376   gobject_class->set_property = org_bluez_manager_proxy_set_property;
1377
1378   proxy_class = G_DBUS_PROXY_CLASS (klass);
1379   proxy_class->g_signal = org_bluez_manager_proxy_g_signal;
1380   proxy_class->g_properties_changed = org_bluez_manager_proxy_g_properties_changed;
1381
1382 }
1383
1384 static void
1385 org_bluez_manager_proxy_iface_init (OrgBluezManagerIface *iface)
1386 {
1387 }
1388
1389 /**
1390  * org_bluez_manager_proxy_new:
1391  * @connection: A #GDBusConnection.
1392  * @flags: Flags from the #GDBusProxyFlags enumeration.
1393  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
1394  * @object_path: An object path.
1395  * @cancellable: (allow-none): A #GCancellable or %NULL.
1396  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
1397  * @user_data: User data to pass to @callback.
1398  *
1399  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link>. See g_dbus_proxy_new() for more details.
1400  *
1401  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
1402  * You can then call org_bluez_manager_proxy_new_finish() to get the result of the operation.
1403  *
1404  * See org_bluez_manager_proxy_new_sync() for the synchronous, blocking version of this constructor.
1405  */
1406 void
1407 org_bluez_manager_proxy_new (
1408     GDBusConnection     *connection,
1409     GDBusProxyFlags      flags,
1410     const gchar         *name,
1411     const gchar         *object_path,
1412     GCancellable        *cancellable,
1413     GAsyncReadyCallback  callback,
1414     gpointer             user_data)
1415 {
1416   g_async_initable_new_async (TYPE_ORG_BLUEZ_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.bluez.Manager", NULL);
1417 }
1418
1419 /**
1420  * org_bluez_manager_proxy_new_finish:
1421  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_proxy_new().
1422  * @error: Return location for error or %NULL
1423  *
1424  * Finishes an operation started with org_bluez_manager_proxy_new().
1425  *
1426  * Returns: (transfer full) (type OrgBluezManagerProxy): The constructed proxy object or %NULL if @error is set.
1427  */
1428 OrgBluezManager *
1429 org_bluez_manager_proxy_new_finish (
1430     GAsyncResult        *res,
1431     GError             **error)
1432 {
1433   GObject *ret;
1434   GObject *source_object;
1435   source_object = g_async_result_get_source_object (res);
1436   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
1437   g_object_unref (source_object);
1438   if (ret != NULL)
1439     return ORG_BLUEZ_MANAGER (ret);
1440   else
1441     return NULL;
1442 }
1443
1444 /**
1445  * org_bluez_manager_proxy_new_sync:
1446  * @connection: A #GDBusConnection.
1447  * @flags: Flags from the #GDBusProxyFlags enumeration.
1448  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
1449  * @object_path: An object path.
1450  * @cancellable: (allow-none): A #GCancellable or %NULL.
1451  * @error: Return location for error or %NULL
1452  *
1453  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link>. See g_dbus_proxy_new_sync() for more details.
1454  *
1455  * The calling thread is blocked until a reply is received.
1456  *
1457  * See org_bluez_manager_proxy_new() for the asynchronous version of this constructor.
1458  *
1459  * Returns: (transfer full) (type OrgBluezManagerProxy): The constructed proxy object or %NULL if @error is set.
1460  */
1461 OrgBluezManager *
1462 org_bluez_manager_proxy_new_sync (
1463     GDBusConnection     *connection,
1464     GDBusProxyFlags      flags,
1465     const gchar         *name,
1466     const gchar         *object_path,
1467     GCancellable        *cancellable,
1468     GError             **error)
1469 {
1470   GInitable *ret;
1471   ret = g_initable_new (TYPE_ORG_BLUEZ_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.bluez.Manager", NULL);
1472   if (ret != NULL)
1473     return ORG_BLUEZ_MANAGER (ret);
1474   else
1475     return NULL;
1476 }
1477
1478
1479 /**
1480  * org_bluez_manager_proxy_new_for_bus:
1481  * @bus_type: A #GBusType.
1482  * @flags: Flags from the #GDBusProxyFlags enumeration.
1483  * @name: A bus name (well-known or unique).
1484  * @object_path: An object path.
1485  * @cancellable: (allow-none): A #GCancellable or %NULL.
1486  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
1487  * @user_data: User data to pass to @callback.
1488  *
1489  * Like org_bluez_manager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
1490  *
1491  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
1492  * You can then call org_bluez_manager_proxy_new_for_bus_finish() to get the result of the operation.
1493  *
1494  * See org_bluez_manager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
1495  */
1496 void
1497 org_bluez_manager_proxy_new_for_bus (
1498     GBusType             bus_type,
1499     GDBusProxyFlags      flags,
1500     const gchar         *name,
1501     const gchar         *object_path,
1502     GCancellable        *cancellable,
1503     GAsyncReadyCallback  callback,
1504     gpointer             user_data)
1505 {
1506   g_async_initable_new_async (TYPE_ORG_BLUEZ_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.bluez.Manager", NULL);
1507 }
1508
1509 /**
1510  * org_bluez_manager_proxy_new_for_bus_finish:
1511  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_manager_proxy_new_for_bus().
1512  * @error: Return location for error or %NULL
1513  *
1514  * Finishes an operation started with org_bluez_manager_proxy_new_for_bus().
1515  *
1516  * Returns: (transfer full) (type OrgBluezManagerProxy): The constructed proxy object or %NULL if @error is set.
1517  */
1518 OrgBluezManager *
1519 org_bluez_manager_proxy_new_for_bus_finish (
1520     GAsyncResult        *res,
1521     GError             **error)
1522 {
1523   GObject *ret;
1524   GObject *source_object;
1525   source_object = g_async_result_get_source_object (res);
1526   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
1527   g_object_unref (source_object);
1528   if (ret != NULL)
1529     return ORG_BLUEZ_MANAGER (ret);
1530   else
1531     return NULL;
1532 }
1533
1534 /**
1535  * org_bluez_manager_proxy_new_for_bus_sync:
1536  * @bus_type: A #GBusType.
1537  * @flags: Flags from the #GDBusProxyFlags enumeration.
1538  * @name: A bus name (well-known or unique).
1539  * @object_path: An object path.
1540  * @cancellable: (allow-none): A #GCancellable or %NULL.
1541  * @error: Return location for error or %NULL
1542  *
1543  * Like org_bluez_manager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
1544  *
1545  * The calling thread is blocked until a reply is received.
1546  *
1547  * See org_bluez_manager_proxy_new_for_bus() for the asynchronous version of this constructor.
1548  *
1549  * Returns: (transfer full) (type OrgBluezManagerProxy): The constructed proxy object or %NULL if @error is set.
1550  */
1551 OrgBluezManager *
1552 org_bluez_manager_proxy_new_for_bus_sync (
1553     GBusType             bus_type,
1554     GDBusProxyFlags      flags,
1555     const gchar         *name,
1556     const gchar         *object_path,
1557     GCancellable        *cancellable,
1558     GError             **error)
1559 {
1560   GInitable *ret;
1561   ret = g_initable_new (TYPE_ORG_BLUEZ_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.bluez.Manager", NULL);
1562   if (ret != NULL)
1563     return ORG_BLUEZ_MANAGER (ret);
1564   else
1565     return NULL;
1566 }
1567
1568
1569 /* ------------------------------------------------------------------------ */
1570
1571 /**
1572  * OrgBluezManagerSkeleton:
1573  *
1574  * The #OrgBluezManagerSkeleton structure contains only private data and should only be accessed using the provided API.
1575  */
1576
1577 /**
1578  * OrgBluezManagerSkeletonClass:
1579  * @parent_class: The parent class.
1580  *
1581  * Class structure for #OrgBluezManagerSkeleton.
1582  */
1583
1584 struct _OrgBluezManagerSkeletonPrivate
1585 {
1586   GValue *properties;
1587   GList *changed_properties;
1588   GSource *changed_properties_idle_source;
1589   GMainContext *context;
1590   GMutex lock;
1591 };
1592
1593 static void
1594 _org_bluez_manager_skeleton_handle_method_call (
1595   GDBusConnection *connection,
1596   const gchar *sender,
1597   const gchar *object_path,
1598   const gchar *interface_name,
1599   const gchar *method_name,
1600   GVariant *parameters,
1601   GDBusMethodInvocation *invocation,
1602   gpointer user_data)
1603 {
1604   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (user_data);
1605   _ExtendedGDBusMethodInfo *info;
1606   GVariantIter iter;
1607   GVariant *child;
1608   GValue *paramv;
1609   guint num_params;
1610   guint num_extra;
1611   guint n;
1612   guint signal_id;
1613   GValue return_value = G_VALUE_INIT;
1614   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
1615   g_assert (info != NULL);
1616   num_params = g_variant_n_children (parameters);
1617   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
1618   n = 0;
1619   g_value_init (&paramv[n], TYPE_ORG_BLUEZ_MANAGER);
1620   g_value_set_object (&paramv[n++], skeleton);
1621   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
1622   g_value_set_object (&paramv[n++], invocation);
1623   if (info->pass_fdlist)
1624     {
1625 #ifdef G_OS_UNIX
1626       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
1627       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
1628 #else
1629       g_assert_not_reached ();
1630 #endif
1631     }
1632   g_variant_iter_init (&iter, parameters);
1633   while ((child = g_variant_iter_next_value (&iter)) != NULL)
1634     {
1635       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
1636       if (arg_info->use_gvariant)
1637         {
1638           g_value_init (&paramv[n], G_TYPE_VARIANT);
1639           g_value_set_variant (&paramv[n], child);
1640           n++;
1641         }
1642       else
1643         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
1644       g_variant_unref (child);
1645     }
1646   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_BLUEZ_MANAGER);
1647   g_value_init (&return_value, G_TYPE_BOOLEAN);
1648   g_signal_emitv (paramv, signal_id, 0, &return_value);
1649   if (!g_value_get_boolean (&return_value))
1650     g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
1651   g_value_unset (&return_value);
1652   for (n = 0; n < num_params + num_extra; n++)
1653     g_value_unset (&paramv[n]);
1654   g_free (paramv);
1655 }
1656
1657 static GVariant *
1658 _org_bluez_manager_skeleton_handle_get_property (
1659   GDBusConnection *connection,
1660   const gchar *sender,
1661   const gchar *object_path,
1662   const gchar *interface_name,
1663   const gchar *property_name,
1664   GError **error,
1665   gpointer user_data)
1666 {
1667   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (user_data);
1668   GValue value = G_VALUE_INIT;
1669   GParamSpec *pspec;
1670   _ExtendedGDBusPropertyInfo *info;
1671   GVariant *ret;
1672   ret = NULL;
1673   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_manager_interface_info, property_name);
1674   g_assert (info != NULL);
1675   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
1676   if (pspec == NULL)
1677     {
1678       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
1679     }
1680   else
1681     {
1682       g_value_init (&value, pspec->value_type);
1683       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
1684       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
1685       g_value_unset (&value);
1686     }
1687   return ret;
1688 }
1689
1690 static gboolean
1691 _org_bluez_manager_skeleton_handle_set_property (
1692   GDBusConnection *connection,
1693   const gchar *sender,
1694   const gchar *object_path,
1695   const gchar *interface_name,
1696   const gchar *property_name,
1697   GVariant *variant,
1698   GError **error,
1699   gpointer user_data)
1700 {
1701   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (user_data);
1702   GValue value = G_VALUE_INIT;
1703   GParamSpec *pspec;
1704   _ExtendedGDBusPropertyInfo *info;
1705   gboolean ret;
1706   ret = FALSE;
1707   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_manager_interface_info, property_name);
1708   g_assert (info != NULL);
1709   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
1710   if (pspec == NULL)
1711     {
1712       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
1713     }
1714   else
1715     {
1716       if (info->use_gvariant)
1717         g_value_set_variant (&value, variant);
1718       else
1719         g_dbus_gvariant_to_gvalue (variant, &value);
1720       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
1721       g_value_unset (&value);
1722       ret = TRUE;
1723     }
1724   return ret;
1725 }
1726
1727 static const GDBusInterfaceVTable _org_bluez_manager_skeleton_vtable =
1728 {
1729   _org_bluez_manager_skeleton_handle_method_call,
1730   _org_bluez_manager_skeleton_handle_get_property,
1731   _org_bluez_manager_skeleton_handle_set_property
1732 };
1733
1734 static GDBusInterfaceInfo *
1735 org_bluez_manager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton)
1736 {
1737   return org_bluez_manager_interface_info ();
1738 }
1739
1740 static GDBusInterfaceVTable *
1741 org_bluez_manager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton)
1742 {
1743   return (GDBusInterfaceVTable *) &_org_bluez_manager_skeleton_vtable;
1744 }
1745
1746 static GVariant *
1747 org_bluez_manager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
1748 {
1749   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (_skeleton);
1750
1751   GVariantBuilder builder;
1752   guint n;
1753   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
1754   if (_org_bluez_manager_interface_info.parent_struct.properties == NULL)
1755     goto out;
1756   for (n = 0; _org_bluez_manager_interface_info.parent_struct.properties[n] != NULL; n++)
1757     {
1758       GDBusPropertyInfo *info = _org_bluez_manager_interface_info.parent_struct.properties[n];
1759       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
1760         {
1761           GVariant *value;
1762           value = _org_bluez_manager_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Manager", info->name, NULL, skeleton);
1763           if (value != NULL)
1764             {
1765               g_variant_take_ref (value);
1766               g_variant_builder_add (&builder, "{sv}", info->name, value);
1767               g_variant_unref (value);
1768             }
1769         }
1770     }
1771 out:
1772   return g_variant_builder_end (&builder);
1773 }
1774
1775 static void
1776 org_bluez_manager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
1777 {
1778 }
1779
1780 static void
1781 _org_bluez_manager_on_signal_property_changed (
1782     OrgBluezManager *object,
1783     const gchar *arg_unnamed_arg0,
1784     GVariant *arg_unnamed_arg1)
1785 {
1786   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (object);
1787
1788   GList      *connections, *l;
1789   GVariant   *signal_variant;
1790   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
1791
1792   signal_variant = g_variant_ref_sink (g_variant_new ("(s@v)",
1793                    arg_unnamed_arg0,
1794                    arg_unnamed_arg1));
1795   for (l = connections; l != NULL; l = l->next)
1796     {
1797       GDBusConnection *connection = l->data;
1798       g_dbus_connection_emit_signal (connection,
1799         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Manager", "PropertyChanged",
1800         signal_variant, NULL);
1801     }
1802   g_variant_unref (signal_variant);
1803   g_list_free_full (connections, g_object_unref);
1804 }
1805
1806 static void
1807 _org_bluez_manager_on_signal_adapter_added (
1808     OrgBluezManager *object,
1809     const gchar *arg_unnamed_arg0)
1810 {
1811   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (object);
1812
1813   GList      *connections, *l;
1814   GVariant   *signal_variant;
1815   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
1816
1817   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
1818                    arg_unnamed_arg0));
1819   for (l = connections; l != NULL; l = l->next)
1820     {
1821       GDBusConnection *connection = l->data;
1822       g_dbus_connection_emit_signal (connection,
1823         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Manager", "AdapterAdded",
1824         signal_variant, NULL);
1825     }
1826   g_variant_unref (signal_variant);
1827   g_list_free_full (connections, g_object_unref);
1828 }
1829
1830 static void
1831 _org_bluez_manager_on_signal_adapter_removed (
1832     OrgBluezManager *object,
1833     const gchar *arg_unnamed_arg0)
1834 {
1835   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (object);
1836
1837   GList      *connections, *l;
1838   GVariant   *signal_variant;
1839   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
1840
1841   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
1842                    arg_unnamed_arg0));
1843   for (l = connections; l != NULL; l = l->next)
1844     {
1845       GDBusConnection *connection = l->data;
1846       g_dbus_connection_emit_signal (connection,
1847         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Manager", "AdapterRemoved",
1848         signal_variant, NULL);
1849     }
1850   g_variant_unref (signal_variant);
1851   g_list_free_full (connections, g_object_unref);
1852 }
1853
1854 static void
1855 _org_bluez_manager_on_signal_default_adapter_changed (
1856     OrgBluezManager *object,
1857     const gchar *arg_unnamed_arg0)
1858 {
1859   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (object);
1860
1861   GList      *connections, *l;
1862   GVariant   *signal_variant;
1863   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
1864
1865   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
1866                    arg_unnamed_arg0));
1867   for (l = connections; l != NULL; l = l->next)
1868     {
1869       GDBusConnection *connection = l->data;
1870       g_dbus_connection_emit_signal (connection,
1871         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Manager", "DefaultAdapterChanged",
1872         signal_variant, NULL);
1873     }
1874   g_variant_unref (signal_variant);
1875   g_list_free_full (connections, g_object_unref);
1876 }
1877
1878 static void org_bluez_manager_skeleton_iface_init (OrgBluezManagerIface *iface);
1879 G_DEFINE_TYPE_WITH_CODE (OrgBluezManagerSkeleton, org_bluez_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
1880                          G_IMPLEMENT_INTERFACE (TYPE_ORG_BLUEZ_MANAGER, org_bluez_manager_skeleton_iface_init));
1881
1882 static void
1883 org_bluez_manager_skeleton_finalize (GObject *object)
1884 {
1885   OrgBluezManagerSkeleton *skeleton = ORG_BLUEZ_MANAGER_SKELETON (object);
1886   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
1887   if (skeleton->priv->changed_properties_idle_source != NULL)
1888     g_source_destroy (skeleton->priv->changed_properties_idle_source);
1889   g_main_context_unref (skeleton->priv->context);
1890   g_mutex_clear (&skeleton->priv->lock);
1891   G_OBJECT_CLASS (org_bluez_manager_skeleton_parent_class)->finalize (object);
1892 }
1893
1894 static void
1895 org_bluez_manager_skeleton_init (OrgBluezManagerSkeleton *skeleton)
1896 {
1897   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_BLUEZ_MANAGER_SKELETON, OrgBluezManagerSkeletonPrivate);
1898   g_mutex_init (&skeleton->priv->lock);
1899   skeleton->priv->context = g_main_context_ref_thread_default ();
1900 }
1901
1902 static void
1903 org_bluez_manager_skeleton_class_init (OrgBluezManagerSkeletonClass *klass)
1904 {
1905   GObjectClass *gobject_class;
1906   GDBusInterfaceSkeletonClass *skeleton_class;
1907
1908   g_type_class_add_private (klass, sizeof (OrgBluezManagerSkeletonPrivate));
1909
1910   gobject_class = G_OBJECT_CLASS (klass);
1911   gobject_class->finalize = org_bluez_manager_skeleton_finalize;
1912
1913   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
1914   skeleton_class->get_info = org_bluez_manager_skeleton_dbus_interface_get_info;
1915   skeleton_class->get_properties = org_bluez_manager_skeleton_dbus_interface_get_properties;
1916   skeleton_class->flush = org_bluez_manager_skeleton_dbus_interface_flush;
1917   skeleton_class->get_vtable = org_bluez_manager_skeleton_dbus_interface_get_vtable;
1918 }
1919
1920 static void
1921 org_bluez_manager_skeleton_iface_init (OrgBluezManagerIface *iface)
1922 {
1923   iface->property_changed = _org_bluez_manager_on_signal_property_changed;
1924   iface->adapter_added = _org_bluez_manager_on_signal_adapter_added;
1925   iface->adapter_removed = _org_bluez_manager_on_signal_adapter_removed;
1926   iface->default_adapter_changed = _org_bluez_manager_on_signal_default_adapter_changed;
1927 }
1928
1929 /**
1930  * org_bluez_manager_skeleton_new:
1931  *
1932  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Manager.top_of_page">org.bluez.Manager</link>.
1933  *
1934  * Returns: (transfer full) (type OrgBluezManagerSkeleton): The skeleton object.
1935  */
1936 OrgBluezManager *
1937 org_bluez_manager_skeleton_new (void)
1938 {
1939   return ORG_BLUEZ_MANAGER (g_object_new (TYPE_ORG_BLUEZ_MANAGER_SKELETON, NULL));
1940 }
1941