plugins/common/bluetoothadapterproxy.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 "bluetoothadapterproxy.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.Adapter
 147  * ------------------------------------------------------------------------
 148  */
 149
 150 /**
 151  * SECTION:OrgBluezAdapter
 152  * @title: OrgBluezAdapter
 153  * @short_description: Generated C code for the org.bluez.Adapter D-Bus interface
 154  *
 155  * This section contains code for working with the <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link> D-Bus interface in C.
 156  */
 157
 158 /* ---- Introspection data for org.bluez.Adapter ---- */
 159
 160 static const _ExtendedGDBusArgInfo _org_bluez_adapter_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_adapter_method_info_get_properties_OUT_ARG_pointers[] =
 172 {
 173   &_org_bluez_adapter_method_info_get_properties_OUT_ARG_unnamed_arg0,
 174   NULL
 175 };
 176
 177 static const GDBusAnnotationInfo _org_bluez_adapter_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_adapter_method_get_properties_annotation_info_pointers[] =
 186 {
 187   &_org_bluez_adapter_method_get_properties_annotation_info_0,
 188   NULL
 189 };
 190
 191 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_get_properties =
 192 {
 193   {
 194     -1,
 195     "GetProperties",
 196     NULL,
 197     (GDBusArgInfo **) &_org_bluez_adapter_method_info_get_properties_OUT_ARG_pointers,
 198     (GDBusAnnotationInfo **) &_org_bluez_adapter_method_get_properties_annotation_info_pointers
 199   },
 200   "handle-get-properties",
 201   FALSE
 202 };
 203
 204 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_set_property_IN_ARG_unnamed_arg0 =
 205 {
 206   {
 207     -1,
 208     "unnamed_arg0",
 209     "s",
 210     NULL
 211   },
 212   FALSE
 213 };
 214
 215 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_set_property_IN_ARG_unnamed_arg1 =
 216 {
 217   {
 218     -1,
 219     "unnamed_arg1",
 220     "v",
 221     NULL
 222   },
 223   FALSE
 224 };
 225
 226 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_set_property_IN_ARG_pointers[] =
 227 {
 228   &_org_bluez_adapter_method_info_set_property_IN_ARG_unnamed_arg0,
 229   &_org_bluez_adapter_method_info_set_property_IN_ARG_unnamed_arg1,
 230   NULL
 231 };
 232
 233 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_set_property =
 234 {
 235   {
 236     -1,
 237     "SetProperty",
 238     (GDBusArgInfo **) &_org_bluez_adapter_method_info_set_property_IN_ARG_pointers,
 239     NULL,
 240     NULL
 241   },
 242   "handle-set-property",
 243   FALSE
 244 };
 245
 246 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_request_session =
 247 {
 248   {
 249     -1,
 250     "RequestSession",
 251     NULL,
 252     NULL,
 253     NULL
 254   },
 255   "handle-request-session",
 256   FALSE
 257 };
 258
 259 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_release_session =
 260 {
 261   {
 262     -1,
 263     "ReleaseSession",
 264     NULL,
 265     NULL,
 266     NULL
 267   },
 268   "handle-release-session",
 269   FALSE
 270 };
 271
 272 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_start_discovery =
 273 {
 274   {
 275     -1,
 276     "StartDiscovery",
 277     NULL,
 278     NULL,
 279     NULL
 280   },
 281   "handle-start-discovery",
 282   FALSE
 283 };
 284
 285 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_stop_discovery =
 286 {
 287   {
 288     -1,
 289     "StopDiscovery",
 290     NULL,
 291     NULL,
 292     NULL
 293   },
 294   "handle-stop-discovery",
 295   FALSE
 296 };
 297
 298 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_list_devices_OUT_ARG_unnamed_arg0 =
 299 {
 300   {
 301     -1,
 302     "unnamed_arg0",
 303     "ao",
 304     NULL
 305   },
 306   FALSE
 307 };
 308
 309 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_list_devices_OUT_ARG_pointers[] =
 310 {
 311   &_org_bluez_adapter_method_info_list_devices_OUT_ARG_unnamed_arg0,
 312   NULL
 313 };
 314
 315 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_list_devices =
 316 {
 317   {
 318     -1,
 319     "ListDevices",
 320     NULL,
 321     (GDBusArgInfo **) &_org_bluez_adapter_method_info_list_devices_OUT_ARG_pointers,
 322     NULL
 323   },
 324   "handle-list-devices",
 325   FALSE
 326 };
 327
 328 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_device_IN_ARG_unnamed_arg0 =
 329 {
 330   {
 331     -1,
 332     "unnamed_arg0",
 333     "s",
 334     NULL
 335   },
 336   FALSE
 337 };
 338
 339 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_create_device_IN_ARG_pointers[] =
 340 {
 341   &_org_bluez_adapter_method_info_create_device_IN_ARG_unnamed_arg0,
 342   NULL
 343 };
 344
 345 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_device_OUT_ARG_unnamed_arg1 =
 346 {
 347   {
 348     -1,
 349     "unnamed_arg1",
 350     "o",
 351     NULL
 352   },
 353   FALSE
 354 };
 355
 356 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_create_device_OUT_ARG_pointers[] =
 357 {
 358   &_org_bluez_adapter_method_info_create_device_OUT_ARG_unnamed_arg1,
 359   NULL
 360 };
 361
 362 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_create_device =
 363 {
 364   {
 365     -1,
 366     "CreateDevice",
 367     (GDBusArgInfo **) &_org_bluez_adapter_method_info_create_device_IN_ARG_pointers,
 368     (GDBusArgInfo **) &_org_bluez_adapter_method_info_create_device_OUT_ARG_pointers,
 369     NULL
 370   },
 371   "handle-create-device",
 372   FALSE
 373 };
 374
 375 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg0 =
 376 {
 377   {
 378     -1,
 379     "unnamed_arg0",
 380     "s",
 381     NULL
 382   },
 383   FALSE
 384 };
 385
 386 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg1 =
 387 {
 388   {
 389     -1,
 390     "unnamed_arg1",
 391     "o",
 392     NULL
 393   },
 394   FALSE
 395 };
 396
 397 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg2 =
 398 {
 399   {
 400     -1,
 401     "unnamed_arg2",
 402     "s",
 403     NULL
 404   },
 405   FALSE
 406 };
 407
 408 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_create_paired_device_IN_ARG_pointers[] =
 409 {
 410   &_org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg0,
 411   &_org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg1,
 412   &_org_bluez_adapter_method_info_create_paired_device_IN_ARG_unnamed_arg2,
 413   NULL
 414 };
 415
 416 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_create_paired_device_OUT_ARG_unnamed_arg3 =
 417 {
 418   {
 419     -1,
 420     "unnamed_arg3",
 421     "o",
 422     NULL
 423   },
 424   FALSE
 425 };
 426
 427 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_create_paired_device_OUT_ARG_pointers[] =
 428 {
 429   &_org_bluez_adapter_method_info_create_paired_device_OUT_ARG_unnamed_arg3,
 430   NULL
 431 };
 432
 433 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_create_paired_device =
 434 {
 435   {
 436     -1,
 437     "CreatePairedDevice",
 438     (GDBusArgInfo **) &_org_bluez_adapter_method_info_create_paired_device_IN_ARG_pointers,
 439     (GDBusArgInfo **) &_org_bluez_adapter_method_info_create_paired_device_OUT_ARG_pointers,
 440     NULL
 441   },
 442   "handle-create-paired-device",
 443   FALSE
 444 };
 445
 446 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_cancel_device_creation_IN_ARG_unnamed_arg0 =
 447 {
 448   {
 449     -1,
 450     "unnamed_arg0",
 451     "s",
 452     NULL
 453   },
 454   FALSE
 455 };
 456
 457 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_cancel_device_creation_IN_ARG_pointers[] =
 458 {
 459   &_org_bluez_adapter_method_info_cancel_device_creation_IN_ARG_unnamed_arg0,
 460   NULL
 461 };
 462
 463 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_cancel_device_creation =
 464 {
 465   {
 466     -1,
 467     "CancelDeviceCreation",
 468     (GDBusArgInfo **) &_org_bluez_adapter_method_info_cancel_device_creation_IN_ARG_pointers,
 469     NULL,
 470     NULL
 471   },
 472   "handle-cancel-device-creation",
 473   FALSE
 474 };
 475
 476 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_remove_device_IN_ARG_unnamed_arg0 =
 477 {
 478   {
 479     -1,
 480     "unnamed_arg0",
 481     "o",
 482     NULL
 483   },
 484   FALSE
 485 };
 486
 487 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_remove_device_IN_ARG_pointers[] =
 488 {
 489   &_org_bluez_adapter_method_info_remove_device_IN_ARG_unnamed_arg0,
 490   NULL
 491 };
 492
 493 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_remove_device =
 494 {
 495   {
 496     -1,
 497     "RemoveDevice",
 498     (GDBusArgInfo **) &_org_bluez_adapter_method_info_remove_device_IN_ARG_pointers,
 499     NULL,
 500     NULL
 501   },
 502   "handle-remove-device",
 503   FALSE
 504 };
 505
 506 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_find_device_IN_ARG_unnamed_arg0 =
 507 {
 508   {
 509     -1,
 510     "unnamed_arg0",
 511     "s",
 512     NULL
 513   },
 514   FALSE
 515 };
 516
 517 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_find_device_IN_ARG_pointers[] =
 518 {
 519   &_org_bluez_adapter_method_info_find_device_IN_ARG_unnamed_arg0,
 520   NULL
 521 };
 522
 523 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_find_device_OUT_ARG_unnamed_arg1 =
 524 {
 525   {
 526     -1,
 527     "unnamed_arg1",
 528     "o",
 529     NULL
 530   },
 531   FALSE
 532 };
 533
 534 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_find_device_OUT_ARG_pointers[] =
 535 {
 536   &_org_bluez_adapter_method_info_find_device_OUT_ARG_unnamed_arg1,
 537   NULL
 538 };
 539
 540 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_find_device =
 541 {
 542   {
 543     -1,
 544     "FindDevice",
 545     (GDBusArgInfo **) &_org_bluez_adapter_method_info_find_device_IN_ARG_pointers,
 546     (GDBusArgInfo **) &_org_bluez_adapter_method_info_find_device_OUT_ARG_pointers,
 547     NULL
 548   },
 549   "handle-find-device",
 550   FALSE
 551 };
 552
 553 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_register_agent_IN_ARG_unnamed_arg0 =
 554 {
 555   {
 556     -1,
 557     "unnamed_arg0",
 558     "o",
 559     NULL
 560   },
 561   FALSE
 562 };
 563
 564 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_register_agent_IN_ARG_unnamed_arg1 =
 565 {
 566   {
 567     -1,
 568     "unnamed_arg1",
 569     "s",
 570     NULL
 571   },
 572   FALSE
 573 };
 574
 575 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_register_agent_IN_ARG_pointers[] =
 576 {
 577   &_org_bluez_adapter_method_info_register_agent_IN_ARG_unnamed_arg0,
 578   &_org_bluez_adapter_method_info_register_agent_IN_ARG_unnamed_arg1,
 579   NULL
 580 };
 581
 582 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_register_agent =
 583 {
 584   {
 585     -1,
 586     "RegisterAgent",
 587     (GDBusArgInfo **) &_org_bluez_adapter_method_info_register_agent_IN_ARG_pointers,
 588     NULL,
 589     NULL
 590   },
 591   "handle-register-agent",
 592   FALSE
 593 };
 594
 595 static const _ExtendedGDBusArgInfo _org_bluez_adapter_method_info_unregister_agent_IN_ARG_unnamed_arg0 =
 596 {
 597   {
 598     -1,
 599     "unnamed_arg0",
 600     "o",
 601     NULL
 602   },
 603   FALSE
 604 };
 605
 606 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_method_info_unregister_agent_IN_ARG_pointers[] =
 607 {
 608   &_org_bluez_adapter_method_info_unregister_agent_IN_ARG_unnamed_arg0,
 609   NULL
 610 };
 611
 612 static const _ExtendedGDBusMethodInfo _org_bluez_adapter_method_info_unregister_agent =
 613 {
 614   {
 615     -1,
 616     "UnregisterAgent",
 617     (GDBusArgInfo **) &_org_bluez_adapter_method_info_unregister_agent_IN_ARG_pointers,
 618     NULL,
 619     NULL
 620   },
 621   "handle-unregister-agent",
 622   FALSE
 623 };
 624
 625 static const _ExtendedGDBusMethodInfo * const _org_bluez_adapter_method_info_pointers[] =
 626 {
 627   &_org_bluez_adapter_method_info_get_properties,
 628   &_org_bluez_adapter_method_info_set_property,
 629   &_org_bluez_adapter_method_info_request_session,
 630   &_org_bluez_adapter_method_info_release_session,
 631   &_org_bluez_adapter_method_info_start_discovery,
 632   &_org_bluez_adapter_method_info_stop_discovery,
 633   &_org_bluez_adapter_method_info_list_devices,
 634   &_org_bluez_adapter_method_info_create_device,
 635   &_org_bluez_adapter_method_info_create_paired_device,
 636   &_org_bluez_adapter_method_info_cancel_device_creation,
 637   &_org_bluez_adapter_method_info_remove_device,
 638   &_org_bluez_adapter_method_info_find_device,
 639   &_org_bluez_adapter_method_info_register_agent,
 640   &_org_bluez_adapter_method_info_unregister_agent,
 641   NULL
 642 };
 643
 644 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_property_changed_ARG_unnamed_arg0 =
 645 {
 646   {
 647     -1,
 648     "unnamed_arg0",
 649     "s",
 650     NULL
 651   },
 652   FALSE
 653 };
 654
 655 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_property_changed_ARG_unnamed_arg1 =
 656 {
 657   {
 658     -1,
 659     "unnamed_arg1",
 660     "v",
 661     NULL
 662   },
 663   FALSE
 664 };
 665
 666 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_signal_info_property_changed_ARG_pointers[] =
 667 {
 668   &_org_bluez_adapter_signal_info_property_changed_ARG_unnamed_arg0,
 669   &_org_bluez_adapter_signal_info_property_changed_ARG_unnamed_arg1,
 670   NULL
 671 };
 672
 673 static const _ExtendedGDBusSignalInfo _org_bluez_adapter_signal_info_property_changed =
 674 {
 675   {
 676     -1,
 677     "PropertyChanged",
 678     (GDBusArgInfo **) &_org_bluez_adapter_signal_info_property_changed_ARG_pointers,
 679     NULL
 680   },
 681   "property-changed"
 682 };
 683
 684 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_device_created_ARG_unnamed_arg0 =
 685 {
 686   {
 687     -1,
 688     "unnamed_arg0",
 689     "o",
 690     NULL
 691   },
 692   FALSE
 693 };
 694
 695 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_signal_info_device_created_ARG_pointers[] =
 696 {
 697   &_org_bluez_adapter_signal_info_device_created_ARG_unnamed_arg0,
 698   NULL
 699 };
 700
 701 static const _ExtendedGDBusSignalInfo _org_bluez_adapter_signal_info_device_created =
 702 {
 703   {
 704     -1,
 705     "DeviceCreated",
 706     (GDBusArgInfo **) &_org_bluez_adapter_signal_info_device_created_ARG_pointers,
 707     NULL
 708   },
 709   "device-created"
 710 };
 711
 712 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_device_removed_ARG_unnamed_arg0 =
 713 {
 714   {
 715     -1,
 716     "unnamed_arg0",
 717     "o",
 718     NULL
 719   },
 720   FALSE
 721 };
 722
 723 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_signal_info_device_removed_ARG_pointers[] =
 724 {
 725   &_org_bluez_adapter_signal_info_device_removed_ARG_unnamed_arg0,
 726   NULL
 727 };
 728
 729 static const _ExtendedGDBusSignalInfo _org_bluez_adapter_signal_info_device_removed =
 730 {
 731   {
 732     -1,
 733     "DeviceRemoved",
 734     (GDBusArgInfo **) &_org_bluez_adapter_signal_info_device_removed_ARG_pointers,
 735     NULL
 736   },
 737   "device-removed"
 738 };
 739
 740 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_device_found_ARG_unnamed_arg0 =
 741 {
 742   {
 743     -1,
 744     "unnamed_arg0",
 745     "s",
 746     NULL
 747   },
 748   FALSE
 749 };
 750
 751 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_device_found_ARG_unnamed_arg1 =
 752 {
 753   {
 754     -1,
 755     "unnamed_arg1",
 756     "a{sv}",
 757     NULL
 758   },
 759   FALSE
 760 };
 761
 762 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_signal_info_device_found_ARG_pointers[] =
 763 {
 764   &_org_bluez_adapter_signal_info_device_found_ARG_unnamed_arg0,
 765   &_org_bluez_adapter_signal_info_device_found_ARG_unnamed_arg1,
 766   NULL
 767 };
 768
 769 static const GDBusAnnotationInfo _org_bluez_adapter_signal_device_found_annotation_info_0 =
 770 {
 771   -1,
 772   "com.trolltech.QtDBus.QtTypeName.In1",
 773   "QVariantMap",
 774   NULL
 775 };
 776
 777 static const GDBusAnnotationInfo * const _org_bluez_adapter_signal_device_found_annotation_info_pointers[] =
 778 {
 779   &_org_bluez_adapter_signal_device_found_annotation_info_0,
 780   NULL
 781 };
 782
 783 static const _ExtendedGDBusSignalInfo _org_bluez_adapter_signal_info_device_found =
 784 {
 785   {
 786     -1,
 787     "DeviceFound",
 788     (GDBusArgInfo **) &_org_bluez_adapter_signal_info_device_found_ARG_pointers,
 789     (GDBusAnnotationInfo **) &_org_bluez_adapter_signal_device_found_annotation_info_pointers
 790   },
 791   "device-found"
 792 };
 793
 794 static const _ExtendedGDBusArgInfo _org_bluez_adapter_signal_info_device_disappeared_ARG_unnamed_arg0 =
 795 {
 796   {
 797     -1,
 798     "unnamed_arg0",
 799     "s",
 800     NULL
 801   },
 802   FALSE
 803 };
 804
 805 static const _ExtendedGDBusArgInfo * const _org_bluez_adapter_signal_info_device_disappeared_ARG_pointers[] =
 806 {
 807   &_org_bluez_adapter_signal_info_device_disappeared_ARG_unnamed_arg0,
 808   NULL
 809 };
 810
 811 static const _ExtendedGDBusSignalInfo _org_bluez_adapter_signal_info_device_disappeared =
 812 {
 813   {
 814     -1,
 815     "DeviceDisappeared",
 816     (GDBusArgInfo **) &_org_bluez_adapter_signal_info_device_disappeared_ARG_pointers,
 817     NULL
 818   },
 819   "device-disappeared"
 820 };
 821
 822 static const _ExtendedGDBusSignalInfo * const _org_bluez_adapter_signal_info_pointers[] =
 823 {
 824   &_org_bluez_adapter_signal_info_property_changed,
 825   &_org_bluez_adapter_signal_info_device_created,
 826   &_org_bluez_adapter_signal_info_device_removed,
 827   &_org_bluez_adapter_signal_info_device_found,
 828   &_org_bluez_adapter_signal_info_device_disappeared,
 829   NULL
 830 };
 831
 832 static const _ExtendedGDBusInterfaceInfo _org_bluez_adapter_interface_info =
 833 {
 834   {
 835     -1,
 836     "org.bluez.Adapter",
 837     (GDBusMethodInfo **) &_org_bluez_adapter_method_info_pointers,
 838     (GDBusSignalInfo **) &_org_bluez_adapter_signal_info_pointers,
 839     NULL,
 840     NULL
 841   },
 842   "org-bluez-adapter",
 843 };
 844
 845
 846 /**
 847  * org_bluez_adapter_interface_info:
 848  *
 849  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link> D-Bus interface.
 850  *
 851  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 852  */
 853 GDBusInterfaceInfo *
 854 org_bluez_adapter_interface_info (void)
 855 {
 856   return (GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info;
 857 }
 858
 859 /**
 860  * org_bluez_adapter_override_properties:
 861  * @klass: The class structure for a #GObject<!-- -->-derived class.
 862  * @property_id_begin: The property id to assign to the first overridden property.
 863  *
 864  * Overrides all #GObject properties in the #OrgBluezAdapter interface for a concrete class.
 865  * The properties are overridden in the order they are defined.
 866  *
 867  * Returns: The last property id.
 868  */
 869 guint
 870 org_bluez_adapter_override_properties (GObjectClass *klass, guint property_id_begin)
 871 {
 872   return property_id_begin - 1;
 873 }
 874
 875
 876
 877 /**
 878  * OrgBluezAdapter:
 879  *
 880  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link>.
 881  */
 882
 883 /**
 884  * OrgBluezAdapterIface:
 885  * @parent_iface: The parent interface.
 886  * @handle_cancel_device_creation: Handler for the #OrgBluezAdapter::handle-cancel-device-creation signal.
 887  * @handle_create_device: Handler for the #OrgBluezAdapter::handle-create-device signal.
 888  * @handle_create_paired_device: Handler for the #OrgBluezAdapter::handle-create-paired-device signal.
 889  * @handle_find_device: Handler for the #OrgBluezAdapter::handle-find-device signal.
 890  * @handle_get_properties: Handler for the #OrgBluezAdapter::handle-get-properties signal.
 891  * @handle_list_devices: Handler for the #OrgBluezAdapter::handle-list-devices signal.
 892  * @handle_register_agent: Handler for the #OrgBluezAdapter::handle-register-agent signal.
 893  * @handle_release_session: Handler for the #OrgBluezAdapter::handle-release-session signal.
 894  * @handle_remove_device: Handler for the #OrgBluezAdapter::handle-remove-device signal.
 895  * @handle_request_session: Handler for the #OrgBluezAdapter::handle-request-session signal.
 896  * @handle_set_property: Handler for the #OrgBluezAdapter::handle-set-property signal.
 897  * @handle_start_discovery: Handler for the #OrgBluezAdapter::handle-start-discovery signal.
 898  * @handle_stop_discovery: Handler for the #OrgBluezAdapter::handle-stop-discovery signal.
 899  * @handle_unregister_agent: Handler for the #OrgBluezAdapter::handle-unregister-agent signal.
 900  * @device_created: Handler for the #OrgBluezAdapter::device-created signal.
 901  * @device_disappeared: Handler for the #OrgBluezAdapter::device-disappeared signal.
 902  * @device_found: Handler for the #OrgBluezAdapter::device-found signal.
 903  * @device_removed: Handler for the #OrgBluezAdapter::device-removed signal.
 904  * @property_changed: Handler for the #OrgBluezAdapter::property-changed signal.
 905  *
 906  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link>.
 907  */
 908
 909 static void
 910 org_bluez_adapter_default_init (OrgBluezAdapterIface *iface)
 911 {
 912   /* GObject signals for incoming D-Bus method calls: */
 913   /**
 914    * OrgBluezAdapter::handle-get-properties:
 915    * @object: A #OrgBluezAdapter.
 916    * @invocation: A #GDBusMethodInvocation.
 917    *
 918    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.GetProperties">GetProperties()</link> D-Bus method.
 919    *
 920    * 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_adapter_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.
 921    *
 922    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 923    */
 924   g_signal_new ("handle-get-properties",
 925     G_TYPE_FROM_INTERFACE (iface),
 926     G_SIGNAL_RUN_LAST,
 927     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_get_properties),
 928     g_signal_accumulator_true_handled,
 929     NULL,
 930     g_cclosure_marshal_generic,
 931     G_TYPE_BOOLEAN,
 932     1,
 933     G_TYPE_DBUS_METHOD_INVOCATION);
 934
 935   /**
 936    * OrgBluezAdapter::handle-set-property:
 937    * @object: A #OrgBluezAdapter.
 938    * @invocation: A #GDBusMethodInvocation.
 939    * @arg_unnamed_arg0: Argument passed by remote caller.
 940    * @arg_unnamed_arg1: Argument passed by remote caller.
 941    *
 942    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.SetProperty">SetProperty()</link> D-Bus method.
 943    *
 944    * 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_adapter_complete_set_property() 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.
 945    *
 946    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 947    */
 948   g_signal_new ("handle-set-property",
 949     G_TYPE_FROM_INTERFACE (iface),
 950     G_SIGNAL_RUN_LAST,
 951     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_set_property),
 952     g_signal_accumulator_true_handled,
 953     NULL,
 954     g_cclosure_marshal_generic,
 955     G_TYPE_BOOLEAN,
 956     3,
 957     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);
 958
 959   /**
 960    * OrgBluezAdapter::handle-request-session:
 961    * @object: A #OrgBluezAdapter.
 962    * @invocation: A #GDBusMethodInvocation.
 963    *
 964    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.RequestSession">RequestSession()</link> D-Bus method.
 965    *
 966    * 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_adapter_complete_request_session() 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.
 967    *
 968    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 969    */
 970   g_signal_new ("handle-request-session",
 971     G_TYPE_FROM_INTERFACE (iface),
 972     G_SIGNAL_RUN_LAST,
 973     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_request_session),
 974     g_signal_accumulator_true_handled,
 975     NULL,
 976     g_cclosure_marshal_generic,
 977     G_TYPE_BOOLEAN,
 978     1,
 979     G_TYPE_DBUS_METHOD_INVOCATION);
 980
 981   /**
 982    * OrgBluezAdapter::handle-release-session:
 983    * @object: A #OrgBluezAdapter.
 984    * @invocation: A #GDBusMethodInvocation.
 985    *
 986    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.ReleaseSession">ReleaseSession()</link> D-Bus method.
 987    *
 988    * 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_adapter_complete_release_session() 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.
 989    *
 990    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 991    */
 992   g_signal_new ("handle-release-session",
 993     G_TYPE_FROM_INTERFACE (iface),
 994     G_SIGNAL_RUN_LAST,
 995     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_release_session),
 996     g_signal_accumulator_true_handled,
 997     NULL,
 998     g_cclosure_marshal_generic,
 999     G_TYPE_BOOLEAN,
1000     1,
1001     G_TYPE_DBUS_METHOD_INVOCATION);
1002
1003   /**
1004    * OrgBluezAdapter::handle-start-discovery:
1005    * @object: A #OrgBluezAdapter.
1006    * @invocation: A #GDBusMethodInvocation.
1007    *
1008    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.StartDiscovery">StartDiscovery()</link> D-Bus method.
1009    *
1010    * 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_adapter_complete_start_discovery() 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.
1011    *
1012    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1013    */
1014   g_signal_new ("handle-start-discovery",
1015     G_TYPE_FROM_INTERFACE (iface),
1016     G_SIGNAL_RUN_LAST,
1017     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_start_discovery),
1018     g_signal_accumulator_true_handled,
1019     NULL,
1020     g_cclosure_marshal_generic,
1021     G_TYPE_BOOLEAN,
1022     1,
1023     G_TYPE_DBUS_METHOD_INVOCATION);
1024
1025   /**
1026    * OrgBluezAdapter::handle-stop-discovery:
1027    * @object: A #OrgBluezAdapter.
1028    * @invocation: A #GDBusMethodInvocation.
1029    *
1030    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.StopDiscovery">StopDiscovery()</link> D-Bus method.
1031    *
1032    * 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_adapter_complete_stop_discovery() 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.
1033    *
1034    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1035    */
1036   g_signal_new ("handle-stop-discovery",
1037     G_TYPE_FROM_INTERFACE (iface),
1038     G_SIGNAL_RUN_LAST,
1039     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_stop_discovery),
1040     g_signal_accumulator_true_handled,
1041     NULL,
1042     g_cclosure_marshal_generic,
1043     G_TYPE_BOOLEAN,
1044     1,
1045     G_TYPE_DBUS_METHOD_INVOCATION);
1046
1047   /**
1048    * OrgBluezAdapter::handle-list-devices:
1049    * @object: A #OrgBluezAdapter.
1050    * @invocation: A #GDBusMethodInvocation.
1051    *
1052    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.ListDevices">ListDevices()</link> D-Bus method.
1053    *
1054    * 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_adapter_complete_list_devices() 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.
1055    *
1056    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1057    */
1058   g_signal_new ("handle-list-devices",
1059     G_TYPE_FROM_INTERFACE (iface),
1060     G_SIGNAL_RUN_LAST,
1061     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_list_devices),
1062     g_signal_accumulator_true_handled,
1063     NULL,
1064     g_cclosure_marshal_generic,
1065     G_TYPE_BOOLEAN,
1066     1,
1067     G_TYPE_DBUS_METHOD_INVOCATION);
1068
1069   /**
1070    * OrgBluezAdapter::handle-create-device:
1071    * @object: A #OrgBluezAdapter.
1072    * @invocation: A #GDBusMethodInvocation.
1073    * @arg_unnamed_arg0: Argument passed by remote caller.
1074    *
1075    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.CreateDevice">CreateDevice()</link> D-Bus method.
1076    *
1077    * 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_adapter_complete_create_device() 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.
1078    *
1079    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1080    */
1081   g_signal_new ("handle-create-device",
1082     G_TYPE_FROM_INTERFACE (iface),
1083     G_SIGNAL_RUN_LAST,
1084     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_create_device),
1085     g_signal_accumulator_true_handled,
1086     NULL,
1087     g_cclosure_marshal_generic,
1088     G_TYPE_BOOLEAN,
1089     2,
1090     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
1091
1092   /**
1093    * OrgBluezAdapter::handle-create-paired-device:
1094    * @object: A #OrgBluezAdapter.
1095    * @invocation: A #GDBusMethodInvocation.
1096    * @arg_unnamed_arg0: Argument passed by remote caller.
1097    * @arg_unnamed_arg1: Argument passed by remote caller.
1098    * @arg_unnamed_arg2: Argument passed by remote caller.
1099    *
1100    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.CreatePairedDevice">CreatePairedDevice()</link> D-Bus method.
1101    *
1102    * 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_adapter_complete_create_paired_device() 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.
1103    *
1104    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1105    */
1106   g_signal_new ("handle-create-paired-device",
1107     G_TYPE_FROM_INTERFACE (iface),
1108     G_SIGNAL_RUN_LAST,
1109     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_create_paired_device),
1110     g_signal_accumulator_true_handled,
1111     NULL,
1112     g_cclosure_marshal_generic,
1113     G_TYPE_BOOLEAN,
1114     4,
1115     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
1116
1117   /**
1118    * OrgBluezAdapter::handle-cancel-device-creation:
1119    * @object: A #OrgBluezAdapter.
1120    * @invocation: A #GDBusMethodInvocation.
1121    * @arg_unnamed_arg0: Argument passed by remote caller.
1122    *
1123    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.CancelDeviceCreation">CancelDeviceCreation()</link> D-Bus method.
1124    *
1125    * 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_adapter_complete_cancel_device_creation() 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.
1126    *
1127    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1128    */
1129   g_signal_new ("handle-cancel-device-creation",
1130     G_TYPE_FROM_INTERFACE (iface),
1131     G_SIGNAL_RUN_LAST,
1132     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_cancel_device_creation),
1133     g_signal_accumulator_true_handled,
1134     NULL,
1135     g_cclosure_marshal_generic,
1136     G_TYPE_BOOLEAN,
1137     2,
1138     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
1139
1140   /**
1141    * OrgBluezAdapter::handle-remove-device:
1142    * @object: A #OrgBluezAdapter.
1143    * @invocation: A #GDBusMethodInvocation.
1144    * @arg_unnamed_arg0: Argument passed by remote caller.
1145    *
1146    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.RemoveDevice">RemoveDevice()</link> D-Bus method.
1147    *
1148    * 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_adapter_complete_remove_device() 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.
1149    *
1150    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1151    */
1152   g_signal_new ("handle-remove-device",
1153     G_TYPE_FROM_INTERFACE (iface),
1154     G_SIGNAL_RUN_LAST,
1155     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_remove_device),
1156     g_signal_accumulator_true_handled,
1157     NULL,
1158     g_cclosure_marshal_generic,
1159     G_TYPE_BOOLEAN,
1160     2,
1161     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
1162
1163   /**
1164    * OrgBluezAdapter::handle-find-device:
1165    * @object: A #OrgBluezAdapter.
1166    * @invocation: A #GDBusMethodInvocation.
1167    * @arg_unnamed_arg0: Argument passed by remote caller.
1168    *
1169    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.FindDevice">FindDevice()</link> D-Bus method.
1170    *
1171    * 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_adapter_complete_find_device() 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.
1172    *
1173    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1174    */
1175   g_signal_new ("handle-find-device",
1176     G_TYPE_FROM_INTERFACE (iface),
1177     G_SIGNAL_RUN_LAST,
1178     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_find_device),
1179     g_signal_accumulator_true_handled,
1180     NULL,
1181     g_cclosure_marshal_generic,
1182     G_TYPE_BOOLEAN,
1183     2,
1184     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
1185
1186   /**
1187    * OrgBluezAdapter::handle-register-agent:
1188    * @object: A #OrgBluezAdapter.
1189    * @invocation: A #GDBusMethodInvocation.
1190    * @arg_unnamed_arg0: Argument passed by remote caller.
1191    * @arg_unnamed_arg1: Argument passed by remote caller.
1192    *
1193    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.RegisterAgent">RegisterAgent()</link> D-Bus method.
1194    *
1195    * 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_adapter_complete_register_agent() 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.
1196    *
1197    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1198    */
1199   g_signal_new ("handle-register-agent",
1200     G_TYPE_FROM_INTERFACE (iface),
1201     G_SIGNAL_RUN_LAST,
1202     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_register_agent),
1203     g_signal_accumulator_true_handled,
1204     NULL,
1205     g_cclosure_marshal_generic,
1206     G_TYPE_BOOLEAN,
1207     3,
1208     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING);
1209
1210   /**
1211    * OrgBluezAdapter::handle-unregister-agent:
1212    * @object: A #OrgBluezAdapter.
1213    * @invocation: A #GDBusMethodInvocation.
1214    * @arg_unnamed_arg0: Argument passed by remote caller.
1215    *
1216    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-bluez-Adapter.UnregisterAgent">UnregisterAgent()</link> D-Bus method.
1217    *
1218    * 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_adapter_complete_unregister_agent() 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.
1219    *
1220    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
1221    */
1222   g_signal_new ("handle-unregister-agent",
1223     G_TYPE_FROM_INTERFACE (iface),
1224     G_SIGNAL_RUN_LAST,
1225     G_STRUCT_OFFSET (OrgBluezAdapterIface, handle_unregister_agent),
1226     g_signal_accumulator_true_handled,
1227     NULL,
1228     g_cclosure_marshal_generic,
1229     G_TYPE_BOOLEAN,
1230     2,
1231     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
1232
1233   /* GObject signals for received D-Bus signals: */
1234   /**
1235    * OrgBluezAdapter::property-changed:
1236    * @object: A #OrgBluezAdapter.
1237    * @arg_unnamed_arg0: Argument.
1238    * @arg_unnamed_arg1: Argument.
1239    *
1240    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Adapter.PropertyChanged">"PropertyChanged"</link> is received.
1241    *
1242    * 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.
1243    */
1244   g_signal_new ("property-changed",
1245     G_TYPE_FROM_INTERFACE (iface),
1246     G_SIGNAL_RUN_LAST,
1247     G_STRUCT_OFFSET (OrgBluezAdapterIface, property_changed),
1248     NULL,
1249     NULL,
1250     g_cclosure_marshal_generic,
1251     G_TYPE_NONE,
1252     2, G_TYPE_STRING, G_TYPE_VARIANT);
1253
1254   /**
1255    * OrgBluezAdapter::device-created:
1256    * @object: A #OrgBluezAdapter.
1257    * @arg_unnamed_arg0: Argument.
1258    *
1259    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Adapter.DeviceCreated">"DeviceCreated"</link> is received.
1260    *
1261    * 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.
1262    */
1263   g_signal_new ("device-created",
1264     G_TYPE_FROM_INTERFACE (iface),
1265     G_SIGNAL_RUN_LAST,
1266     G_STRUCT_OFFSET (OrgBluezAdapterIface, device_created),
1267     NULL,
1268     NULL,
1269     g_cclosure_marshal_generic,
1270     G_TYPE_NONE,
1271     1, G_TYPE_STRING);
1272
1273   /**
1274    * OrgBluezAdapter::device-removed:
1275    * @object: A #OrgBluezAdapter.
1276    * @arg_unnamed_arg0: Argument.
1277    *
1278    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Adapter.DeviceRemoved">"DeviceRemoved"</link> is received.
1279    *
1280    * 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.
1281    */
1282   g_signal_new ("device-removed",
1283     G_TYPE_FROM_INTERFACE (iface),
1284     G_SIGNAL_RUN_LAST,
1285     G_STRUCT_OFFSET (OrgBluezAdapterIface, device_removed),
1286     NULL,
1287     NULL,
1288     g_cclosure_marshal_generic,
1289     G_TYPE_NONE,
1290     1, G_TYPE_STRING);
1291
1292   /**
1293    * OrgBluezAdapter::device-found:
1294    * @object: A #OrgBluezAdapter.
1295    * @arg_unnamed_arg0: Argument.
1296    * @arg_unnamed_arg1: Argument.
1297    *
1298    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Adapter.DeviceFound">"DeviceFound"</link> is received.
1299    *
1300    * 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.
1301    */
1302   g_signal_new ("device-found",
1303     G_TYPE_FROM_INTERFACE (iface),
1304     G_SIGNAL_RUN_LAST,
1305     G_STRUCT_OFFSET (OrgBluezAdapterIface, device_found),
1306     NULL,
1307     NULL,
1308     g_cclosure_marshal_generic,
1309     G_TYPE_NONE,
1310     2, G_TYPE_STRING, G_TYPE_VARIANT);
1311
1312   /**
1313    * OrgBluezAdapter::device-disappeared:
1314    * @object: A #OrgBluezAdapter.
1315    * @arg_unnamed_arg0: Argument.
1316    *
1317    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-bluez-Adapter.DeviceDisappeared">"DeviceDisappeared"</link> is received.
1318    *
1319    * 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.
1320    */
1321   g_signal_new ("device-disappeared",
1322     G_TYPE_FROM_INTERFACE (iface),
1323     G_SIGNAL_RUN_LAST,
1324     G_STRUCT_OFFSET (OrgBluezAdapterIface, device_disappeared),
1325     NULL,
1326     NULL,
1327     g_cclosure_marshal_generic,
1328     G_TYPE_NONE,
1329     1, G_TYPE_STRING);
1330
1331 }
1332
1333 typedef OrgBluezAdapterIface OrgBluezAdapterInterface;
1334 G_DEFINE_INTERFACE (OrgBluezAdapter, org_bluez_adapter, G_TYPE_OBJECT);
1335
1336 /**
1337  * org_bluez_adapter_emit_property_changed:
1338  * @object: A #OrgBluezAdapter.
1339  * @arg_unnamed_arg0: Argument to pass with the signal.
1340  * @arg_unnamed_arg1: Argument to pass with the signal.
1341  *
1342  * Emits the <link linkend="gdbus-signal-org-bluez-Adapter.PropertyChanged">"PropertyChanged"</link> D-Bus signal.
1343  */
1344 void
1345 org_bluez_adapter_emit_property_changed (
1346     OrgBluezAdapter *object,
1347     const gchar *arg_unnamed_arg0,
1348     GVariant *arg_unnamed_arg1)
1349 {
1350   g_signal_emit_by_name (object, "property-changed", arg_unnamed_arg0, arg_unnamed_arg1);
1351 }
1352
1353 /**
1354  * org_bluez_adapter_emit_device_created:
1355  * @object: A #OrgBluezAdapter.
1356  * @arg_unnamed_arg0: Argument to pass with the signal.
1357  *
1358  * Emits the <link linkend="gdbus-signal-org-bluez-Adapter.DeviceCreated">"DeviceCreated"</link> D-Bus signal.
1359  */
1360 void
1361 org_bluez_adapter_emit_device_created (
1362     OrgBluezAdapter *object,
1363     const gchar *arg_unnamed_arg0)
1364 {
1365   g_signal_emit_by_name (object, "device-created", arg_unnamed_arg0);
1366 }
1367
1368 /**
1369  * org_bluez_adapter_emit_device_removed:
1370  * @object: A #OrgBluezAdapter.
1371  * @arg_unnamed_arg0: Argument to pass with the signal.
1372  *
1373  * Emits the <link linkend="gdbus-signal-org-bluez-Adapter.DeviceRemoved">"DeviceRemoved"</link> D-Bus signal.
1374  */
1375 void
1376 org_bluez_adapter_emit_device_removed (
1377     OrgBluezAdapter *object,
1378     const gchar *arg_unnamed_arg0)
1379 {
1380   g_signal_emit_by_name (object, "device-removed", arg_unnamed_arg0);
1381 }
1382
1383 /**
1384  * org_bluez_adapter_emit_device_found:
1385  * @object: A #OrgBluezAdapter.
1386  * @arg_unnamed_arg0: Argument to pass with the signal.
1387  * @arg_unnamed_arg1: Argument to pass with the signal.
1388  *
1389  * Emits the <link linkend="gdbus-signal-org-bluez-Adapter.DeviceFound">"DeviceFound"</link> D-Bus signal.
1390  */
1391 void
1392 org_bluez_adapter_emit_device_found (
1393     OrgBluezAdapter *object,
1394     const gchar *arg_unnamed_arg0,
1395     GVariant *arg_unnamed_arg1)
1396 {
1397   g_signal_emit_by_name (object, "device-found", arg_unnamed_arg0, arg_unnamed_arg1);
1398 }
1399
1400 /**
1401  * org_bluez_adapter_emit_device_disappeared:
1402  * @object: A #OrgBluezAdapter.
1403  * @arg_unnamed_arg0: Argument to pass with the signal.
1404  *
1405  * Emits the <link linkend="gdbus-signal-org-bluez-Adapter.DeviceDisappeared">"DeviceDisappeared"</link> D-Bus signal.
1406  */
1407 void
1408 org_bluez_adapter_emit_device_disappeared (
1409     OrgBluezAdapter *object,
1410     const gchar *arg_unnamed_arg0)
1411 {
1412   g_signal_emit_by_name (object, "device-disappeared", arg_unnamed_arg0);
1413 }
1414
1415 /**
1416  * org_bluez_adapter_call_get_properties:
1417  * @proxy: A #OrgBluezAdapterProxy.
1418  * @cancellable: (allow-none): A #GCancellable or %NULL.
1419  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1420  * @user_data: User data to pass to @callback.
1421  *
1422  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.GetProperties">GetProperties()</link> D-Bus method on @proxy.
1423  * 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.
1424  * You can then call org_bluez_adapter_call_get_properties_finish() to get the result of the operation.
1425  *
1426  * See org_bluez_adapter_call_get_properties_sync() for the synchronous, blocking version of this method.
1427  */
1428 void
1429 org_bluez_adapter_call_get_properties (
1430     OrgBluezAdapter *proxy,
1431     GCancellable *cancellable,
1432     GAsyncReadyCallback callback,
1433     gpointer user_data)
1434 {
1435   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1436     "GetProperties",
1437     g_variant_new ("()"),
1438     G_DBUS_CALL_FLAGS_NONE,
1439     -1,
1440     cancellable,
1441     callback,
1442     user_data);
1443 }
1444
1445 /**
1446  * org_bluez_adapter_call_get_properties_finish:
1447  * @proxy: A #OrgBluezAdapterProxy.
1448  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1449  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_get_properties().
1450  * @error: Return location for error or %NULL.
1451  *
1452  * Finishes an operation started with org_bluez_adapter_call_get_properties().
1453  *
1454  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1455  */
1456 gboolean
1457 org_bluez_adapter_call_get_properties_finish (
1458     OrgBluezAdapter *proxy,
1459     GVariant **out_unnamed_arg0,
1460     GAsyncResult *res,
1461     GError **error)
1462 {
1463   GVariant *_ret;
1464   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1465   if (_ret == NULL)
1466     goto _out;
1467   g_variant_get (_ret,
1468                  "(@a{sv})",
1469                  out_unnamed_arg0);
1470   g_variant_unref (_ret);
1471 _out:
1472   return _ret != NULL;
1473 }
1474
1475 /**
1476  * org_bluez_adapter_call_get_properties_sync:
1477  * @proxy: A #OrgBluezAdapterProxy.
1478  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1479  * @cancellable: (allow-none): A #GCancellable or %NULL.
1480  * @error: Return location for error or %NULL.
1481  *
1482  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.GetProperties">GetProperties()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1483  *
1484  * See org_bluez_adapter_call_get_properties() for the asynchronous version of this method.
1485  *
1486  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1487  */
1488 gboolean
1489 org_bluez_adapter_call_get_properties_sync (
1490     OrgBluezAdapter *proxy,
1491     GVariant **out_unnamed_arg0,
1492     GCancellable *cancellable,
1493     GError **error)
1494 {
1495   GVariant *_ret;
1496   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1497     "GetProperties",
1498     g_variant_new ("()"),
1499     G_DBUS_CALL_FLAGS_NONE,
1500     -1,
1501     cancellable,
1502     error);
1503   if (_ret == NULL)
1504     goto _out;
1505   g_variant_get (_ret,
1506                  "(@a{sv})",
1507                  out_unnamed_arg0);
1508   g_variant_unref (_ret);
1509 _out:
1510   return _ret != NULL;
1511 }
1512
1513 /**
1514  * org_bluez_adapter_call_set_property:
1515  * @proxy: A #OrgBluezAdapterProxy.
1516  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1517  * @arg_unnamed_arg1: Argument to pass with the method invocation.
1518  * @cancellable: (allow-none): A #GCancellable or %NULL.
1519  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1520  * @user_data: User data to pass to @callback.
1521  *
1522  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.SetProperty">SetProperty()</link> D-Bus method on @proxy.
1523  * 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.
1524  * You can then call org_bluez_adapter_call_set_property_finish() to get the result of the operation.
1525  *
1526  * See org_bluez_adapter_call_set_property_sync() for the synchronous, blocking version of this method.
1527  */
1528 void
1529 org_bluez_adapter_call_set_property (
1530     OrgBluezAdapter *proxy,
1531     const gchar *arg_unnamed_arg0,
1532     GVariant *arg_unnamed_arg1,
1533     GCancellable *cancellable,
1534     GAsyncReadyCallback callback,
1535     gpointer user_data)
1536 {
1537   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1538     "SetProperty",
1539     g_variant_new ("(s@v)",
1540                    arg_unnamed_arg0,
1541                    arg_unnamed_arg1),
1542     G_DBUS_CALL_FLAGS_NONE,
1543     -1,
1544     cancellable,
1545     callback,
1546     user_data);
1547 }
1548
1549 /**
1550  * org_bluez_adapter_call_set_property_finish:
1551  * @proxy: A #OrgBluezAdapterProxy.
1552  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_set_property().
1553  * @error: Return location for error or %NULL.
1554  *
1555  * Finishes an operation started with org_bluez_adapter_call_set_property().
1556  *
1557  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1558  */
1559 gboolean
1560 org_bluez_adapter_call_set_property_finish (
1561     OrgBluezAdapter *proxy,
1562     GAsyncResult *res,
1563     GError **error)
1564 {
1565   GVariant *_ret;
1566   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1567   if (_ret == NULL)
1568     goto _out;
1569   g_variant_get (_ret,
1570                  "()");
1571   g_variant_unref (_ret);
1572 _out:
1573   return _ret != NULL;
1574 }
1575
1576 /**
1577  * org_bluez_adapter_call_set_property_sync:
1578  * @proxy: A #OrgBluezAdapterProxy.
1579  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1580  * @arg_unnamed_arg1: Argument to pass with the method invocation.
1581  * @cancellable: (allow-none): A #GCancellable or %NULL.
1582  * @error: Return location for error or %NULL.
1583  *
1584  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.SetProperty">SetProperty()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1585  *
1586  * See org_bluez_adapter_call_set_property() for the asynchronous version of this method.
1587  *
1588  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1589  */
1590 gboolean
1591 org_bluez_adapter_call_set_property_sync (
1592     OrgBluezAdapter *proxy,
1593     const gchar *arg_unnamed_arg0,
1594     GVariant *arg_unnamed_arg1,
1595     GCancellable *cancellable,
1596     GError **error)
1597 {
1598   GVariant *_ret;
1599   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1600     "SetProperty",
1601     g_variant_new ("(s@v)",
1602                    arg_unnamed_arg0,
1603                    arg_unnamed_arg1),
1604     G_DBUS_CALL_FLAGS_NONE,
1605     -1,
1606     cancellable,
1607     error);
1608   if (_ret == NULL)
1609     goto _out;
1610   g_variant_get (_ret,
1611                  "()");
1612   g_variant_unref (_ret);
1613 _out:
1614   return _ret != NULL;
1615 }
1616
1617 /**
1618  * org_bluez_adapter_call_request_session:
1619  * @proxy: A #OrgBluezAdapterProxy.
1620  * @cancellable: (allow-none): A #GCancellable or %NULL.
1621  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1622  * @user_data: User data to pass to @callback.
1623  *
1624  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RequestSession">RequestSession()</link> D-Bus method on @proxy.
1625  * 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.
1626  * You can then call org_bluez_adapter_call_request_session_finish() to get the result of the operation.
1627  *
1628  * See org_bluez_adapter_call_request_session_sync() for the synchronous, blocking version of this method.
1629  */
1630 void
1631 org_bluez_adapter_call_request_session (
1632     OrgBluezAdapter *proxy,
1633     GCancellable *cancellable,
1634     GAsyncReadyCallback callback,
1635     gpointer user_data)
1636 {
1637   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1638     "RequestSession",
1639     g_variant_new ("()"),
1640     G_DBUS_CALL_FLAGS_NONE,
1641     -1,
1642     cancellable,
1643     callback,
1644     user_data);
1645 }
1646
1647 /**
1648  * org_bluez_adapter_call_request_session_finish:
1649  * @proxy: A #OrgBluezAdapterProxy.
1650  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_request_session().
1651  * @error: Return location for error or %NULL.
1652  *
1653  * Finishes an operation started with org_bluez_adapter_call_request_session().
1654  *
1655  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1656  */
1657 gboolean
1658 org_bluez_adapter_call_request_session_finish (
1659     OrgBluezAdapter *proxy,
1660     GAsyncResult *res,
1661     GError **error)
1662 {
1663   GVariant *_ret;
1664   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1665   if (_ret == NULL)
1666     goto _out;
1667   g_variant_get (_ret,
1668                  "()");
1669   g_variant_unref (_ret);
1670 _out:
1671   return _ret != NULL;
1672 }
1673
1674 /**
1675  * org_bluez_adapter_call_request_session_sync:
1676  * @proxy: A #OrgBluezAdapterProxy.
1677  * @cancellable: (allow-none): A #GCancellable or %NULL.
1678  * @error: Return location for error or %NULL.
1679  *
1680  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RequestSession">RequestSession()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1681  *
1682  * See org_bluez_adapter_call_request_session() for the asynchronous version of this method.
1683  *
1684  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1685  */
1686 gboolean
1687 org_bluez_adapter_call_request_session_sync (
1688     OrgBluezAdapter *proxy,
1689     GCancellable *cancellable,
1690     GError **error)
1691 {
1692   GVariant *_ret;
1693   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1694     "RequestSession",
1695     g_variant_new ("()"),
1696     G_DBUS_CALL_FLAGS_NONE,
1697     -1,
1698     cancellable,
1699     error);
1700   if (_ret == NULL)
1701     goto _out;
1702   g_variant_get (_ret,
1703                  "()");
1704   g_variant_unref (_ret);
1705 _out:
1706   return _ret != NULL;
1707 }
1708
1709 /**
1710  * org_bluez_adapter_call_release_session:
1711  * @proxy: A #OrgBluezAdapterProxy.
1712  * @cancellable: (allow-none): A #GCancellable or %NULL.
1713  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1714  * @user_data: User data to pass to @callback.
1715  *
1716  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.ReleaseSession">ReleaseSession()</link> D-Bus method on @proxy.
1717  * 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.
1718  * You can then call org_bluez_adapter_call_release_session_finish() to get the result of the operation.
1719  *
1720  * See org_bluez_adapter_call_release_session_sync() for the synchronous, blocking version of this method.
1721  */
1722 void
1723 org_bluez_adapter_call_release_session (
1724     OrgBluezAdapter *proxy,
1725     GCancellable *cancellable,
1726     GAsyncReadyCallback callback,
1727     gpointer user_data)
1728 {
1729   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1730     "ReleaseSession",
1731     g_variant_new ("()"),
1732     G_DBUS_CALL_FLAGS_NONE,
1733     -1,
1734     cancellable,
1735     callback,
1736     user_data);
1737 }
1738
1739 /**
1740  * org_bluez_adapter_call_release_session_finish:
1741  * @proxy: A #OrgBluezAdapterProxy.
1742  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_release_session().
1743  * @error: Return location for error or %NULL.
1744  *
1745  * Finishes an operation started with org_bluez_adapter_call_release_session().
1746  *
1747  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1748  */
1749 gboolean
1750 org_bluez_adapter_call_release_session_finish (
1751     OrgBluezAdapter *proxy,
1752     GAsyncResult *res,
1753     GError **error)
1754 {
1755   GVariant *_ret;
1756   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1757   if (_ret == NULL)
1758     goto _out;
1759   g_variant_get (_ret,
1760                  "()");
1761   g_variant_unref (_ret);
1762 _out:
1763   return _ret != NULL;
1764 }
1765
1766 /**
1767  * org_bluez_adapter_call_release_session_sync:
1768  * @proxy: A #OrgBluezAdapterProxy.
1769  * @cancellable: (allow-none): A #GCancellable or %NULL.
1770  * @error: Return location for error or %NULL.
1771  *
1772  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.ReleaseSession">ReleaseSession()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1773  *
1774  * See org_bluez_adapter_call_release_session() for the asynchronous version of this method.
1775  *
1776  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1777  */
1778 gboolean
1779 org_bluez_adapter_call_release_session_sync (
1780     OrgBluezAdapter *proxy,
1781     GCancellable *cancellable,
1782     GError **error)
1783 {
1784   GVariant *_ret;
1785   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1786     "ReleaseSession",
1787     g_variant_new ("()"),
1788     G_DBUS_CALL_FLAGS_NONE,
1789     -1,
1790     cancellable,
1791     error);
1792   if (_ret == NULL)
1793     goto _out;
1794   g_variant_get (_ret,
1795                  "()");
1796   g_variant_unref (_ret);
1797 _out:
1798   return _ret != NULL;
1799 }
1800
1801 /**
1802  * org_bluez_adapter_call_start_discovery:
1803  * @proxy: A #OrgBluezAdapterProxy.
1804  * @cancellable: (allow-none): A #GCancellable or %NULL.
1805  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1806  * @user_data: User data to pass to @callback.
1807  *
1808  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.StartDiscovery">StartDiscovery()</link> D-Bus method on @proxy.
1809  * 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.
1810  * You can then call org_bluez_adapter_call_start_discovery_finish() to get the result of the operation.
1811  *
1812  * See org_bluez_adapter_call_start_discovery_sync() for the synchronous, blocking version of this method.
1813  */
1814 void
1815 org_bluez_adapter_call_start_discovery (
1816     OrgBluezAdapter *proxy,
1817     GCancellable *cancellable,
1818     GAsyncReadyCallback callback,
1819     gpointer user_data)
1820 {
1821   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1822     "StartDiscovery",
1823     g_variant_new ("()"),
1824     G_DBUS_CALL_FLAGS_NONE,
1825     -1,
1826     cancellable,
1827     callback,
1828     user_data);
1829 }
1830
1831 /**
1832  * org_bluez_adapter_call_start_discovery_finish:
1833  * @proxy: A #OrgBluezAdapterProxy.
1834  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_start_discovery().
1835  * @error: Return location for error or %NULL.
1836  *
1837  * Finishes an operation started with org_bluez_adapter_call_start_discovery().
1838  *
1839  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1840  */
1841 gboolean
1842 org_bluez_adapter_call_start_discovery_finish (
1843     OrgBluezAdapter *proxy,
1844     GAsyncResult *res,
1845     GError **error)
1846 {
1847   GVariant *_ret;
1848   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1849   if (_ret == NULL)
1850     goto _out;
1851   g_variant_get (_ret,
1852                  "()");
1853   g_variant_unref (_ret);
1854 _out:
1855   return _ret != NULL;
1856 }
1857
1858 /**
1859  * org_bluez_adapter_call_start_discovery_sync:
1860  * @proxy: A #OrgBluezAdapterProxy.
1861  * @cancellable: (allow-none): A #GCancellable or %NULL.
1862  * @error: Return location for error or %NULL.
1863  *
1864  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.StartDiscovery">StartDiscovery()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1865  *
1866  * See org_bluez_adapter_call_start_discovery() for the asynchronous version of this method.
1867  *
1868  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1869  */
1870 gboolean
1871 org_bluez_adapter_call_start_discovery_sync (
1872     OrgBluezAdapter *proxy,
1873     GCancellable *cancellable,
1874     GError **error)
1875 {
1876   GVariant *_ret;
1877   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1878     "StartDiscovery",
1879     g_variant_new ("()"),
1880     G_DBUS_CALL_FLAGS_NONE,
1881     -1,
1882     cancellable,
1883     error);
1884   if (_ret == NULL)
1885     goto _out;
1886   g_variant_get (_ret,
1887                  "()");
1888   g_variant_unref (_ret);
1889 _out:
1890   return _ret != NULL;
1891 }
1892
1893 /**
1894  * org_bluez_adapter_call_stop_discovery:
1895  * @proxy: A #OrgBluezAdapterProxy.
1896  * @cancellable: (allow-none): A #GCancellable or %NULL.
1897  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1898  * @user_data: User data to pass to @callback.
1899  *
1900  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.StopDiscovery">StopDiscovery()</link> D-Bus method on @proxy.
1901  * 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.
1902  * You can then call org_bluez_adapter_call_stop_discovery_finish() to get the result of the operation.
1903  *
1904  * See org_bluez_adapter_call_stop_discovery_sync() for the synchronous, blocking version of this method.
1905  */
1906 void
1907 org_bluez_adapter_call_stop_discovery (
1908     OrgBluezAdapter *proxy,
1909     GCancellable *cancellable,
1910     GAsyncReadyCallback callback,
1911     gpointer user_data)
1912 {
1913   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1914     "StopDiscovery",
1915     g_variant_new ("()"),
1916     G_DBUS_CALL_FLAGS_NONE,
1917     -1,
1918     cancellable,
1919     callback,
1920     user_data);
1921 }
1922
1923 /**
1924  * org_bluez_adapter_call_stop_discovery_finish:
1925  * @proxy: A #OrgBluezAdapterProxy.
1926  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_stop_discovery().
1927  * @error: Return location for error or %NULL.
1928  *
1929  * Finishes an operation started with org_bluez_adapter_call_stop_discovery().
1930  *
1931  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1932  */
1933 gboolean
1934 org_bluez_adapter_call_stop_discovery_finish (
1935     OrgBluezAdapter *proxy,
1936     GAsyncResult *res,
1937     GError **error)
1938 {
1939   GVariant *_ret;
1940   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1941   if (_ret == NULL)
1942     goto _out;
1943   g_variant_get (_ret,
1944                  "()");
1945   g_variant_unref (_ret);
1946 _out:
1947   return _ret != NULL;
1948 }
1949
1950 /**
1951  * org_bluez_adapter_call_stop_discovery_sync:
1952  * @proxy: A #OrgBluezAdapterProxy.
1953  * @cancellable: (allow-none): A #GCancellable or %NULL.
1954  * @error: Return location for error or %NULL.
1955  *
1956  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.StopDiscovery">StopDiscovery()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1957  *
1958  * See org_bluez_adapter_call_stop_discovery() for the asynchronous version of this method.
1959  *
1960  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1961  */
1962 gboolean
1963 org_bluez_adapter_call_stop_discovery_sync (
1964     OrgBluezAdapter *proxy,
1965     GCancellable *cancellable,
1966     GError **error)
1967 {
1968   GVariant *_ret;
1969   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1970     "StopDiscovery",
1971     g_variant_new ("()"),
1972     G_DBUS_CALL_FLAGS_NONE,
1973     -1,
1974     cancellable,
1975     error);
1976   if (_ret == NULL)
1977     goto _out;
1978   g_variant_get (_ret,
1979                  "()");
1980   g_variant_unref (_ret);
1981 _out:
1982   return _ret != NULL;
1983 }
1984
1985 /**
1986  * org_bluez_adapter_call_list_devices:
1987  * @proxy: A #OrgBluezAdapterProxy.
1988  * @cancellable: (allow-none): A #GCancellable or %NULL.
1989  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1990  * @user_data: User data to pass to @callback.
1991  *
1992  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.ListDevices">ListDevices()</link> D-Bus method on @proxy.
1993  * 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.
1994  * You can then call org_bluez_adapter_call_list_devices_finish() to get the result of the operation.
1995  *
1996  * See org_bluez_adapter_call_list_devices_sync() for the synchronous, blocking version of this method.
1997  */
1998 void
1999 org_bluez_adapter_call_list_devices (
2000     OrgBluezAdapter *proxy,
2001     GCancellable *cancellable,
2002     GAsyncReadyCallback callback,
2003     gpointer user_data)
2004 {
2005   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2006     "ListDevices",
2007     g_variant_new ("()"),
2008     G_DBUS_CALL_FLAGS_NONE,
2009     -1,
2010     cancellable,
2011     callback,
2012     user_data);
2013 }
2014
2015 /**
2016  * org_bluez_adapter_call_list_devices_finish:
2017  * @proxy: A #OrgBluezAdapterProxy.
2018  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
2019  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_list_devices().
2020  * @error: Return location for error or %NULL.
2021  *
2022  * Finishes an operation started with org_bluez_adapter_call_list_devices().
2023  *
2024  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2025  */
2026 gboolean
2027 org_bluez_adapter_call_list_devices_finish (
2028     OrgBluezAdapter *proxy,
2029     gchar ***out_unnamed_arg0,
2030     GAsyncResult *res,
2031     GError **error)
2032 {
2033   GVariant *_ret;
2034   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2035   if (_ret == NULL)
2036     goto _out;
2037   g_variant_get (_ret,
2038                  "(^ao)",
2039                  out_unnamed_arg0);
2040   g_variant_unref (_ret);
2041 _out:
2042   return _ret != NULL;
2043 }
2044
2045 /**
2046  * org_bluez_adapter_call_list_devices_sync:
2047  * @proxy: A #OrgBluezAdapterProxy.
2048  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
2049  * @cancellable: (allow-none): A #GCancellable or %NULL.
2050  * @error: Return location for error or %NULL.
2051  *
2052  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.ListDevices">ListDevices()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2053  *
2054  * See org_bluez_adapter_call_list_devices() for the asynchronous version of this method.
2055  *
2056  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2057  */
2058 gboolean
2059 org_bluez_adapter_call_list_devices_sync (
2060     OrgBluezAdapter *proxy,
2061     gchar ***out_unnamed_arg0,
2062     GCancellable *cancellable,
2063     GError **error)
2064 {
2065   GVariant *_ret;
2066   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2067     "ListDevices",
2068     g_variant_new ("()"),
2069     G_DBUS_CALL_FLAGS_NONE,
2070     -1,
2071     cancellable,
2072     error);
2073   if (_ret == NULL)
2074     goto _out;
2075   g_variant_get (_ret,
2076                  "(^ao)",
2077                  out_unnamed_arg0);
2078   g_variant_unref (_ret);
2079 _out:
2080   return _ret != NULL;
2081 }
2082
2083 /**
2084  * org_bluez_adapter_call_create_device:
2085  * @proxy: A #OrgBluezAdapterProxy.
2086  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2087  * @cancellable: (allow-none): A #GCancellable or %NULL.
2088  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2089  * @user_data: User data to pass to @callback.
2090  *
2091  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CreateDevice">CreateDevice()</link> D-Bus method on @proxy.
2092  * 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.
2093  * You can then call org_bluez_adapter_call_create_device_finish() to get the result of the operation.
2094  *
2095  * See org_bluez_adapter_call_create_device_sync() for the synchronous, blocking version of this method.
2096  */
2097 void
2098 org_bluez_adapter_call_create_device (
2099     OrgBluezAdapter *proxy,
2100     const gchar *arg_unnamed_arg0,
2101     GCancellable *cancellable,
2102     GAsyncReadyCallback callback,
2103     gpointer user_data)
2104 {
2105   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2106     "CreateDevice",
2107     g_variant_new ("(s)",
2108                    arg_unnamed_arg0),
2109     G_DBUS_CALL_FLAGS_NONE,
2110     -1,
2111     cancellable,
2112     callback,
2113     user_data);
2114 }
2115
2116 /**
2117  * org_bluez_adapter_call_create_device_finish:
2118  * @proxy: A #OrgBluezAdapterProxy.
2119  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
2120  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_create_device().
2121  * @error: Return location for error or %NULL.
2122  *
2123  * Finishes an operation started with org_bluez_adapter_call_create_device().
2124  *
2125  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2126  */
2127 gboolean
2128 org_bluez_adapter_call_create_device_finish (
2129     OrgBluezAdapter *proxy,
2130     gchar **out_unnamed_arg1,
2131     GAsyncResult *res,
2132     GError **error)
2133 {
2134   GVariant *_ret;
2135   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2136   if (_ret == NULL)
2137     goto _out;
2138   g_variant_get (_ret,
2139                  "(o)",
2140                  out_unnamed_arg1);
2141   g_variant_unref (_ret);
2142 _out:
2143   return _ret != NULL;
2144 }
2145
2146 /**
2147  * org_bluez_adapter_call_create_device_sync:
2148  * @proxy: A #OrgBluezAdapterProxy.
2149  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2150  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
2151  * @cancellable: (allow-none): A #GCancellable or %NULL.
2152  * @error: Return location for error or %NULL.
2153  *
2154  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CreateDevice">CreateDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2155  *
2156  * See org_bluez_adapter_call_create_device() for the asynchronous version of this method.
2157  *
2158  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2159  */
2160 gboolean
2161 org_bluez_adapter_call_create_device_sync (
2162     OrgBluezAdapter *proxy,
2163     const gchar *arg_unnamed_arg0,
2164     gchar **out_unnamed_arg1,
2165     GCancellable *cancellable,
2166     GError **error)
2167 {
2168   GVariant *_ret;
2169   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2170     "CreateDevice",
2171     g_variant_new ("(s)",
2172                    arg_unnamed_arg0),
2173     G_DBUS_CALL_FLAGS_NONE,
2174     -1,
2175     cancellable,
2176     error);
2177   if (_ret == NULL)
2178     goto _out;
2179   g_variant_get (_ret,
2180                  "(o)",
2181                  out_unnamed_arg1);
2182   g_variant_unref (_ret);
2183 _out:
2184   return _ret != NULL;
2185 }
2186
2187 /**
2188  * org_bluez_adapter_call_create_paired_device:
2189  * @proxy: A #OrgBluezAdapterProxy.
2190  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2191  * @arg_unnamed_arg1: Argument to pass with the method invocation.
2192  * @arg_unnamed_arg2: Argument to pass with the method invocation.
2193  * @cancellable: (allow-none): A #GCancellable or %NULL.
2194  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2195  * @user_data: User data to pass to @callback.
2196  *
2197  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CreatePairedDevice">CreatePairedDevice()</link> D-Bus method on @proxy.
2198  * 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.
2199  * You can then call org_bluez_adapter_call_create_paired_device_finish() to get the result of the operation.
2200  *
2201  * See org_bluez_adapter_call_create_paired_device_sync() for the synchronous, blocking version of this method.
2202  */
2203 void
2204 org_bluez_adapter_call_create_paired_device (
2205     OrgBluezAdapter *proxy,
2206     const gchar *arg_unnamed_arg0,
2207     const gchar *arg_unnamed_arg1,
2208     const gchar *arg_unnamed_arg2,
2209     GCancellable *cancellable,
2210     GAsyncReadyCallback callback,
2211     gpointer user_data)
2212 {
2213   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2214     "CreatePairedDevice",
2215     g_variant_new ("(sos)",
2216                    arg_unnamed_arg0,
2217                    arg_unnamed_arg1,
2218                    arg_unnamed_arg2),
2219     G_DBUS_CALL_FLAGS_NONE,
2220     -1,
2221     cancellable,
2222     callback,
2223     user_data);
2224 }
2225
2226 /**
2227  * org_bluez_adapter_call_create_paired_device_finish:
2228  * @proxy: A #OrgBluezAdapterProxy.
2229  * @out_unnamed_arg3: (out): Return location for return parameter or %NULL to ignore.
2230  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_create_paired_device().
2231  * @error: Return location for error or %NULL.
2232  *
2233  * Finishes an operation started with org_bluez_adapter_call_create_paired_device().
2234  *
2235  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2236  */
2237 gboolean
2238 org_bluez_adapter_call_create_paired_device_finish (
2239     OrgBluezAdapter *proxy,
2240     gchar **out_unnamed_arg3,
2241     GAsyncResult *res,
2242     GError **error)
2243 {
2244   GVariant *_ret;
2245   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2246   if (_ret == NULL)
2247     goto _out;
2248   g_variant_get (_ret,
2249                  "(o)",
2250                  out_unnamed_arg3);
2251   g_variant_unref (_ret);
2252 _out:
2253   return _ret != NULL;
2254 }
2255
2256 /**
2257  * org_bluez_adapter_call_create_paired_device_sync:
2258  * @proxy: A #OrgBluezAdapterProxy.
2259  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2260  * @arg_unnamed_arg1: Argument to pass with the method invocation.
2261  * @arg_unnamed_arg2: Argument to pass with the method invocation.
2262  * @out_unnamed_arg3: (out): Return location for return parameter or %NULL to ignore.
2263  * @cancellable: (allow-none): A #GCancellable or %NULL.
2264  * @error: Return location for error or %NULL.
2265  *
2266  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CreatePairedDevice">CreatePairedDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2267  *
2268  * See org_bluez_adapter_call_create_paired_device() for the asynchronous version of this method.
2269  *
2270  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2271  */
2272 gboolean
2273 org_bluez_adapter_call_create_paired_device_sync (
2274     OrgBluezAdapter *proxy,
2275     const gchar *arg_unnamed_arg0,
2276     const gchar *arg_unnamed_arg1,
2277     const gchar *arg_unnamed_arg2,
2278     gchar **out_unnamed_arg3,
2279     GCancellable *cancellable,
2280     GError **error)
2281 {
2282   GVariant *_ret;
2283   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2284     "CreatePairedDevice",
2285     g_variant_new ("(sos)",
2286                    arg_unnamed_arg0,
2287                    arg_unnamed_arg1,
2288                    arg_unnamed_arg2),
2289     G_DBUS_CALL_FLAGS_NONE,
2290     -1,
2291     cancellable,
2292     error);
2293   if (_ret == NULL)
2294     goto _out;
2295   g_variant_get (_ret,
2296                  "(o)",
2297                  out_unnamed_arg3);
2298   g_variant_unref (_ret);
2299 _out:
2300   return _ret != NULL;
2301 }
2302
2303 /**
2304  * org_bluez_adapter_call_cancel_device_creation:
2305  * @proxy: A #OrgBluezAdapterProxy.
2306  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2307  * @cancellable: (allow-none): A #GCancellable or %NULL.
2308  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2309  * @user_data: User data to pass to @callback.
2310  *
2311  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CancelDeviceCreation">CancelDeviceCreation()</link> D-Bus method on @proxy.
2312  * 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.
2313  * You can then call org_bluez_adapter_call_cancel_device_creation_finish() to get the result of the operation.
2314  *
2315  * See org_bluez_adapter_call_cancel_device_creation_sync() for the synchronous, blocking version of this method.
2316  */
2317 void
2318 org_bluez_adapter_call_cancel_device_creation (
2319     OrgBluezAdapter *proxy,
2320     const gchar *arg_unnamed_arg0,
2321     GCancellable *cancellable,
2322     GAsyncReadyCallback callback,
2323     gpointer user_data)
2324 {
2325   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2326     "CancelDeviceCreation",
2327     g_variant_new ("(s)",
2328                    arg_unnamed_arg0),
2329     G_DBUS_CALL_FLAGS_NONE,
2330     -1,
2331     cancellable,
2332     callback,
2333     user_data);
2334 }
2335
2336 /**
2337  * org_bluez_adapter_call_cancel_device_creation_finish:
2338  * @proxy: A #OrgBluezAdapterProxy.
2339  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_cancel_device_creation().
2340  * @error: Return location for error or %NULL.
2341  *
2342  * Finishes an operation started with org_bluez_adapter_call_cancel_device_creation().
2343  *
2344  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2345  */
2346 gboolean
2347 org_bluez_adapter_call_cancel_device_creation_finish (
2348     OrgBluezAdapter *proxy,
2349     GAsyncResult *res,
2350     GError **error)
2351 {
2352   GVariant *_ret;
2353   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2354   if (_ret == NULL)
2355     goto _out;
2356   g_variant_get (_ret,
2357                  "()");
2358   g_variant_unref (_ret);
2359 _out:
2360   return _ret != NULL;
2361 }
2362
2363 /**
2364  * org_bluez_adapter_call_cancel_device_creation_sync:
2365  * @proxy: A #OrgBluezAdapterProxy.
2366  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2367  * @cancellable: (allow-none): A #GCancellable or %NULL.
2368  * @error: Return location for error or %NULL.
2369  *
2370  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.CancelDeviceCreation">CancelDeviceCreation()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2371  *
2372  * See org_bluez_adapter_call_cancel_device_creation() for the asynchronous version of this method.
2373  *
2374  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2375  */
2376 gboolean
2377 org_bluez_adapter_call_cancel_device_creation_sync (
2378     OrgBluezAdapter *proxy,
2379     const gchar *arg_unnamed_arg0,
2380     GCancellable *cancellable,
2381     GError **error)
2382 {
2383   GVariant *_ret;
2384   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2385     "CancelDeviceCreation",
2386     g_variant_new ("(s)",
2387                    arg_unnamed_arg0),
2388     G_DBUS_CALL_FLAGS_NONE,
2389     -1,
2390     cancellable,
2391     error);
2392   if (_ret == NULL)
2393     goto _out;
2394   g_variant_get (_ret,
2395                  "()");
2396   g_variant_unref (_ret);
2397 _out:
2398   return _ret != NULL;
2399 }
2400
2401 /**
2402  * org_bluez_adapter_call_remove_device:
2403  * @proxy: A #OrgBluezAdapterProxy.
2404  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2405  * @cancellable: (allow-none): A #GCancellable or %NULL.
2406  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2407  * @user_data: User data to pass to @callback.
2408  *
2409  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy.
2410  * 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.
2411  * You can then call org_bluez_adapter_call_remove_device_finish() to get the result of the operation.
2412  *
2413  * See org_bluez_adapter_call_remove_device_sync() for the synchronous, blocking version of this method.
2414  */
2415 void
2416 org_bluez_adapter_call_remove_device (
2417     OrgBluezAdapter *proxy,
2418     const gchar *arg_unnamed_arg0,
2419     GCancellable *cancellable,
2420     GAsyncReadyCallback callback,
2421     gpointer user_data)
2422 {
2423   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2424     "RemoveDevice",
2425     g_variant_new ("(o)",
2426                    arg_unnamed_arg0),
2427     G_DBUS_CALL_FLAGS_NONE,
2428     -1,
2429     cancellable,
2430     callback,
2431     user_data);
2432 }
2433
2434 /**
2435  * org_bluez_adapter_call_remove_device_finish:
2436  * @proxy: A #OrgBluezAdapterProxy.
2437  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_remove_device().
2438  * @error: Return location for error or %NULL.
2439  *
2440  * Finishes an operation started with org_bluez_adapter_call_remove_device().
2441  *
2442  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2443  */
2444 gboolean
2445 org_bluez_adapter_call_remove_device_finish (
2446     OrgBluezAdapter *proxy,
2447     GAsyncResult *res,
2448     GError **error)
2449 {
2450   GVariant *_ret;
2451   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2452   if (_ret == NULL)
2453     goto _out;
2454   g_variant_get (_ret,
2455                  "()");
2456   g_variant_unref (_ret);
2457 _out:
2458   return _ret != NULL;
2459 }
2460
2461 /**
2462  * org_bluez_adapter_call_remove_device_sync:
2463  * @proxy: A #OrgBluezAdapterProxy.
2464  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2465  * @cancellable: (allow-none): A #GCancellable or %NULL.
2466  * @error: Return location for error or %NULL.
2467  *
2468  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2469  *
2470  * See org_bluez_adapter_call_remove_device() for the asynchronous version of this method.
2471  *
2472  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2473  */
2474 gboolean
2475 org_bluez_adapter_call_remove_device_sync (
2476     OrgBluezAdapter *proxy,
2477     const gchar *arg_unnamed_arg0,
2478     GCancellable *cancellable,
2479     GError **error)
2480 {
2481   GVariant *_ret;
2482   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2483     "RemoveDevice",
2484     g_variant_new ("(o)",
2485                    arg_unnamed_arg0),
2486     G_DBUS_CALL_FLAGS_NONE,
2487     -1,
2488     cancellable,
2489     error);
2490   if (_ret == NULL)
2491     goto _out;
2492   g_variant_get (_ret,
2493                  "()");
2494   g_variant_unref (_ret);
2495 _out:
2496   return _ret != NULL;
2497 }
2498
2499 /**
2500  * org_bluez_adapter_call_find_device:
2501  * @proxy: A #OrgBluezAdapterProxy.
2502  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2503  * @cancellable: (allow-none): A #GCancellable or %NULL.
2504  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2505  * @user_data: User data to pass to @callback.
2506  *
2507  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.FindDevice">FindDevice()</link> D-Bus method on @proxy.
2508  * 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.
2509  * You can then call org_bluez_adapter_call_find_device_finish() to get the result of the operation.
2510  *
2511  * See org_bluez_adapter_call_find_device_sync() for the synchronous, blocking version of this method.
2512  */
2513 void
2514 org_bluez_adapter_call_find_device (
2515     OrgBluezAdapter *proxy,
2516     const gchar *arg_unnamed_arg0,
2517     GCancellable *cancellable,
2518     GAsyncReadyCallback callback,
2519     gpointer user_data)
2520 {
2521   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2522     "FindDevice",
2523     g_variant_new ("(s)",
2524                    arg_unnamed_arg0),
2525     G_DBUS_CALL_FLAGS_NONE,
2526     -1,
2527     cancellable,
2528     callback,
2529     user_data);
2530 }
2531
2532 /**
2533  * org_bluez_adapter_call_find_device_finish:
2534  * @proxy: A #OrgBluezAdapterProxy.
2535  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
2536  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_find_device().
2537  * @error: Return location for error or %NULL.
2538  *
2539  * Finishes an operation started with org_bluez_adapter_call_find_device().
2540  *
2541  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2542  */
2543 gboolean
2544 org_bluez_adapter_call_find_device_finish (
2545     OrgBluezAdapter *proxy,
2546     gchar **out_unnamed_arg1,
2547     GAsyncResult *res,
2548     GError **error)
2549 {
2550   GVariant *_ret;
2551   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2552   if (_ret == NULL)
2553     goto _out;
2554   g_variant_get (_ret,
2555                  "(o)",
2556                  out_unnamed_arg1);
2557   g_variant_unref (_ret);
2558 _out:
2559   return _ret != NULL;
2560 }
2561
2562 /**
2563  * org_bluez_adapter_call_find_device_sync:
2564  * @proxy: A #OrgBluezAdapterProxy.
2565  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2566  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
2567  * @cancellable: (allow-none): A #GCancellable or %NULL.
2568  * @error: Return location for error or %NULL.
2569  *
2570  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.FindDevice">FindDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2571  *
2572  * See org_bluez_adapter_call_find_device() for the asynchronous version of this method.
2573  *
2574  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2575  */
2576 gboolean
2577 org_bluez_adapter_call_find_device_sync (
2578     OrgBluezAdapter *proxy,
2579     const gchar *arg_unnamed_arg0,
2580     gchar **out_unnamed_arg1,
2581     GCancellable *cancellable,
2582     GError **error)
2583 {
2584   GVariant *_ret;
2585   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2586     "FindDevice",
2587     g_variant_new ("(s)",
2588                    arg_unnamed_arg0),
2589     G_DBUS_CALL_FLAGS_NONE,
2590     -1,
2591     cancellable,
2592     error);
2593   if (_ret == NULL)
2594     goto _out;
2595   g_variant_get (_ret,
2596                  "(o)",
2597                  out_unnamed_arg1);
2598   g_variant_unref (_ret);
2599 _out:
2600   return _ret != NULL;
2601 }
2602
2603 /**
2604  * org_bluez_adapter_call_register_agent:
2605  * @proxy: A #OrgBluezAdapterProxy.
2606  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2607  * @arg_unnamed_arg1: Argument to pass with the method invocation.
2608  * @cancellable: (allow-none): A #GCancellable or %NULL.
2609  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2610  * @user_data: User data to pass to @callback.
2611  *
2612  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RegisterAgent">RegisterAgent()</link> D-Bus method on @proxy.
2613  * 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.
2614  * You can then call org_bluez_adapter_call_register_agent_finish() to get the result of the operation.
2615  *
2616  * See org_bluez_adapter_call_register_agent_sync() for the synchronous, blocking version of this method.
2617  */
2618 void
2619 org_bluez_adapter_call_register_agent (
2620     OrgBluezAdapter *proxy,
2621     const gchar *arg_unnamed_arg0,
2622     const gchar *arg_unnamed_arg1,
2623     GCancellable *cancellable,
2624     GAsyncReadyCallback callback,
2625     gpointer user_data)
2626 {
2627   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2628     "RegisterAgent",
2629     g_variant_new ("(os)",
2630                    arg_unnamed_arg0,
2631                    arg_unnamed_arg1),
2632     G_DBUS_CALL_FLAGS_NONE,
2633     -1,
2634     cancellable,
2635     callback,
2636     user_data);
2637 }
2638
2639 /**
2640  * org_bluez_adapter_call_register_agent_finish:
2641  * @proxy: A #OrgBluezAdapterProxy.
2642  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_register_agent().
2643  * @error: Return location for error or %NULL.
2644  *
2645  * Finishes an operation started with org_bluez_adapter_call_register_agent().
2646  *
2647  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2648  */
2649 gboolean
2650 org_bluez_adapter_call_register_agent_finish (
2651     OrgBluezAdapter *proxy,
2652     GAsyncResult *res,
2653     GError **error)
2654 {
2655   GVariant *_ret;
2656   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2657   if (_ret == NULL)
2658     goto _out;
2659   g_variant_get (_ret,
2660                  "()");
2661   g_variant_unref (_ret);
2662 _out:
2663   return _ret != NULL;
2664 }
2665
2666 /**
2667  * org_bluez_adapter_call_register_agent_sync:
2668  * @proxy: A #OrgBluezAdapterProxy.
2669  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2670  * @arg_unnamed_arg1: Argument to pass with the method invocation.
2671  * @cancellable: (allow-none): A #GCancellable or %NULL.
2672  * @error: Return location for error or %NULL.
2673  *
2674  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.RegisterAgent">RegisterAgent()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2675  *
2676  * See org_bluez_adapter_call_register_agent() for the asynchronous version of this method.
2677  *
2678  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2679  */
2680 gboolean
2681 org_bluez_adapter_call_register_agent_sync (
2682     OrgBluezAdapter *proxy,
2683     const gchar *arg_unnamed_arg0,
2684     const gchar *arg_unnamed_arg1,
2685     GCancellable *cancellable,
2686     GError **error)
2687 {
2688   GVariant *_ret;
2689   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2690     "RegisterAgent",
2691     g_variant_new ("(os)",
2692                    arg_unnamed_arg0,
2693                    arg_unnamed_arg1),
2694     G_DBUS_CALL_FLAGS_NONE,
2695     -1,
2696     cancellable,
2697     error);
2698   if (_ret == NULL)
2699     goto _out;
2700   g_variant_get (_ret,
2701                  "()");
2702   g_variant_unref (_ret);
2703 _out:
2704   return _ret != NULL;
2705 }
2706
2707 /**
2708  * org_bluez_adapter_call_unregister_agent:
2709  * @proxy: A #OrgBluezAdapterProxy.
2710  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2711  * @cancellable: (allow-none): A #GCancellable or %NULL.
2712  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2713  * @user_data: User data to pass to @callback.
2714  *
2715  * Asynchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.UnregisterAgent">UnregisterAgent()</link> D-Bus method on @proxy.
2716  * 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.
2717  * You can then call org_bluez_adapter_call_unregister_agent_finish() to get the result of the operation.
2718  *
2719  * See org_bluez_adapter_call_unregister_agent_sync() for the synchronous, blocking version of this method.
2720  */
2721 void
2722 org_bluez_adapter_call_unregister_agent (
2723     OrgBluezAdapter *proxy,
2724     const gchar *arg_unnamed_arg0,
2725     GCancellable *cancellable,
2726     GAsyncReadyCallback callback,
2727     gpointer user_data)
2728 {
2729   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2730     "UnregisterAgent",
2731     g_variant_new ("(o)",
2732                    arg_unnamed_arg0),
2733     G_DBUS_CALL_FLAGS_NONE,
2734     -1,
2735     cancellable,
2736     callback,
2737     user_data);
2738 }
2739
2740 /**
2741  * org_bluez_adapter_call_unregister_agent_finish:
2742  * @proxy: A #OrgBluezAdapterProxy.
2743  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_call_unregister_agent().
2744  * @error: Return location for error or %NULL.
2745  *
2746  * Finishes an operation started with org_bluez_adapter_call_unregister_agent().
2747  *
2748  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2749  */
2750 gboolean
2751 org_bluez_adapter_call_unregister_agent_finish (
2752     OrgBluezAdapter *proxy,
2753     GAsyncResult *res,
2754     GError **error)
2755 {
2756   GVariant *_ret;
2757   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2758   if (_ret == NULL)
2759     goto _out;
2760   g_variant_get (_ret,
2761                  "()");
2762   g_variant_unref (_ret);
2763 _out:
2764   return _ret != NULL;
2765 }
2766
2767 /**
2768  * org_bluez_adapter_call_unregister_agent_sync:
2769  * @proxy: A #OrgBluezAdapterProxy.
2770  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2771  * @cancellable: (allow-none): A #GCancellable or %NULL.
2772  * @error: Return location for error or %NULL.
2773  *
2774  * Synchronously invokes the <link linkend="gdbus-method-org-bluez-Adapter.UnregisterAgent">UnregisterAgent()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2775  *
2776  * See org_bluez_adapter_call_unregister_agent() for the asynchronous version of this method.
2777  *
2778  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2779  */
2780 gboolean
2781 org_bluez_adapter_call_unregister_agent_sync (
2782     OrgBluezAdapter *proxy,
2783     const gchar *arg_unnamed_arg0,
2784     GCancellable *cancellable,
2785     GError **error)
2786 {
2787   GVariant *_ret;
2788   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2789     "UnregisterAgent",
2790     g_variant_new ("(o)",
2791                    arg_unnamed_arg0),
2792     G_DBUS_CALL_FLAGS_NONE,
2793     -1,
2794     cancellable,
2795     error);
2796   if (_ret == NULL)
2797     goto _out;
2798   g_variant_get (_ret,
2799                  "()");
2800   g_variant_unref (_ret);
2801 _out:
2802   return _ret != NULL;
2803 }
2804
2805 /**
2806  * org_bluez_adapter_complete_get_properties:
2807  * @object: A #OrgBluezAdapter.
2808  * @invocation: (transfer full): A #GDBusMethodInvocation.
2809  * @unnamed_arg0: Parameter to return.
2810  *
2811  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.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.
2812  *
2813  * This method will free @invocation, you cannot use it afterwards.
2814  */
2815 void
2816 org_bluez_adapter_complete_get_properties (
2817     OrgBluezAdapter *object,
2818     GDBusMethodInvocation *invocation,
2819     GVariant *unnamed_arg0)
2820 {
2821   g_dbus_method_invocation_return_value (invocation,
2822     g_variant_new ("(@a{sv})",
2823                    unnamed_arg0));
2824 }
2825
2826 /**
2827  * org_bluez_adapter_complete_set_property:
2828  * @object: A #OrgBluezAdapter.
2829  * @invocation: (transfer full): A #GDBusMethodInvocation.
2830  *
2831  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.SetProperty">SetProperty()</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.
2832  *
2833  * This method will free @invocation, you cannot use it afterwards.
2834  */
2835 void
2836 org_bluez_adapter_complete_set_property (
2837     OrgBluezAdapter *object,
2838     GDBusMethodInvocation *invocation)
2839 {
2840   g_dbus_method_invocation_return_value (invocation,
2841     g_variant_new ("()"));
2842 }
2843
2844 /**
2845  * org_bluez_adapter_complete_request_session:
2846  * @object: A #OrgBluezAdapter.
2847  * @invocation: (transfer full): A #GDBusMethodInvocation.
2848  *
2849  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.RequestSession">RequestSession()</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.
2850  *
2851  * This method will free @invocation, you cannot use it afterwards.
2852  */
2853 void
2854 org_bluez_adapter_complete_request_session (
2855     OrgBluezAdapter *object,
2856     GDBusMethodInvocation *invocation)
2857 {
2858   g_dbus_method_invocation_return_value (invocation,
2859     g_variant_new ("()"));
2860 }
2861
2862 /**
2863  * org_bluez_adapter_complete_release_session:
2864  * @object: A #OrgBluezAdapter.
2865  * @invocation: (transfer full): A #GDBusMethodInvocation.
2866  *
2867  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.ReleaseSession">ReleaseSession()</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.
2868  *
2869  * This method will free @invocation, you cannot use it afterwards.
2870  */
2871 void
2872 org_bluez_adapter_complete_release_session (
2873     OrgBluezAdapter *object,
2874     GDBusMethodInvocation *invocation)
2875 {
2876   g_dbus_method_invocation_return_value (invocation,
2877     g_variant_new ("()"));
2878 }
2879
2880 /**
2881  * org_bluez_adapter_complete_start_discovery:
2882  * @object: A #OrgBluezAdapter.
2883  * @invocation: (transfer full): A #GDBusMethodInvocation.
2884  *
2885  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.StartDiscovery">StartDiscovery()</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.
2886  *
2887  * This method will free @invocation, you cannot use it afterwards.
2888  */
2889 void
2890 org_bluez_adapter_complete_start_discovery (
2891     OrgBluezAdapter *object,
2892     GDBusMethodInvocation *invocation)
2893 {
2894   g_dbus_method_invocation_return_value (invocation,
2895     g_variant_new ("()"));
2896 }
2897
2898 /**
2899  * org_bluez_adapter_complete_stop_discovery:
2900  * @object: A #OrgBluezAdapter.
2901  * @invocation: (transfer full): A #GDBusMethodInvocation.
2902  *
2903  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.StopDiscovery">StopDiscovery()</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.
2904  *
2905  * This method will free @invocation, you cannot use it afterwards.
2906  */
2907 void
2908 org_bluez_adapter_complete_stop_discovery (
2909     OrgBluezAdapter *object,
2910     GDBusMethodInvocation *invocation)
2911 {
2912   g_dbus_method_invocation_return_value (invocation,
2913     g_variant_new ("()"));
2914 }
2915
2916 /**
2917  * org_bluez_adapter_complete_list_devices:
2918  * @object: A #OrgBluezAdapter.
2919  * @invocation: (transfer full): A #GDBusMethodInvocation.
2920  * @unnamed_arg0: Parameter to return.
2921  *
2922  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.ListDevices">ListDevices()</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.
2923  *
2924  * This method will free @invocation, you cannot use it afterwards.
2925  */
2926 void
2927 org_bluez_adapter_complete_list_devices (
2928     OrgBluezAdapter *object,
2929     GDBusMethodInvocation *invocation,
2930     const gchar *const *unnamed_arg0)
2931 {
2932   g_dbus_method_invocation_return_value (invocation,
2933     g_variant_new ("(^ao)",
2934                    unnamed_arg0));
2935 }
2936
2937 /**
2938  * org_bluez_adapter_complete_create_device:
2939  * @object: A #OrgBluezAdapter.
2940  * @invocation: (transfer full): A #GDBusMethodInvocation.
2941  * @unnamed_arg1: Parameter to return.
2942  *
2943  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.CreateDevice">CreateDevice()</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.
2944  *
2945  * This method will free @invocation, you cannot use it afterwards.
2946  */
2947 void
2948 org_bluez_adapter_complete_create_device (
2949     OrgBluezAdapter *object,
2950     GDBusMethodInvocation *invocation,
2951     const gchar *unnamed_arg1)
2952 {
2953   g_dbus_method_invocation_return_value (invocation,
2954     g_variant_new ("(o)",
2955                    unnamed_arg1));
2956 }
2957
2958 /**
2959  * org_bluez_adapter_complete_create_paired_device:
2960  * @object: A #OrgBluezAdapter.
2961  * @invocation: (transfer full): A #GDBusMethodInvocation.
2962  * @unnamed_arg3: Parameter to return.
2963  *
2964  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.CreatePairedDevice">CreatePairedDevice()</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.
2965  *
2966  * This method will free @invocation, you cannot use it afterwards.
2967  */
2968 void
2969 org_bluez_adapter_complete_create_paired_device (
2970     OrgBluezAdapter *object,
2971     GDBusMethodInvocation *invocation,
2972     const gchar *unnamed_arg3)
2973 {
2974   g_dbus_method_invocation_return_value (invocation,
2975     g_variant_new ("(o)",
2976                    unnamed_arg3));
2977 }
2978
2979 /**
2980  * org_bluez_adapter_complete_cancel_device_creation:
2981  * @object: A #OrgBluezAdapter.
2982  * @invocation: (transfer full): A #GDBusMethodInvocation.
2983  *
2984  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.CancelDeviceCreation">CancelDeviceCreation()</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.
2985  *
2986  * This method will free @invocation, you cannot use it afterwards.
2987  */
2988 void
2989 org_bluez_adapter_complete_cancel_device_creation (
2990     OrgBluezAdapter *object,
2991     GDBusMethodInvocation *invocation)
2992 {
2993   g_dbus_method_invocation_return_value (invocation,
2994     g_variant_new ("()"));
2995 }
2996
2997 /**
2998  * org_bluez_adapter_complete_remove_device:
2999  * @object: A #OrgBluezAdapter.
3000  * @invocation: (transfer full): A #GDBusMethodInvocation.
3001  *
3002  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.RemoveDevice">RemoveDevice()</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.
3003  *
3004  * This method will free @invocation, you cannot use it afterwards.
3005  */
3006 void
3007 org_bluez_adapter_complete_remove_device (
3008     OrgBluezAdapter *object,
3009     GDBusMethodInvocation *invocation)
3010 {
3011   g_dbus_method_invocation_return_value (invocation,
3012     g_variant_new ("()"));
3013 }
3014
3015 /**
3016  * org_bluez_adapter_complete_find_device:
3017  * @object: A #OrgBluezAdapter.
3018  * @invocation: (transfer full): A #GDBusMethodInvocation.
3019  * @unnamed_arg1: Parameter to return.
3020  *
3021  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.FindDevice">FindDevice()</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.
3022  *
3023  * This method will free @invocation, you cannot use it afterwards.
3024  */
3025 void
3026 org_bluez_adapter_complete_find_device (
3027     OrgBluezAdapter *object,
3028     GDBusMethodInvocation *invocation,
3029     const gchar *unnamed_arg1)
3030 {
3031   g_dbus_method_invocation_return_value (invocation,
3032     g_variant_new ("(o)",
3033                    unnamed_arg1));
3034 }
3035
3036 /**
3037  * org_bluez_adapter_complete_register_agent:
3038  * @object: A #OrgBluezAdapter.
3039  * @invocation: (transfer full): A #GDBusMethodInvocation.
3040  *
3041  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.RegisterAgent">RegisterAgent()</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.
3042  *
3043  * This method will free @invocation, you cannot use it afterwards.
3044  */
3045 void
3046 org_bluez_adapter_complete_register_agent (
3047     OrgBluezAdapter *object,
3048     GDBusMethodInvocation *invocation)
3049 {
3050   g_dbus_method_invocation_return_value (invocation,
3051     g_variant_new ("()"));
3052 }
3053
3054 /**
3055  * org_bluez_adapter_complete_unregister_agent:
3056  * @object: A #OrgBluezAdapter.
3057  * @invocation: (transfer full): A #GDBusMethodInvocation.
3058  *
3059  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-bluez-Adapter.UnregisterAgent">UnregisterAgent()</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.
3060  *
3061  * This method will free @invocation, you cannot use it afterwards.
3062  */
3063 void
3064 org_bluez_adapter_complete_unregister_agent (
3065     OrgBluezAdapter *object,
3066     GDBusMethodInvocation *invocation)
3067 {
3068   g_dbus_method_invocation_return_value (invocation,
3069     g_variant_new ("()"));
3070 }
3071
3072 /* ------------------------------------------------------------------------ */
3073
3074 /**
3075  * OrgBluezAdapterProxy:
3076  *
3077  * The #OrgBluezAdapterProxy structure contains only private data and should only be accessed using the provided API.
3078  */
3079
3080 /**
3081  * OrgBluezAdapterProxyClass:
3082  * @parent_class: The parent class.
3083  *
3084  * Class structure for #OrgBluezAdapterProxy.
3085  */
3086
3087 struct _OrgBluezAdapterProxyPrivate
3088 {
3089   GData *qdata;
3090 };
3091
3092 static void org_bluez_adapter_proxy_iface_init (OrgBluezAdapterIface *iface);
3093
3094 G_DEFINE_TYPE_WITH_CODE (OrgBluezAdapterProxy, org_bluez_adapter_proxy, G_TYPE_DBUS_PROXY,
3095                          G_IMPLEMENT_INTERFACE (TYPE_ORG_BLUEZ_ADAPTER, org_bluez_adapter_proxy_iface_init));
3096
3097 static void
3098 org_bluez_adapter_proxy_finalize (GObject *object)
3099 {
3100   OrgBluezAdapterProxy *proxy = ORG_BLUEZ_ADAPTER_PROXY (object);
3101   g_datalist_clear (&proxy->priv->qdata);
3102   G_OBJECT_CLASS (org_bluez_adapter_proxy_parent_class)->finalize (object);
3103 }
3104
3105 static void
3106 org_bluez_adapter_proxy_get_property (GObject      *object,
3107   guint         prop_id,
3108   GValue       *value,
3109   GParamSpec   *pspec)
3110 {
3111 }
3112
3113 static void
3114 org_bluez_adapter_proxy_set_property (GObject      *object,
3115   guint         prop_id,
3116   const GValue *value,
3117   GParamSpec   *pspec)
3118 {
3119 }
3120
3121 static void
3122 org_bluez_adapter_proxy_g_signal (GDBusProxy *proxy,
3123   const gchar *sender_name,
3124   const gchar *signal_name,
3125   GVariant *parameters)
3126 {
3127   _ExtendedGDBusSignalInfo *info;
3128   GVariantIter iter;
3129   GVariant *child;
3130   GValue *paramv;
3131   guint num_params;
3132   guint n;
3133   guint signal_id;
3134   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info, signal_name);
3135   if (info == NULL)
3136     return;
3137   num_params = g_variant_n_children (parameters);
3138   paramv = g_new0 (GValue, num_params + 1);
3139   g_value_init (&paramv[0], TYPE_ORG_BLUEZ_ADAPTER);
3140   g_value_set_object (&paramv[0], proxy);
3141   g_variant_iter_init (&iter, parameters);
3142   n = 1;
3143   while ((child = g_variant_iter_next_value (&iter)) != NULL)
3144     {
3145       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
3146       if (arg_info->use_gvariant)
3147         {
3148           g_value_init (&paramv[n], G_TYPE_VARIANT);
3149           g_value_set_variant (&paramv[n], child);
3150           n++;
3151         }
3152       else
3153         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
3154       g_variant_unref (child);
3155     }
3156   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_BLUEZ_ADAPTER);
3157   g_signal_emitv (paramv, signal_id, 0, NULL);
3158   for (n = 0; n < num_params + 1; n++)
3159     g_value_unset (&paramv[n]);
3160   g_free (paramv);
3161 }
3162
3163 static void
3164 org_bluez_adapter_proxy_g_properties_changed (GDBusProxy *_proxy,
3165   GVariant *changed_properties,
3166   const gchar *const *invalidated_properties)
3167 {
3168   OrgBluezAdapterProxy *proxy = ORG_BLUEZ_ADAPTER_PROXY (_proxy);
3169   guint n;
3170   const gchar *key;
3171   GVariantIter *iter;
3172   _ExtendedGDBusPropertyInfo *info;
3173   g_variant_get (changed_properties, "a{sv}", &iter);
3174   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
3175     {
3176       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info, key);
3177       g_datalist_remove_data (&proxy->priv->qdata, key);
3178       if (info != NULL)
3179         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
3180     }
3181   g_variant_iter_free (iter);
3182   for (n = 0; invalidated_properties[n] != NULL; n++)
3183     {
3184       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info, invalidated_properties[n]);
3185       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
3186       if (info != NULL)
3187         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
3188     }
3189 }
3190
3191 static void
3192 org_bluez_adapter_proxy_init (OrgBluezAdapterProxy *proxy)
3193 {
3194   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_BLUEZ_ADAPTER_PROXY, OrgBluezAdapterProxyPrivate);
3195   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_bluez_adapter_interface_info ());
3196 }
3197
3198 static void
3199 org_bluez_adapter_proxy_class_init (OrgBluezAdapterProxyClass *klass)
3200 {
3201   GObjectClass *gobject_class;
3202   GDBusProxyClass *proxy_class;
3203
3204   g_type_class_add_private (klass, sizeof (OrgBluezAdapterProxyPrivate));
3205
3206   gobject_class = G_OBJECT_CLASS (klass);
3207   gobject_class->finalize     = org_bluez_adapter_proxy_finalize;
3208   gobject_class->get_property = org_bluez_adapter_proxy_get_property;
3209   gobject_class->set_property = org_bluez_adapter_proxy_set_property;
3210
3211   proxy_class = G_DBUS_PROXY_CLASS (klass);
3212   proxy_class->g_signal = org_bluez_adapter_proxy_g_signal;
3213   proxy_class->g_properties_changed = org_bluez_adapter_proxy_g_properties_changed;
3214
3215 }
3216
3217 static void
3218 org_bluez_adapter_proxy_iface_init (OrgBluezAdapterIface *iface)
3219 {
3220 }
3221
3222 /**
3223  * org_bluez_adapter_proxy_new:
3224  * @connection: A #GDBusConnection.
3225  * @flags: Flags from the #GDBusProxyFlags enumeration.
3226  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
3227  * @object_path: An object path.
3228  * @cancellable: (allow-none): A #GCancellable or %NULL.
3229  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
3230  * @user_data: User data to pass to @callback.
3231  *
3232  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link>. See g_dbus_proxy_new() for more details.
3233  *
3234  * 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.
3235  * You can then call org_bluez_adapter_proxy_new_finish() to get the result of the operation.
3236  *
3237  * See org_bluez_adapter_proxy_new_sync() for the synchronous, blocking version of this constructor.
3238  */
3239 void
3240 org_bluez_adapter_proxy_new (
3241     GDBusConnection     *connection,
3242     GDBusProxyFlags      flags,
3243     const gchar         *name,
3244     const gchar         *object_path,
3245     GCancellable        *cancellable,
3246     GAsyncReadyCallback  callback,
3247     gpointer             user_data)
3248 {
3249   g_async_initable_new_async (TYPE_ORG_BLUEZ_ADAPTER_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.Adapter", NULL);
3250 }
3251
3252 /**
3253  * org_bluez_adapter_proxy_new_finish:
3254  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_proxy_new().
3255  * @error: Return location for error or %NULL
3256  *
3257  * Finishes an operation started with org_bluez_adapter_proxy_new().
3258  *
3259  * Returns: (transfer full) (type OrgBluezAdapterProxy): The constructed proxy object or %NULL if @error is set.
3260  */
3261 OrgBluezAdapter *
3262 org_bluez_adapter_proxy_new_finish (
3263     GAsyncResult        *res,
3264     GError             **error)
3265 {
3266   GObject *ret;
3267   GObject *source_object;
3268   source_object = g_async_result_get_source_object (res);
3269   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
3270   g_object_unref (source_object);
3271   if (ret != NULL)
3272     return ORG_BLUEZ_ADAPTER (ret);
3273   else
3274     return NULL;
3275 }
3276
3277 /**
3278  * org_bluez_adapter_proxy_new_sync:
3279  * @connection: A #GDBusConnection.
3280  * @flags: Flags from the #GDBusProxyFlags enumeration.
3281  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
3282  * @object_path: An object path.
3283  * @cancellable: (allow-none): A #GCancellable or %NULL.
3284  * @error: Return location for error or %NULL
3285  *
3286  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link>. See g_dbus_proxy_new_sync() for more details.
3287  *
3288  * The calling thread is blocked until a reply is received.
3289  *
3290  * See org_bluez_adapter_proxy_new() for the asynchronous version of this constructor.
3291  *
3292  * Returns: (transfer full) (type OrgBluezAdapterProxy): The constructed proxy object or %NULL if @error is set.
3293  */
3294 OrgBluezAdapter *
3295 org_bluez_adapter_proxy_new_sync (
3296     GDBusConnection     *connection,
3297     GDBusProxyFlags      flags,
3298     const gchar         *name,
3299     const gchar         *object_path,
3300     GCancellable        *cancellable,
3301     GError             **error)
3302 {
3303   GInitable *ret;
3304   ret = g_initable_new (TYPE_ORG_BLUEZ_ADAPTER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.bluez.Adapter", NULL);
3305   if (ret != NULL)
3306     return ORG_BLUEZ_ADAPTER (ret);
3307   else
3308     return NULL;
3309 }
3310
3311
3312 /**
3313  * org_bluez_adapter_proxy_new_for_bus:
3314  * @bus_type: A #GBusType.
3315  * @flags: Flags from the #GDBusProxyFlags enumeration.
3316  * @name: A bus name (well-known or unique).
3317  * @object_path: An object path.
3318  * @cancellable: (allow-none): A #GCancellable or %NULL.
3319  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
3320  * @user_data: User data to pass to @callback.
3321  *
3322  * Like org_bluez_adapter_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
3323  *
3324  * 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.
3325  * You can then call org_bluez_adapter_proxy_new_for_bus_finish() to get the result of the operation.
3326  *
3327  * See org_bluez_adapter_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
3328  */
3329 void
3330 org_bluez_adapter_proxy_new_for_bus (
3331     GBusType             bus_type,
3332     GDBusProxyFlags      flags,
3333     const gchar         *name,
3334     const gchar         *object_path,
3335     GCancellable        *cancellable,
3336     GAsyncReadyCallback  callback,
3337     gpointer             user_data)
3338 {
3339   g_async_initable_new_async (TYPE_ORG_BLUEZ_ADAPTER_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.Adapter", NULL);
3340 }
3341
3342 /**
3343  * org_bluez_adapter_proxy_new_for_bus_finish:
3344  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_bluez_adapter_proxy_new_for_bus().
3345  * @error: Return location for error or %NULL
3346  *
3347  * Finishes an operation started with org_bluez_adapter_proxy_new_for_bus().
3348  *
3349  * Returns: (transfer full) (type OrgBluezAdapterProxy): The constructed proxy object or %NULL if @error is set.
3350  */
3351 OrgBluezAdapter *
3352 org_bluez_adapter_proxy_new_for_bus_finish (
3353     GAsyncResult        *res,
3354     GError             **error)
3355 {
3356   GObject *ret;
3357   GObject *source_object;
3358   source_object = g_async_result_get_source_object (res);
3359   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
3360   g_object_unref (source_object);
3361   if (ret != NULL)
3362     return ORG_BLUEZ_ADAPTER (ret);
3363   else
3364     return NULL;
3365 }
3366
3367 /**
3368  * org_bluez_adapter_proxy_new_for_bus_sync:
3369  * @bus_type: A #GBusType.
3370  * @flags: Flags from the #GDBusProxyFlags enumeration.
3371  * @name: A bus name (well-known or unique).
3372  * @object_path: An object path.
3373  * @cancellable: (allow-none): A #GCancellable or %NULL.
3374  * @error: Return location for error or %NULL
3375  *
3376  * Like org_bluez_adapter_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
3377  *
3378  * The calling thread is blocked until a reply is received.
3379  *
3380  * See org_bluez_adapter_proxy_new_for_bus() for the asynchronous version of this constructor.
3381  *
3382  * Returns: (transfer full) (type OrgBluezAdapterProxy): The constructed proxy object or %NULL if @error is set.
3383  */
3384 OrgBluezAdapter *
3385 org_bluez_adapter_proxy_new_for_bus_sync (
3386     GBusType             bus_type,
3387     GDBusProxyFlags      flags,
3388     const gchar         *name,
3389     const gchar         *object_path,
3390     GCancellable        *cancellable,
3391     GError             **error)
3392 {
3393   GInitable *ret;
3394   ret = g_initable_new (TYPE_ORG_BLUEZ_ADAPTER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.bluez.Adapter", NULL);
3395   if (ret != NULL)
3396     return ORG_BLUEZ_ADAPTER (ret);
3397   else
3398     return NULL;
3399 }
3400
3401
3402 /* ------------------------------------------------------------------------ */
3403
3404 /**
3405  * OrgBluezAdapterSkeleton:
3406  *
3407  * The #OrgBluezAdapterSkeleton structure contains only private data and should only be accessed using the provided API.
3408  */
3409
3410 /**
3411  * OrgBluezAdapterSkeletonClass:
3412  * @parent_class: The parent class.
3413  *
3414  * Class structure for #OrgBluezAdapterSkeleton.
3415  */
3416
3417 struct _OrgBluezAdapterSkeletonPrivate
3418 {
3419   GValue *properties;
3420   GList *changed_properties;
3421   GSource *changed_properties_idle_source;
3422   GMainContext *context;
3423   GMutex lock;
3424 };
3425
3426 static void
3427 _org_bluez_adapter_skeleton_handle_method_call (
3428   GDBusConnection *connection,
3429   const gchar *sender,
3430   const gchar *object_path,
3431   const gchar *interface_name,
3432   const gchar *method_name,
3433   GVariant *parameters,
3434   GDBusMethodInvocation *invocation,
3435   gpointer user_data)
3436 {
3437   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (user_data);
3438   _ExtendedGDBusMethodInfo *info;
3439   GVariantIter iter;
3440   GVariant *child;
3441   GValue *paramv;
3442   guint num_params;
3443   guint num_extra;
3444   guint n;
3445   guint signal_id;
3446   GValue return_value = G_VALUE_INIT;
3447   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
3448   g_assert (info != NULL);
3449   num_params = g_variant_n_children (parameters);
3450   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
3451   n = 0;
3452   g_value_init (&paramv[n], TYPE_ORG_BLUEZ_ADAPTER);
3453   g_value_set_object (&paramv[n++], skeleton);
3454   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
3455   g_value_set_object (&paramv[n++], invocation);
3456   if (info->pass_fdlist)
3457     {
3458 #ifdef G_OS_UNIX
3459       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
3460       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
3461 #else
3462       g_assert_not_reached ();
3463 #endif
3464     }
3465   g_variant_iter_init (&iter, parameters);
3466   while ((child = g_variant_iter_next_value (&iter)) != NULL)
3467     {
3468       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
3469       if (arg_info->use_gvariant)
3470         {
3471           g_value_init (&paramv[n], G_TYPE_VARIANT);
3472           g_value_set_variant (&paramv[n], child);
3473           n++;
3474         }
3475       else
3476         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
3477       g_variant_unref (child);
3478     }
3479   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_BLUEZ_ADAPTER);
3480   g_value_init (&return_value, G_TYPE_BOOLEAN);
3481   g_signal_emitv (paramv, signal_id, 0, &return_value);
3482   if (!g_value_get_boolean (&return_value))
3483     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);
3484   g_value_unset (&return_value);
3485   for (n = 0; n < num_params + num_extra; n++)
3486     g_value_unset (&paramv[n]);
3487   g_free (paramv);
3488 }
3489
3490 static GVariant *
3491 _org_bluez_adapter_skeleton_handle_get_property (
3492   GDBusConnection *connection,
3493   const gchar *sender,
3494   const gchar *object_path,
3495   const gchar *interface_name,
3496   const gchar *property_name,
3497   GError **error,
3498   gpointer user_data)
3499 {
3500   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (user_data);
3501   GValue value = G_VALUE_INIT;
3502   GParamSpec *pspec;
3503   _ExtendedGDBusPropertyInfo *info;
3504   GVariant *ret;
3505   ret = NULL;
3506   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info, property_name);
3507   g_assert (info != NULL);
3508   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
3509   if (pspec == NULL)
3510     {
3511       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
3512     }
3513   else
3514     {
3515       g_value_init (&value, pspec->value_type);
3516       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
3517       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
3518       g_value_unset (&value);
3519     }
3520   return ret;
3521 }
3522
3523 static gboolean
3524 _org_bluez_adapter_skeleton_handle_set_property (
3525   GDBusConnection *connection,
3526   const gchar *sender,
3527   const gchar *object_path,
3528   const gchar *interface_name,
3529   const gchar *property_name,
3530   GVariant *variant,
3531   GError **error,
3532   gpointer user_data)
3533 {
3534   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (user_data);
3535   GValue value = G_VALUE_INIT;
3536   GParamSpec *pspec;
3537   _ExtendedGDBusPropertyInfo *info;
3538   gboolean ret;
3539   ret = FALSE;
3540   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_bluez_adapter_interface_info, property_name);
3541   g_assert (info != NULL);
3542   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
3543   if (pspec == NULL)
3544     {
3545       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
3546     }
3547   else
3548     {
3549       if (info->use_gvariant)
3550         g_value_set_variant (&value, variant);
3551       else
3552         g_dbus_gvariant_to_gvalue (variant, &value);
3553       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
3554       g_value_unset (&value);
3555       ret = TRUE;
3556     }
3557   return ret;
3558 }
3559
3560 static const GDBusInterfaceVTable _org_bluez_adapter_skeleton_vtable =
3561 {
3562   _org_bluez_adapter_skeleton_handle_method_call,
3563   _org_bluez_adapter_skeleton_handle_get_property,
3564   _org_bluez_adapter_skeleton_handle_set_property
3565 };
3566
3567 static GDBusInterfaceInfo *
3568 org_bluez_adapter_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton)
3569 {
3570   return org_bluez_adapter_interface_info ();
3571 }
3572
3573 static GDBusInterfaceVTable *
3574 org_bluez_adapter_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton)
3575 {
3576   return (GDBusInterfaceVTable *) &_org_bluez_adapter_skeleton_vtable;
3577 }
3578
3579 static GVariant *
3580 org_bluez_adapter_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
3581 {
3582   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (_skeleton);
3583
3584   GVariantBuilder builder;
3585   guint n;
3586   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
3587   if (_org_bluez_adapter_interface_info.parent_struct.properties == NULL)
3588     goto out;
3589   for (n = 0; _org_bluez_adapter_interface_info.parent_struct.properties[n] != NULL; n++)
3590     {
3591       GDBusPropertyInfo *info = _org_bluez_adapter_interface_info.parent_struct.properties[n];
3592       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
3593         {
3594           GVariant *value;
3595           value = _org_bluez_adapter_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.Adapter", info->name, NULL, skeleton);
3596           if (value != NULL)
3597             {
3598               g_variant_take_ref (value);
3599               g_variant_builder_add (&builder, "{sv}", info->name, value);
3600               g_variant_unref (value);
3601             }
3602         }
3603     }
3604 out:
3605   return g_variant_builder_end (&builder);
3606 }
3607
3608 static void
3609 org_bluez_adapter_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
3610 {
3611 }
3612
3613 static void
3614 _org_bluez_adapter_on_signal_property_changed (
3615     OrgBluezAdapter *object,
3616     const gchar *arg_unnamed_arg0,
3617     GVariant *arg_unnamed_arg1)
3618 {
3619   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3620
3621   GList      *connections, *l;
3622   GVariant   *signal_variant;
3623   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3624
3625   signal_variant = g_variant_ref_sink (g_variant_new ("(s@v)",
3626                    arg_unnamed_arg0,
3627                    arg_unnamed_arg1));
3628   for (l = connections; l != NULL; l = l->next)
3629     {
3630       GDBusConnection *connection = l->data;
3631       g_dbus_connection_emit_signal (connection,
3632         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Adapter", "PropertyChanged",
3633         signal_variant, NULL);
3634     }
3635   g_variant_unref (signal_variant);
3636   g_list_free_full (connections, g_object_unref);
3637 }
3638
3639 static void
3640 _org_bluez_adapter_on_signal_device_created (
3641     OrgBluezAdapter *object,
3642     const gchar *arg_unnamed_arg0)
3643 {
3644   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3645
3646   GList      *connections, *l;
3647   GVariant   *signal_variant;
3648   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3649
3650   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
3651                    arg_unnamed_arg0));
3652   for (l = connections; l != NULL; l = l->next)
3653     {
3654       GDBusConnection *connection = l->data;
3655       g_dbus_connection_emit_signal (connection,
3656         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Adapter", "DeviceCreated",
3657         signal_variant, NULL);
3658     }
3659   g_variant_unref (signal_variant);
3660   g_list_free_full (connections, g_object_unref);
3661 }
3662
3663 static void
3664 _org_bluez_adapter_on_signal_device_removed (
3665     OrgBluezAdapter *object,
3666     const gchar *arg_unnamed_arg0)
3667 {
3668   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3669
3670   GList      *connections, *l;
3671   GVariant   *signal_variant;
3672   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3673
3674   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
3675                    arg_unnamed_arg0));
3676   for (l = connections; l != NULL; l = l->next)
3677     {
3678       GDBusConnection *connection = l->data;
3679       g_dbus_connection_emit_signal (connection,
3680         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Adapter", "DeviceRemoved",
3681         signal_variant, NULL);
3682     }
3683   g_variant_unref (signal_variant);
3684   g_list_free_full (connections, g_object_unref);
3685 }
3686
3687 static void
3688 _org_bluez_adapter_on_signal_device_found (
3689     OrgBluezAdapter *object,
3690     const gchar *arg_unnamed_arg0,
3691     GVariant *arg_unnamed_arg1)
3692 {
3693   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3694
3695   GList      *connections, *l;
3696   GVariant   *signal_variant;
3697   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3698
3699   signal_variant = g_variant_ref_sink (g_variant_new ("(s@a{sv})",
3700                    arg_unnamed_arg0,
3701                    arg_unnamed_arg1));
3702   for (l = connections; l != NULL; l = l->next)
3703     {
3704       GDBusConnection *connection = l->data;
3705       g_dbus_connection_emit_signal (connection,
3706         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Adapter", "DeviceFound",
3707         signal_variant, NULL);
3708     }
3709   g_variant_unref (signal_variant);
3710   g_list_free_full (connections, g_object_unref);
3711 }
3712
3713 static void
3714 _org_bluez_adapter_on_signal_device_disappeared (
3715     OrgBluezAdapter *object,
3716     const gchar *arg_unnamed_arg0)
3717 {
3718   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3719
3720   GList      *connections, *l;
3721   GVariant   *signal_variant;
3722   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3723
3724   signal_variant = g_variant_ref_sink (g_variant_new ("(s)",
3725                    arg_unnamed_arg0));
3726   for (l = connections; l != NULL; l = l->next)
3727     {
3728       GDBusConnection *connection = l->data;
3729       g_dbus_connection_emit_signal (connection,
3730         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.bluez.Adapter", "DeviceDisappeared",
3731         signal_variant, NULL);
3732     }
3733   g_variant_unref (signal_variant);
3734   g_list_free_full (connections, g_object_unref);
3735 }
3736
3737 static void org_bluez_adapter_skeleton_iface_init (OrgBluezAdapterIface *iface);
3738 G_DEFINE_TYPE_WITH_CODE (OrgBluezAdapterSkeleton, org_bluez_adapter_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
3739                          G_IMPLEMENT_INTERFACE (TYPE_ORG_BLUEZ_ADAPTER, org_bluez_adapter_skeleton_iface_init));
3740
3741 static void
3742 org_bluez_adapter_skeleton_finalize (GObject *object)
3743 {
3744   OrgBluezAdapterSkeleton *skeleton = ORG_BLUEZ_ADAPTER_SKELETON (object);
3745   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
3746   if (skeleton->priv->changed_properties_idle_source != NULL)
3747     g_source_destroy (skeleton->priv->changed_properties_idle_source);
3748   g_main_context_unref (skeleton->priv->context);
3749   g_mutex_clear (&skeleton->priv->lock);
3750   G_OBJECT_CLASS (org_bluez_adapter_skeleton_parent_class)->finalize (object);
3751 }
3752
3753 static void
3754 org_bluez_adapter_skeleton_init (OrgBluezAdapterSkeleton *skeleton)
3755 {
3756   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_BLUEZ_ADAPTER_SKELETON, OrgBluezAdapterSkeletonPrivate);
3757   g_mutex_init (&skeleton->priv->lock);
3758   skeleton->priv->context = g_main_context_ref_thread_default ();
3759 }
3760
3761 static void
3762 org_bluez_adapter_skeleton_class_init (OrgBluezAdapterSkeletonClass *klass)
3763 {
3764   GObjectClass *gobject_class;
3765   GDBusInterfaceSkeletonClass *skeleton_class;
3766
3767   g_type_class_add_private (klass, sizeof (OrgBluezAdapterSkeletonPrivate));
3768
3769   gobject_class = G_OBJECT_CLASS (klass);
3770   gobject_class->finalize = org_bluez_adapter_skeleton_finalize;
3771
3772   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
3773   skeleton_class->get_info = org_bluez_adapter_skeleton_dbus_interface_get_info;
3774   skeleton_class->get_properties = org_bluez_adapter_skeleton_dbus_interface_get_properties;
3775   skeleton_class->flush = org_bluez_adapter_skeleton_dbus_interface_flush;
3776   skeleton_class->get_vtable = org_bluez_adapter_skeleton_dbus_interface_get_vtable;
3777 }
3778
3779 static void
3780 org_bluez_adapter_skeleton_iface_init (OrgBluezAdapterIface *iface)
3781 {
3782   iface->property_changed = _org_bluez_adapter_on_signal_property_changed;
3783   iface->device_created = _org_bluez_adapter_on_signal_device_created;
3784   iface->device_removed = _org_bluez_adapter_on_signal_device_removed;
3785   iface->device_found = _org_bluez_adapter_on_signal_device_found;
3786   iface->device_disappeared = _org_bluez_adapter_on_signal_device_disappeared;
3787 }
3788
3789 /**
3790  * org_bluez_adapter_skeleton_new:
3791  *
3792  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-bluez-Adapter.top_of_page">org.bluez.Adapter</link>.
3793  *
3794  * Returns: (transfer full) (type OrgBluezAdapterSkeleton): The skeleton object.
3795  */
3796 OrgBluezAdapter *
3797 org_bluez_adapter_skeleton_new (void)
3798 {
3799   return ORG_BLUEZ_ADAPTER (g_object_new (TYPE_ORG_BLUEZ_ADAPTER_SKELETON, NULL));
3800 }
3801