sample/phone/telephony-binding/gdbus/ofono_voicecallmanager_interface.c

   1 /*
   2  * Generated by gdbus-codegen 2.50.3. 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 "ofono_voicecallmanager_interface.h"
  12
  13 #include <string.h>
  14 #ifdef G_OS_UNIX
  15 #  include <gio/gunixfdlist.h>
  16 #endif
  17
  18 typedef struct
  19 {
  20   GDBusArgInfo parent_struct;
  21   gboolean use_gvariant;
  22 } _ExtendedGDBusArgInfo;
  23
  24 typedef struct
  25 {
  26   GDBusMethodInfo parent_struct;
  27   const gchar *signal_name;
  28   gboolean pass_fdlist;
  29 } _ExtendedGDBusMethodInfo;
  30
  31 typedef struct
  32 {
  33   GDBusSignalInfo parent_struct;
  34   const gchar *signal_name;
  35 } _ExtendedGDBusSignalInfo;
  36
  37 typedef struct
  38 {
  39   GDBusPropertyInfo parent_struct;
  40   const gchar *hyphen_name;
  41   gboolean use_gvariant;
  42 } _ExtendedGDBusPropertyInfo;
  43
  44 typedef struct
  45 {
  46   GDBusInterfaceInfo parent_struct;
  47   const gchar *hyphen_name;
  48 } _ExtendedGDBusInterfaceInfo;
  49
  50 typedef struct
  51 {
  52   const _ExtendedGDBusPropertyInfo *info;
  53   guint prop_id;
  54   GValue orig_value; /* the value before the change */
  55 } ChangedProperty;
  56
  57 static void
  58 _changed_property_free (ChangedProperty *data)
  59 {
  60   g_value_unset (&data->orig_value);
  61   g_free (data);
  62 }
  63
  64 static gboolean
  65 _g_strv_equal0 (gchar **a, gchar **b)
  66 {
  67   gboolean ret = FALSE;
  68   guint n;
  69   if (a == NULL && b == NULL)
  70     {
  71       ret = TRUE;
  72       goto out;
  73     }
  74   if (a == NULL || b == NULL)
  75     goto out;
  76   if (g_strv_length (a) != g_strv_length (b))
  77     goto out;
  78   for (n = 0; a[n] != NULL; n++)
  79     if (g_strcmp0 (a[n], b[n]) != 0)
  80       goto out;
  81   ret = TRUE;
  82 out:
  83   return ret;
  84 }
  85
  86 static gboolean
  87 _g_variant_equal0 (GVariant *a, GVariant *b)
  88 {
  89   gboolean ret = FALSE;
  90   if (a == NULL && b == NULL)
  91     {
  92       ret = TRUE;
  93       goto out;
  94     }
  95   if (a == NULL || b == NULL)
  96     goto out;
  97   ret = g_variant_equal (a, b);
  98 out:
  99   return ret;
 100 }
 101
 102 G_GNUC_UNUSED static gboolean
 103 _g_value_equal (const GValue *a, const GValue *b)
 104 {
 105   gboolean ret = FALSE;
 106   g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
 107   switch (G_VALUE_TYPE (a))
 108     {
 109       case G_TYPE_BOOLEAN:
 110         ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
 111         break;
 112       case G_TYPE_UCHAR:
 113         ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
 114         break;
 115       case G_TYPE_INT:
 116         ret = (g_value_get_int (a) == g_value_get_int (b));
 117         break;
 118       case G_TYPE_UINT:
 119         ret = (g_value_get_uint (a) == g_value_get_uint (b));
 120         break;
 121       case G_TYPE_INT64:
 122         ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
 123         break;
 124       case G_TYPE_UINT64:
 125         ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
 126         break;
 127       case G_TYPE_DOUBLE:
 128         {
 129           /* Avoid -Wfloat-equal warnings by doing a direct bit compare */
 130           gdouble da = g_value_get_double (a);
 131           gdouble db = g_value_get_double (b);
 132           ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
 133         }
 134         break;
 135       case G_TYPE_STRING:
 136         ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
 137         break;
 138       case G_TYPE_VARIANT:
 139         ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
 140         break;
 141       default:
 142         if (G_VALUE_TYPE (a) == G_TYPE_STRV)
 143           ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
 144         else
 145           g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
 146         break;
 147     }
 148   return ret;
 149 }
 150
 151 /* ------------------------------------------------------------------------
 152  * Code for interface org.ofono.VoiceCallManager
 153  * ------------------------------------------------------------------------
 154  */
 155
 156 /**
 157  * SECTION:OrgOfonoVoiceCallManager
 158  * @title: OrgOfonoVoiceCallManager
 159  * @short_description: Generated C code for the org.ofono.VoiceCallManager D-Bus interface
 160  *
 161  * This section contains code for working with the <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link> D-Bus interface in C.
 162  */
 163
 164 /* ---- Introspection data for org.ofono.VoiceCallManager ---- */
 165
 166 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_get_properties_OUT_ARG_unnamed_arg0 =
 167 {
 168   {
 169     -1,
 170     (gchar *) "unnamed_arg0",
 171     (gchar *) "a{sv}",
 172     NULL
 173   },
 174   FALSE
 175 };
 176
 177 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_get_properties_OUT_ARG_pointers[] =
 178 {
 179   &_org_ofono_voice_call_manager_method_info_get_properties_OUT_ARG_unnamed_arg0,
 180   NULL
 181 };
 182
 183 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_get_properties =
 184 {
 185   {
 186     -1,
 187     (gchar *) "GetProperties",
 188     NULL,
 189     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_get_properties_OUT_ARG_pointers,
 190     NULL
 191   },
 192   "handle-get-properties",
 193   FALSE
 194 };
 195
 196 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_dial_IN_ARG_unnamed_arg0 =
 197 {
 198   {
 199     -1,
 200     (gchar *) "unnamed_arg0",
 201     (gchar *) "s",
 202     NULL
 203   },
 204   FALSE
 205 };
 206
 207 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_dial_IN_ARG_unnamed_arg1 =
 208 {
 209   {
 210     -1,
 211     (gchar *) "unnamed_arg1",
 212     (gchar *) "s",
 213     NULL
 214   },
 215   FALSE
 216 };
 217
 218 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_dial_IN_ARG_pointers[] =
 219 {
 220   &_org_ofono_voice_call_manager_method_info_dial_IN_ARG_unnamed_arg0,
 221   &_org_ofono_voice_call_manager_method_info_dial_IN_ARG_unnamed_arg1,
 222   NULL
 223 };
 224
 225 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_dial_OUT_ARG_unnamed_arg2 =
 226 {
 227   {
 228     -1,
 229     (gchar *) "unnamed_arg2",
 230     (gchar *) "o",
 231     NULL
 232   },
 233   FALSE
 234 };
 235
 236 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_dial_OUT_ARG_pointers[] =
 237 {
 238   &_org_ofono_voice_call_manager_method_info_dial_OUT_ARG_unnamed_arg2,
 239   NULL
 240 };
 241
 242 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_dial =
 243 {
 244   {
 245     -1,
 246     (gchar *) "Dial",
 247     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_dial_IN_ARG_pointers,
 248     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_dial_OUT_ARG_pointers,
 249     NULL
 250   },
 251   "handle-dial",
 252   FALSE
 253 };
 254
 255 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_transfer =
 256 {
 257   {
 258     -1,
 259     (gchar *) "Transfer",
 260     NULL,
 261     NULL,
 262     NULL
 263   },
 264   "handle-transfer",
 265   FALSE
 266 };
 267
 268 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_swap_calls =
 269 {
 270   {
 271     -1,
 272     (gchar *) "SwapCalls",
 273     NULL,
 274     NULL,
 275     NULL
 276   },
 277   "handle-swap-calls",
 278   FALSE
 279 };
 280
 281 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_release_and_answer =
 282 {
 283   {
 284     -1,
 285     (gchar *) "ReleaseAndAnswer",
 286     NULL,
 287     NULL,
 288     NULL
 289   },
 290   "handle-release-and-answer",
 291   FALSE
 292 };
 293
 294 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_hold_and_answer =
 295 {
 296   {
 297     -1,
 298     (gchar *) "HoldAndAnswer",
 299     NULL,
 300     NULL,
 301     NULL
 302   },
 303   "handle-hold-and-answer",
 304   FALSE
 305 };
 306
 307 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_hangup_all =
 308 {
 309   {
 310     -1,
 311     (gchar *) "HangupAll",
 312     NULL,
 313     NULL,
 314     NULL
 315   },
 316   "handle-hangup-all",
 317   FALSE
 318 };
 319
 320 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_private_chat_IN_ARG_unnamed_arg0 =
 321 {
 322   {
 323     -1,
 324     (gchar *) "unnamed_arg0",
 325     (gchar *) "o",
 326     NULL
 327   },
 328   FALSE
 329 };
 330
 331 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_private_chat_IN_ARG_pointers[] =
 332 {
 333   &_org_ofono_voice_call_manager_method_info_private_chat_IN_ARG_unnamed_arg0,
 334   NULL
 335 };
 336
 337 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_private_chat_OUT_ARG_unnamed_arg1 =
 338 {
 339   {
 340     -1,
 341     (gchar *) "unnamed_arg1",
 342     (gchar *) "ao",
 343     NULL
 344   },
 345   FALSE
 346 };
 347
 348 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_private_chat_OUT_ARG_pointers[] =
 349 {
 350   &_org_ofono_voice_call_manager_method_info_private_chat_OUT_ARG_unnamed_arg1,
 351   NULL
 352 };
 353
 354 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_private_chat =
 355 {
 356   {
 357     -1,
 358     (gchar *) "PrivateChat",
 359     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_private_chat_IN_ARG_pointers,
 360     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_private_chat_OUT_ARG_pointers,
 361     NULL
 362   },
 363   "handle-private-chat",
 364   FALSE
 365 };
 366
 367 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_create_multiparty_OUT_ARG_unnamed_arg0 =
 368 {
 369   {
 370     -1,
 371     (gchar *) "unnamed_arg0",
 372     (gchar *) "ao",
 373     NULL
 374   },
 375   FALSE
 376 };
 377
 378 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_create_multiparty_OUT_ARG_pointers[] =
 379 {
 380   &_org_ofono_voice_call_manager_method_info_create_multiparty_OUT_ARG_unnamed_arg0,
 381   NULL
 382 };
 383
 384 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_create_multiparty =
 385 {
 386   {
 387     -1,
 388     (gchar *) "CreateMultiparty",
 389     NULL,
 390     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_create_multiparty_OUT_ARG_pointers,
 391     NULL
 392   },
 393   "handle-create-multiparty",
 394   FALSE
 395 };
 396
 397 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_hangup_multiparty =
 398 {
 399   {
 400     -1,
 401     (gchar *) "HangupMultiparty",
 402     NULL,
 403     NULL,
 404     NULL
 405   },
 406   "handle-hangup-multiparty",
 407   FALSE
 408 };
 409
 410 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_send_tones_IN_ARG_unnamed_arg0 =
 411 {
 412   {
 413     -1,
 414     (gchar *) "unnamed_arg0",
 415     (gchar *) "s",
 416     NULL
 417   },
 418   FALSE
 419 };
 420
 421 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_send_tones_IN_ARG_pointers[] =
 422 {
 423   &_org_ofono_voice_call_manager_method_info_send_tones_IN_ARG_unnamed_arg0,
 424   NULL
 425 };
 426
 427 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_send_tones =
 428 {
 429   {
 430     -1,
 431     (gchar *) "SendTones",
 432     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_send_tones_IN_ARG_pointers,
 433     NULL,
 434     NULL
 435   },
 436   "handle-send-tones",
 437   FALSE
 438 };
 439
 440 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_method_info_get_calls_OUT_ARG_unnamed_arg0 =
 441 {
 442   {
 443     -1,
 444     (gchar *) "unnamed_arg0",
 445     (gchar *) "a(oa{sv})",
 446     NULL
 447   },
 448   FALSE
 449 };
 450
 451 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_method_info_get_calls_OUT_ARG_pointers[] =
 452 {
 453   &_org_ofono_voice_call_manager_method_info_get_calls_OUT_ARG_unnamed_arg0,
 454   NULL
 455 };
 456
 457 static const _ExtendedGDBusMethodInfo _org_ofono_voice_call_manager_method_info_get_calls =
 458 {
 459   {
 460     -1,
 461     (gchar *) "GetCalls",
 462     NULL,
 463     (GDBusArgInfo **) &_org_ofono_voice_call_manager_method_info_get_calls_OUT_ARG_pointers,
 464     NULL
 465   },
 466   "handle-get-calls",
 467   FALSE
 468 };
 469
 470 static const _ExtendedGDBusMethodInfo * const _org_ofono_voice_call_manager_method_info_pointers[] =
 471 {
 472   &_org_ofono_voice_call_manager_method_info_get_properties,
 473   &_org_ofono_voice_call_manager_method_info_dial,
 474   &_org_ofono_voice_call_manager_method_info_transfer,
 475   &_org_ofono_voice_call_manager_method_info_swap_calls,
 476   &_org_ofono_voice_call_manager_method_info_release_and_answer,
 477   &_org_ofono_voice_call_manager_method_info_hold_and_answer,
 478   &_org_ofono_voice_call_manager_method_info_hangup_all,
 479   &_org_ofono_voice_call_manager_method_info_private_chat,
 480   &_org_ofono_voice_call_manager_method_info_create_multiparty,
 481   &_org_ofono_voice_call_manager_method_info_hangup_multiparty,
 482   &_org_ofono_voice_call_manager_method_info_send_tones,
 483   &_org_ofono_voice_call_manager_method_info_get_calls,
 484   NULL
 485 };
 486
 487 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_property_changed_ARG_unnamed_arg0 =
 488 {
 489   {
 490     -1,
 491     (gchar *) "unnamed_arg0",
 492     (gchar *) "s",
 493     NULL
 494   },
 495   FALSE
 496 };
 497
 498 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_property_changed_ARG_unnamed_arg1 =
 499 {
 500   {
 501     -1,
 502     (gchar *) "unnamed_arg1",
 503     (gchar *) "v",
 504     NULL
 505   },
 506   FALSE
 507 };
 508
 509 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_signal_info_property_changed_ARG_pointers[] =
 510 {
 511   &_org_ofono_voice_call_manager_signal_info_property_changed_ARG_unnamed_arg0,
 512   &_org_ofono_voice_call_manager_signal_info_property_changed_ARG_unnamed_arg1,
 513   NULL
 514 };
 515
 516 static const _ExtendedGDBusSignalInfo _org_ofono_voice_call_manager_signal_info_property_changed =
 517 {
 518   {
 519     -1,
 520     (gchar *) "PropertyChanged",
 521     (GDBusArgInfo **) &_org_ofono_voice_call_manager_signal_info_property_changed_ARG_pointers,
 522     NULL
 523   },
 524   "property-changed"
 525 };
 526
 527 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_call_added_ARG_unnamed_arg0 =
 528 {
 529   {
 530     -1,
 531     (gchar *) "unnamed_arg0",
 532     (gchar *) "o",
 533     NULL
 534   },
 535   FALSE
 536 };
 537
 538 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_call_added_ARG_unnamed_arg1 =
 539 {
 540   {
 541     -1,
 542     (gchar *) "unnamed_arg1",
 543     (gchar *) "a{sv}",
 544     NULL
 545   },
 546   FALSE
 547 };
 548
 549 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_signal_info_call_added_ARG_pointers[] =
 550 {
 551   &_org_ofono_voice_call_manager_signal_info_call_added_ARG_unnamed_arg0,
 552   &_org_ofono_voice_call_manager_signal_info_call_added_ARG_unnamed_arg1,
 553   NULL
 554 };
 555
 556 static const _ExtendedGDBusSignalInfo _org_ofono_voice_call_manager_signal_info_call_added =
 557 {
 558   {
 559     -1,
 560     (gchar *) "CallAdded",
 561     (GDBusArgInfo **) &_org_ofono_voice_call_manager_signal_info_call_added_ARG_pointers,
 562     NULL
 563   },
 564   "call-added"
 565 };
 566
 567 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_call_removed_ARG_unnamed_arg0 =
 568 {
 569   {
 570     -1,
 571     (gchar *) "unnamed_arg0",
 572     (gchar *) "o",
 573     NULL
 574   },
 575   FALSE
 576 };
 577
 578 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_signal_info_call_removed_ARG_pointers[] =
 579 {
 580   &_org_ofono_voice_call_manager_signal_info_call_removed_ARG_unnamed_arg0,
 581   NULL
 582 };
 583
 584 static const _ExtendedGDBusSignalInfo _org_ofono_voice_call_manager_signal_info_call_removed =
 585 {
 586   {
 587     -1,
 588     (gchar *) "CallRemoved",
 589     (GDBusArgInfo **) &_org_ofono_voice_call_manager_signal_info_call_removed_ARG_pointers,
 590     NULL
 591   },
 592   "call-removed"
 593 };
 594
 595 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_barring_active_ARG_unnamed_arg0 =
 596 {
 597   {
 598     -1,
 599     (gchar *) "unnamed_arg0",
 600     (gchar *) "s",
 601     NULL
 602   },
 603   FALSE
 604 };
 605
 606 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_signal_info_barring_active_ARG_pointers[] =
 607 {
 608   &_org_ofono_voice_call_manager_signal_info_barring_active_ARG_unnamed_arg0,
 609   NULL
 610 };
 611
 612 static const _ExtendedGDBusSignalInfo _org_ofono_voice_call_manager_signal_info_barring_active =
 613 {
 614   {
 615     -1,
 616     (gchar *) "BarringActive",
 617     (GDBusArgInfo **) &_org_ofono_voice_call_manager_signal_info_barring_active_ARG_pointers,
 618     NULL
 619   },
 620   "barring-active"
 621 };
 622
 623 static const _ExtendedGDBusArgInfo _org_ofono_voice_call_manager_signal_info_forwarded_ARG_unnamed_arg0 =
 624 {
 625   {
 626     -1,
 627     (gchar *) "unnamed_arg0",
 628     (gchar *) "s",
 629     NULL
 630   },
 631   FALSE
 632 };
 633
 634 static const _ExtendedGDBusArgInfo * const _org_ofono_voice_call_manager_signal_info_forwarded_ARG_pointers[] =
 635 {
 636   &_org_ofono_voice_call_manager_signal_info_forwarded_ARG_unnamed_arg0,
 637   NULL
 638 };
 639
 640 static const _ExtendedGDBusSignalInfo _org_ofono_voice_call_manager_signal_info_forwarded =
 641 {
 642   {
 643     -1,
 644     (gchar *) "Forwarded",
 645     (GDBusArgInfo **) &_org_ofono_voice_call_manager_signal_info_forwarded_ARG_pointers,
 646     NULL
 647   },
 648   "forwarded"
 649 };
 650
 651 static const _ExtendedGDBusSignalInfo * const _org_ofono_voice_call_manager_signal_info_pointers[] =
 652 {
 653   &_org_ofono_voice_call_manager_signal_info_property_changed,
 654   &_org_ofono_voice_call_manager_signal_info_call_added,
 655   &_org_ofono_voice_call_manager_signal_info_call_removed,
 656   &_org_ofono_voice_call_manager_signal_info_barring_active,
 657   &_org_ofono_voice_call_manager_signal_info_forwarded,
 658   NULL
 659 };
 660
 661 static const _ExtendedGDBusInterfaceInfo _org_ofono_voice_call_manager_interface_info =
 662 {
 663   {
 664     -1,
 665     (gchar *) "org.ofono.VoiceCallManager",
 666     (GDBusMethodInfo **) &_org_ofono_voice_call_manager_method_info_pointers,
 667     (GDBusSignalInfo **) &_org_ofono_voice_call_manager_signal_info_pointers,
 668     NULL,
 669     NULL
 670   },
 671   "org-ofono-voice-call-manager",
 672 };
 673
 674
 675 /**
 676  * org_ofono_voice_call_manager_interface_info:
 677  *
 678  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link> D-Bus interface.
 679  *
 680  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 681  */
 682 GDBusInterfaceInfo *
 683 org_ofono_voice_call_manager_interface_info (void)
 684 {
 685   return (GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct;
 686 }
 687
 688 /**
 689  * org_ofono_voice_call_manager_override_properties:
 690  * @klass: The class structure for a #GObject<!-- -->-derived class.
 691  * @property_id_begin: The property id to assign to the first overridden property.
 692  *
 693  * Overrides all #GObject properties in the #OrgOfonoVoiceCallManager interface for a concrete class.
 694  * The properties are overridden in the order they are defined.
 695  *
 696  * Returns: The last property id.
 697  */
 698 guint
 699 org_ofono_voice_call_manager_override_properties (GObjectClass *klass, guint property_id_begin)
 700 {
 701   return property_id_begin - 1;
 702 }
 703
 704
 705
 706 /**
 707  * OrgOfonoVoiceCallManager:
 708  *
 709  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link>.
 710  */
 711
 712 /**
 713  * OrgOfonoVoiceCallManagerIface:
 714  * @parent_iface: The parent interface.
 715  * @handle_create_multiparty: Handler for the #OrgOfonoVoiceCallManager::handle-create-multiparty signal.
 716  * @handle_dial: Handler for the #OrgOfonoVoiceCallManager::handle-dial signal.
 717  * @handle_get_calls: Handler for the #OrgOfonoVoiceCallManager::handle-get-calls signal.
 718  * @handle_get_properties: Handler for the #OrgOfonoVoiceCallManager::handle-get-properties signal.
 719  * @handle_hangup_all: Handler for the #OrgOfonoVoiceCallManager::handle-hangup-all signal.
 720  * @handle_hangup_multiparty: Handler for the #OrgOfonoVoiceCallManager::handle-hangup-multiparty signal.
 721  * @handle_hold_and_answer: Handler for the #OrgOfonoVoiceCallManager::handle-hold-and-answer signal.
 722  * @handle_private_chat: Handler for the #OrgOfonoVoiceCallManager::handle-private-chat signal.
 723  * @handle_release_and_answer: Handler for the #OrgOfonoVoiceCallManager::handle-release-and-answer signal.
 724  * @handle_send_tones: Handler for the #OrgOfonoVoiceCallManager::handle-send-tones signal.
 725  * @handle_swap_calls: Handler for the #OrgOfonoVoiceCallManager::handle-swap-calls signal.
 726  * @handle_transfer: Handler for the #OrgOfonoVoiceCallManager::handle-transfer signal.
 727  * @barring_active: Handler for the #OrgOfonoVoiceCallManager::barring-active signal.
 728  * @call_added: Handler for the #OrgOfonoVoiceCallManager::call-added signal.
 729  * @call_removed: Handler for the #OrgOfonoVoiceCallManager::call-removed signal.
 730  * @forwarded: Handler for the #OrgOfonoVoiceCallManager::forwarded signal.
 731  * @property_changed: Handler for the #OrgOfonoVoiceCallManager::property-changed signal.
 732  *
 733  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link>.
 734  */
 735
 736 typedef OrgOfonoVoiceCallManagerIface OrgOfonoVoiceCallManagerInterface;
 737 G_DEFINE_INTERFACE (OrgOfonoVoiceCallManager, org_ofono_voice_call_manager, G_TYPE_OBJECT);
 738
 739 static void
 740 org_ofono_voice_call_manager_default_init (OrgOfonoVoiceCallManagerIface *iface)
 741 {
 742   /* GObject signals for incoming D-Bus method calls: */
 743   /**
 744    * OrgOfonoVoiceCallManager::handle-get-properties:
 745    * @object: A #OrgOfonoVoiceCallManager.
 746    * @invocation: A #GDBusMethodInvocation.
 747    *
 748    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetProperties">GetProperties()</link> D-Bus method.
 749    *
 750    * 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_ofono_voice_call_manager_complete_get_properties() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
 751    *
 752    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 753    */
 754   g_signal_new ("handle-get-properties",
 755     G_TYPE_FROM_INTERFACE (iface),
 756     G_SIGNAL_RUN_LAST,
 757     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_get_properties),
 758     g_signal_accumulator_true_handled,
 759     NULL,
 760     g_cclosure_marshal_generic,
 761     G_TYPE_BOOLEAN,
 762     1,
 763     G_TYPE_DBUS_METHOD_INVOCATION);
 764
 765   /**
 766    * OrgOfonoVoiceCallManager::handle-dial:
 767    * @object: A #OrgOfonoVoiceCallManager.
 768    * @invocation: A #GDBusMethodInvocation.
 769    * @arg_unnamed_arg0: Argument passed by remote caller.
 770    * @arg_unnamed_arg1: Argument passed by remote caller.
 771    *
 772    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Dial">Dial()</link> D-Bus method.
 773    *
 774    * 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_ofono_voice_call_manager_complete_dial() 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.
 775    *
 776    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 777    */
 778   g_signal_new ("handle-dial",
 779     G_TYPE_FROM_INTERFACE (iface),
 780     G_SIGNAL_RUN_LAST,
 781     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_dial),
 782     g_signal_accumulator_true_handled,
 783     NULL,
 784     g_cclosure_marshal_generic,
 785     G_TYPE_BOOLEAN,
 786     3,
 787     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING);
 788
 789   /**
 790    * OrgOfonoVoiceCallManager::handle-transfer:
 791    * @object: A #OrgOfonoVoiceCallManager.
 792    * @invocation: A #GDBusMethodInvocation.
 793    *
 794    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Transfer">Transfer()</link> D-Bus method.
 795    *
 796    * 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_ofono_voice_call_manager_complete_transfer() 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.
 797    *
 798    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 799    */
 800   g_signal_new ("handle-transfer",
 801     G_TYPE_FROM_INTERFACE (iface),
 802     G_SIGNAL_RUN_LAST,
 803     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_transfer),
 804     g_signal_accumulator_true_handled,
 805     NULL,
 806     g_cclosure_marshal_generic,
 807     G_TYPE_BOOLEAN,
 808     1,
 809     G_TYPE_DBUS_METHOD_INVOCATION);
 810
 811   /**
 812    * OrgOfonoVoiceCallManager::handle-swap-calls:
 813    * @object: A #OrgOfonoVoiceCallManager.
 814    * @invocation: A #GDBusMethodInvocation.
 815    *
 816    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SwapCalls">SwapCalls()</link> D-Bus method.
 817    *
 818    * 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_ofono_voice_call_manager_complete_swap_calls() 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.
 819    *
 820    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 821    */
 822   g_signal_new ("handle-swap-calls",
 823     G_TYPE_FROM_INTERFACE (iface),
 824     G_SIGNAL_RUN_LAST,
 825     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_swap_calls),
 826     g_signal_accumulator_true_handled,
 827     NULL,
 828     g_cclosure_marshal_generic,
 829     G_TYPE_BOOLEAN,
 830     1,
 831     G_TYPE_DBUS_METHOD_INVOCATION);
 832
 833   /**
 834    * OrgOfonoVoiceCallManager::handle-release-and-answer:
 835    * @object: A #OrgOfonoVoiceCallManager.
 836    * @invocation: A #GDBusMethodInvocation.
 837    *
 838    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.ReleaseAndAnswer">ReleaseAndAnswer()</link> D-Bus method.
 839    *
 840    * 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_ofono_voice_call_manager_complete_release_and_answer() 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.
 841    *
 842    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 843    */
 844   g_signal_new ("handle-release-and-answer",
 845     G_TYPE_FROM_INTERFACE (iface),
 846     G_SIGNAL_RUN_LAST,
 847     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_release_and_answer),
 848     g_signal_accumulator_true_handled,
 849     NULL,
 850     g_cclosure_marshal_generic,
 851     G_TYPE_BOOLEAN,
 852     1,
 853     G_TYPE_DBUS_METHOD_INVOCATION);
 854
 855   /**
 856    * OrgOfonoVoiceCallManager::handle-hold-and-answer:
 857    * @object: A #OrgOfonoVoiceCallManager.
 858    * @invocation: A #GDBusMethodInvocation.
 859    *
 860    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HoldAndAnswer">HoldAndAnswer()</link> D-Bus method.
 861    *
 862    * 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_ofono_voice_call_manager_complete_hold_and_answer() 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.
 863    *
 864    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 865    */
 866   g_signal_new ("handle-hold-and-answer",
 867     G_TYPE_FROM_INTERFACE (iface),
 868     G_SIGNAL_RUN_LAST,
 869     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_hold_and_answer),
 870     g_signal_accumulator_true_handled,
 871     NULL,
 872     g_cclosure_marshal_generic,
 873     G_TYPE_BOOLEAN,
 874     1,
 875     G_TYPE_DBUS_METHOD_INVOCATION);
 876
 877   /**
 878    * OrgOfonoVoiceCallManager::handle-hangup-all:
 879    * @object: A #OrgOfonoVoiceCallManager.
 880    * @invocation: A #GDBusMethodInvocation.
 881    *
 882    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupAll">HangupAll()</link> D-Bus method.
 883    *
 884    * 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_ofono_voice_call_manager_complete_hangup_all() 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.
 885    *
 886    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 887    */
 888   g_signal_new ("handle-hangup-all",
 889     G_TYPE_FROM_INTERFACE (iface),
 890     G_SIGNAL_RUN_LAST,
 891     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_hangup_all),
 892     g_signal_accumulator_true_handled,
 893     NULL,
 894     g_cclosure_marshal_generic,
 895     G_TYPE_BOOLEAN,
 896     1,
 897     G_TYPE_DBUS_METHOD_INVOCATION);
 898
 899   /**
 900    * OrgOfonoVoiceCallManager::handle-private-chat:
 901    * @object: A #OrgOfonoVoiceCallManager.
 902    * @invocation: A #GDBusMethodInvocation.
 903    * @arg_unnamed_arg0: Argument passed by remote caller.
 904    *
 905    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.PrivateChat">PrivateChat()</link> D-Bus method.
 906    *
 907    * 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_ofono_voice_call_manager_complete_private_chat() 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.
 908    *
 909    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 910    */
 911   g_signal_new ("handle-private-chat",
 912     G_TYPE_FROM_INTERFACE (iface),
 913     G_SIGNAL_RUN_LAST,
 914     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_private_chat),
 915     g_signal_accumulator_true_handled,
 916     NULL,
 917     g_cclosure_marshal_generic,
 918     G_TYPE_BOOLEAN,
 919     2,
 920     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
 921
 922   /**
 923    * OrgOfonoVoiceCallManager::handle-create-multiparty:
 924    * @object: A #OrgOfonoVoiceCallManager.
 925    * @invocation: A #GDBusMethodInvocation.
 926    *
 927    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.CreateMultiparty">CreateMultiparty()</link> D-Bus method.
 928    *
 929    * 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_ofono_voice_call_manager_complete_create_multiparty() 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.
 930    *
 931    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 932    */
 933   g_signal_new ("handle-create-multiparty",
 934     G_TYPE_FROM_INTERFACE (iface),
 935     G_SIGNAL_RUN_LAST,
 936     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_create_multiparty),
 937     g_signal_accumulator_true_handled,
 938     NULL,
 939     g_cclosure_marshal_generic,
 940     G_TYPE_BOOLEAN,
 941     1,
 942     G_TYPE_DBUS_METHOD_INVOCATION);
 943
 944   /**
 945    * OrgOfonoVoiceCallManager::handle-hangup-multiparty:
 946    * @object: A #OrgOfonoVoiceCallManager.
 947    * @invocation: A #GDBusMethodInvocation.
 948    *
 949    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupMultiparty">HangupMultiparty()</link> D-Bus method.
 950    *
 951    * 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_ofono_voice_call_manager_complete_hangup_multiparty() 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.
 952    *
 953    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 954    */
 955   g_signal_new ("handle-hangup-multiparty",
 956     G_TYPE_FROM_INTERFACE (iface),
 957     G_SIGNAL_RUN_LAST,
 958     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_hangup_multiparty),
 959     g_signal_accumulator_true_handled,
 960     NULL,
 961     g_cclosure_marshal_generic,
 962     G_TYPE_BOOLEAN,
 963     1,
 964     G_TYPE_DBUS_METHOD_INVOCATION);
 965
 966   /**
 967    * OrgOfonoVoiceCallManager::handle-send-tones:
 968    * @object: A #OrgOfonoVoiceCallManager.
 969    * @invocation: A #GDBusMethodInvocation.
 970    * @arg_unnamed_arg0: Argument passed by remote caller.
 971    *
 972    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SendTones">SendTones()</link> D-Bus method.
 973    *
 974    * 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_ofono_voice_call_manager_complete_send_tones() 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.
 975    *
 976    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 977    */
 978   g_signal_new ("handle-send-tones",
 979     G_TYPE_FROM_INTERFACE (iface),
 980     G_SIGNAL_RUN_LAST,
 981     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_send_tones),
 982     g_signal_accumulator_true_handled,
 983     NULL,
 984     g_cclosure_marshal_generic,
 985     G_TYPE_BOOLEAN,
 986     2,
 987     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
 988
 989   /**
 990    * OrgOfonoVoiceCallManager::handle-get-calls:
 991    * @object: A #OrgOfonoVoiceCallManager.
 992    * @invocation: A #GDBusMethodInvocation.
 993    *
 994    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetCalls">GetCalls()</link> D-Bus method.
 995    *
 996    * 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_ofono_voice_call_manager_complete_get_calls() 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.
 997    *
 998    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 999    */
1000   g_signal_new ("handle-get-calls",
1001     G_TYPE_FROM_INTERFACE (iface),
1002     G_SIGNAL_RUN_LAST,
1003     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, handle_get_calls),
1004     g_signal_accumulator_true_handled,
1005     NULL,
1006     g_cclosure_marshal_generic,
1007     G_TYPE_BOOLEAN,
1008     1,
1009     G_TYPE_DBUS_METHOD_INVOCATION);
1010
1011   /* GObject signals for received D-Bus signals: */
1012   /**
1013    * OrgOfonoVoiceCallManager::property-changed:
1014    * @object: A #OrgOfonoVoiceCallManager.
1015    * @arg_unnamed_arg0: Argument.
1016    * @arg_unnamed_arg1: Argument.
1017    *
1018    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-ofono-VoiceCallManager.PropertyChanged">"PropertyChanged"</link> is received.
1019    *
1020    * 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.
1021    */
1022   g_signal_new ("property-changed",
1023     G_TYPE_FROM_INTERFACE (iface),
1024     G_SIGNAL_RUN_LAST,
1025     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, property_changed),
1026     NULL,
1027     NULL,
1028     g_cclosure_marshal_generic,
1029     G_TYPE_NONE,
1030     2, G_TYPE_STRING, G_TYPE_VARIANT);
1031
1032   /**
1033    * OrgOfonoVoiceCallManager::call-added:
1034    * @object: A #OrgOfonoVoiceCallManager.
1035    * @arg_unnamed_arg0: Argument.
1036    * @arg_unnamed_arg1: Argument.
1037    *
1038    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-ofono-VoiceCallManager.CallAdded">"CallAdded"</link> is received.
1039    *
1040    * 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.
1041    */
1042   g_signal_new ("call-added",
1043     G_TYPE_FROM_INTERFACE (iface),
1044     G_SIGNAL_RUN_LAST,
1045     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, call_added),
1046     NULL,
1047     NULL,
1048     g_cclosure_marshal_generic,
1049     G_TYPE_NONE,
1050     2, G_TYPE_STRING, G_TYPE_VARIANT);
1051
1052   /**
1053    * OrgOfonoVoiceCallManager::call-removed:
1054    * @object: A #OrgOfonoVoiceCallManager.
1055    * @arg_unnamed_arg0: Argument.
1056    *
1057    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-ofono-VoiceCallManager.CallRemoved">"CallRemoved"</link> is received.
1058    *
1059    * 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.
1060    */
1061   g_signal_new ("call-removed",
1062     G_TYPE_FROM_INTERFACE (iface),
1063     G_SIGNAL_RUN_LAST,
1064     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, call_removed),
1065     NULL,
1066     NULL,
1067     g_cclosure_marshal_generic,
1068     G_TYPE_NONE,
1069     1, G_TYPE_STRING);
1070
1071   /**
1072    * OrgOfonoVoiceCallManager::barring-active:
1073    * @object: A #OrgOfonoVoiceCallManager.
1074    * @arg_unnamed_arg0: Argument.
1075    *
1076    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-ofono-VoiceCallManager.BarringActive">"BarringActive"</link> is received.
1077    *
1078    * 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.
1079    */
1080   g_signal_new ("barring-active",
1081     G_TYPE_FROM_INTERFACE (iface),
1082     G_SIGNAL_RUN_LAST,
1083     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, barring_active),
1084     NULL,
1085     NULL,
1086     g_cclosure_marshal_generic,
1087     G_TYPE_NONE,
1088     1, G_TYPE_STRING);
1089
1090   /**
1091    * OrgOfonoVoiceCallManager::forwarded:
1092    * @object: A #OrgOfonoVoiceCallManager.
1093    * @arg_unnamed_arg0: Argument.
1094    *
1095    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-ofono-VoiceCallManager.Forwarded">"Forwarded"</link> is received.
1096    *
1097    * 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.
1098    */
1099   g_signal_new ("forwarded",
1100     G_TYPE_FROM_INTERFACE (iface),
1101     G_SIGNAL_RUN_LAST,
1102     G_STRUCT_OFFSET (OrgOfonoVoiceCallManagerIface, forwarded),
1103     NULL,
1104     NULL,
1105     g_cclosure_marshal_generic,
1106     G_TYPE_NONE,
1107     1, G_TYPE_STRING);
1108
1109 }
1110
1111 /**
1112  * org_ofono_voice_call_manager_emit_property_changed:
1113  * @object: A #OrgOfonoVoiceCallManager.
1114  * @arg_unnamed_arg0: Argument to pass with the signal.
1115  * @arg_unnamed_arg1: Argument to pass with the signal.
1116  *
1117  * Emits the <link linkend="gdbus-signal-org-ofono-VoiceCallManager.PropertyChanged">"PropertyChanged"</link> D-Bus signal.
1118  */
1119 void
1120 org_ofono_voice_call_manager_emit_property_changed (
1121     OrgOfonoVoiceCallManager *object,
1122     const gchar *arg_unnamed_arg0,
1123     GVariant *arg_unnamed_arg1)
1124 {
1125   g_signal_emit_by_name (object, "property-changed", arg_unnamed_arg0, arg_unnamed_arg1);
1126 }
1127
1128 /**
1129  * org_ofono_voice_call_manager_emit_call_added:
1130  * @object: A #OrgOfonoVoiceCallManager.
1131  * @arg_unnamed_arg0: Argument to pass with the signal.
1132  * @arg_unnamed_arg1: Argument to pass with the signal.
1133  *
1134  * Emits the <link linkend="gdbus-signal-org-ofono-VoiceCallManager.CallAdded">"CallAdded"</link> D-Bus signal.
1135  */
1136 void
1137 org_ofono_voice_call_manager_emit_call_added (
1138     OrgOfonoVoiceCallManager *object,
1139     const gchar *arg_unnamed_arg0,
1140     GVariant *arg_unnamed_arg1)
1141 {
1142   g_signal_emit_by_name (object, "call-added", arg_unnamed_arg0, arg_unnamed_arg1);
1143 }
1144
1145 /**
1146  * org_ofono_voice_call_manager_emit_call_removed:
1147  * @object: A #OrgOfonoVoiceCallManager.
1148  * @arg_unnamed_arg0: Argument to pass with the signal.
1149  *
1150  * Emits the <link linkend="gdbus-signal-org-ofono-VoiceCallManager.CallRemoved">"CallRemoved"</link> D-Bus signal.
1151  */
1152 void
1153 org_ofono_voice_call_manager_emit_call_removed (
1154     OrgOfonoVoiceCallManager *object,
1155     const gchar *arg_unnamed_arg0)
1156 {
1157   g_signal_emit_by_name (object, "call-removed", arg_unnamed_arg0);
1158 }
1159
1160 /**
1161  * org_ofono_voice_call_manager_emit_barring_active:
1162  * @object: A #OrgOfonoVoiceCallManager.
1163  * @arg_unnamed_arg0: Argument to pass with the signal.
1164  *
1165  * Emits the <link linkend="gdbus-signal-org-ofono-VoiceCallManager.BarringActive">"BarringActive"</link> D-Bus signal.
1166  */
1167 void
1168 org_ofono_voice_call_manager_emit_barring_active (
1169     OrgOfonoVoiceCallManager *object,
1170     const gchar *arg_unnamed_arg0)
1171 {
1172   g_signal_emit_by_name (object, "barring-active", arg_unnamed_arg0);
1173 }
1174
1175 /**
1176  * org_ofono_voice_call_manager_emit_forwarded:
1177  * @object: A #OrgOfonoVoiceCallManager.
1178  * @arg_unnamed_arg0: Argument to pass with the signal.
1179  *
1180  * Emits the <link linkend="gdbus-signal-org-ofono-VoiceCallManager.Forwarded">"Forwarded"</link> D-Bus signal.
1181  */
1182 void
1183 org_ofono_voice_call_manager_emit_forwarded (
1184     OrgOfonoVoiceCallManager *object,
1185     const gchar *arg_unnamed_arg0)
1186 {
1187   g_signal_emit_by_name (object, "forwarded", arg_unnamed_arg0);
1188 }
1189
1190 /**
1191  * org_ofono_voice_call_manager_call_get_properties:
1192  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1193  * @cancellable: (allow-none): A #GCancellable or %NULL.
1194  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1195  * @user_data: User data to pass to @callback.
1196  *
1197  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetProperties">GetProperties()</link> D-Bus method on @proxy.
1198  * 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.
1199  * You can then call org_ofono_voice_call_manager_call_get_properties_finish() to get the result of the operation.
1200  *
1201  * See org_ofono_voice_call_manager_call_get_properties_sync() for the synchronous, blocking version of this method.
1202  */
1203 void
1204 org_ofono_voice_call_manager_call_get_properties (
1205     OrgOfonoVoiceCallManager *proxy,
1206     GCancellable *cancellable,
1207     GAsyncReadyCallback callback,
1208     gpointer user_data)
1209 {
1210   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1211     "GetProperties",
1212     g_variant_new ("()"),
1213     G_DBUS_CALL_FLAGS_NONE,
1214     -1,
1215     cancellable,
1216     callback,
1217     user_data);
1218 }
1219
1220 /**
1221  * org_ofono_voice_call_manager_call_get_properties_finish:
1222  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1223  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1224  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_get_properties().
1225  * @error: Return location for error or %NULL.
1226  *
1227  * Finishes an operation started with org_ofono_voice_call_manager_call_get_properties().
1228  *
1229  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1230  */
1231 gboolean
1232 org_ofono_voice_call_manager_call_get_properties_finish (
1233     OrgOfonoVoiceCallManager *proxy,
1234     GVariant **out_unnamed_arg0,
1235     GAsyncResult *res,
1236     GError **error)
1237 {
1238   GVariant *_ret;
1239   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1240   if (_ret == NULL)
1241     goto _out;
1242   g_variant_get (_ret,
1243                  "(@a{sv})",
1244                  out_unnamed_arg0);
1245   g_variant_unref (_ret);
1246 _out:
1247   return _ret != NULL;
1248 }
1249
1250 /**
1251  * org_ofono_voice_call_manager_call_get_properties_sync:
1252  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1253  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1254  * @cancellable: (allow-none): A #GCancellable or %NULL.
1255  * @error: Return location for error or %NULL.
1256  *
1257  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetProperties">GetProperties()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1258  *
1259  * See org_ofono_voice_call_manager_call_get_properties() for the asynchronous version of this method.
1260  *
1261  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1262  */
1263 gboolean
1264 org_ofono_voice_call_manager_call_get_properties_sync (
1265     OrgOfonoVoiceCallManager *proxy,
1266     GVariant **out_unnamed_arg0,
1267     GCancellable *cancellable,
1268     GError **error)
1269 {
1270   GVariant *_ret;
1271   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1272     "GetProperties",
1273     g_variant_new ("()"),
1274     G_DBUS_CALL_FLAGS_NONE,
1275     -1,
1276     cancellable,
1277     error);
1278   if (_ret == NULL)
1279     goto _out;
1280   g_variant_get (_ret,
1281                  "(@a{sv})",
1282                  out_unnamed_arg0);
1283   g_variant_unref (_ret);
1284 _out:
1285   return _ret != NULL;
1286 }
1287
1288 /**
1289  * org_ofono_voice_call_manager_call_dial:
1290  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1291  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1292  * @arg_unnamed_arg1: Argument to pass with the method invocation.
1293  * @cancellable: (allow-none): A #GCancellable or %NULL.
1294  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1295  * @user_data: User data to pass to @callback.
1296  *
1297  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Dial">Dial()</link> D-Bus method on @proxy.
1298  * 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.
1299  * You can then call org_ofono_voice_call_manager_call_dial_finish() to get the result of the operation.
1300  *
1301  * See org_ofono_voice_call_manager_call_dial_sync() for the synchronous, blocking version of this method.
1302  */
1303 void
1304 org_ofono_voice_call_manager_call_dial (
1305     OrgOfonoVoiceCallManager *proxy,
1306     const gchar *arg_unnamed_arg0,
1307     const gchar *arg_unnamed_arg1,
1308     GCancellable *cancellable,
1309     GAsyncReadyCallback callback,
1310     gpointer user_data)
1311 {
1312   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1313     "Dial",
1314     g_variant_new ("(ss)",
1315                    arg_unnamed_arg0,
1316                    arg_unnamed_arg1),
1317     G_DBUS_CALL_FLAGS_NONE,
1318     -1,
1319     cancellable,
1320     callback,
1321     user_data);
1322 }
1323
1324 /**
1325  * org_ofono_voice_call_manager_call_dial_finish:
1326  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1327  * @out_unnamed_arg2: (out): Return location for return parameter or %NULL to ignore.
1328  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_dial().
1329  * @error: Return location for error or %NULL.
1330  *
1331  * Finishes an operation started with org_ofono_voice_call_manager_call_dial().
1332  *
1333  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1334  */
1335 gboolean
1336 org_ofono_voice_call_manager_call_dial_finish (
1337     OrgOfonoVoiceCallManager *proxy,
1338     gchar **out_unnamed_arg2,
1339     GAsyncResult *res,
1340     GError **error)
1341 {
1342   GVariant *_ret;
1343   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1344   if (_ret == NULL)
1345     goto _out;
1346   g_variant_get (_ret,
1347                  "(o)",
1348                  out_unnamed_arg2);
1349   g_variant_unref (_ret);
1350 _out:
1351   return _ret != NULL;
1352 }
1353
1354 /**
1355  * org_ofono_voice_call_manager_call_dial_sync:
1356  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1357  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1358  * @arg_unnamed_arg1: Argument to pass with the method invocation.
1359  * @out_unnamed_arg2: (out): Return location for return parameter or %NULL to ignore.
1360  * @cancellable: (allow-none): A #GCancellable or %NULL.
1361  * @error: Return location for error or %NULL.
1362  *
1363  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Dial">Dial()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1364  *
1365  * See org_ofono_voice_call_manager_call_dial() for the asynchronous version of this method.
1366  *
1367  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1368  */
1369 gboolean
1370 org_ofono_voice_call_manager_call_dial_sync (
1371     OrgOfonoVoiceCallManager *proxy,
1372     const gchar *arg_unnamed_arg0,
1373     const gchar *arg_unnamed_arg1,
1374     gchar **out_unnamed_arg2,
1375     GCancellable *cancellable,
1376     GError **error)
1377 {
1378   GVariant *_ret;
1379   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1380     "Dial",
1381     g_variant_new ("(ss)",
1382                    arg_unnamed_arg0,
1383                    arg_unnamed_arg1),
1384     G_DBUS_CALL_FLAGS_NONE,
1385     -1,
1386     cancellable,
1387     error);
1388   if (_ret == NULL)
1389     goto _out;
1390   g_variant_get (_ret,
1391                  "(o)",
1392                  out_unnamed_arg2);
1393   g_variant_unref (_ret);
1394 _out:
1395   return _ret != NULL;
1396 }
1397
1398 /**
1399  * org_ofono_voice_call_manager_call_transfer:
1400  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1401  * @cancellable: (allow-none): A #GCancellable or %NULL.
1402  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1403  * @user_data: User data to pass to @callback.
1404  *
1405  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Transfer">Transfer()</link> D-Bus method on @proxy.
1406  * 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.
1407  * You can then call org_ofono_voice_call_manager_call_transfer_finish() to get the result of the operation.
1408  *
1409  * See org_ofono_voice_call_manager_call_transfer_sync() for the synchronous, blocking version of this method.
1410  */
1411 void
1412 org_ofono_voice_call_manager_call_transfer (
1413     OrgOfonoVoiceCallManager *proxy,
1414     GCancellable *cancellable,
1415     GAsyncReadyCallback callback,
1416     gpointer user_data)
1417 {
1418   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1419     "Transfer",
1420     g_variant_new ("()"),
1421     G_DBUS_CALL_FLAGS_NONE,
1422     -1,
1423     cancellable,
1424     callback,
1425     user_data);
1426 }
1427
1428 /**
1429  * org_ofono_voice_call_manager_call_transfer_finish:
1430  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1431  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_transfer().
1432  * @error: Return location for error or %NULL.
1433  *
1434  * Finishes an operation started with org_ofono_voice_call_manager_call_transfer().
1435  *
1436  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1437  */
1438 gboolean
1439 org_ofono_voice_call_manager_call_transfer_finish (
1440     OrgOfonoVoiceCallManager *proxy,
1441     GAsyncResult *res,
1442     GError **error)
1443 {
1444   GVariant *_ret;
1445   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1446   if (_ret == NULL)
1447     goto _out;
1448   g_variant_get (_ret,
1449                  "()");
1450   g_variant_unref (_ret);
1451 _out:
1452   return _ret != NULL;
1453 }
1454
1455 /**
1456  * org_ofono_voice_call_manager_call_transfer_sync:
1457  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1458  * @cancellable: (allow-none): A #GCancellable or %NULL.
1459  * @error: Return location for error or %NULL.
1460  *
1461  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Transfer">Transfer()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1462  *
1463  * See org_ofono_voice_call_manager_call_transfer() for the asynchronous version of this method.
1464  *
1465  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1466  */
1467 gboolean
1468 org_ofono_voice_call_manager_call_transfer_sync (
1469     OrgOfonoVoiceCallManager *proxy,
1470     GCancellable *cancellable,
1471     GError **error)
1472 {
1473   GVariant *_ret;
1474   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1475     "Transfer",
1476     g_variant_new ("()"),
1477     G_DBUS_CALL_FLAGS_NONE,
1478     -1,
1479     cancellable,
1480     error);
1481   if (_ret == NULL)
1482     goto _out;
1483   g_variant_get (_ret,
1484                  "()");
1485   g_variant_unref (_ret);
1486 _out:
1487   return _ret != NULL;
1488 }
1489
1490 /**
1491  * org_ofono_voice_call_manager_call_swap_calls:
1492  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1493  * @cancellable: (allow-none): A #GCancellable or %NULL.
1494  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1495  * @user_data: User data to pass to @callback.
1496  *
1497  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SwapCalls">SwapCalls()</link> D-Bus method on @proxy.
1498  * 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.
1499  * You can then call org_ofono_voice_call_manager_call_swap_calls_finish() to get the result of the operation.
1500  *
1501  * See org_ofono_voice_call_manager_call_swap_calls_sync() for the synchronous, blocking version of this method.
1502  */
1503 void
1504 org_ofono_voice_call_manager_call_swap_calls (
1505     OrgOfonoVoiceCallManager *proxy,
1506     GCancellable *cancellable,
1507     GAsyncReadyCallback callback,
1508     gpointer user_data)
1509 {
1510   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1511     "SwapCalls",
1512     g_variant_new ("()"),
1513     G_DBUS_CALL_FLAGS_NONE,
1514     -1,
1515     cancellable,
1516     callback,
1517     user_data);
1518 }
1519
1520 /**
1521  * org_ofono_voice_call_manager_call_swap_calls_finish:
1522  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1523  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_swap_calls().
1524  * @error: Return location for error or %NULL.
1525  *
1526  * Finishes an operation started with org_ofono_voice_call_manager_call_swap_calls().
1527  *
1528  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1529  */
1530 gboolean
1531 org_ofono_voice_call_manager_call_swap_calls_finish (
1532     OrgOfonoVoiceCallManager *proxy,
1533     GAsyncResult *res,
1534     GError **error)
1535 {
1536   GVariant *_ret;
1537   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1538   if (_ret == NULL)
1539     goto _out;
1540   g_variant_get (_ret,
1541                  "()");
1542   g_variant_unref (_ret);
1543 _out:
1544   return _ret != NULL;
1545 }
1546
1547 /**
1548  * org_ofono_voice_call_manager_call_swap_calls_sync:
1549  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1550  * @cancellable: (allow-none): A #GCancellable or %NULL.
1551  * @error: Return location for error or %NULL.
1552  *
1553  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SwapCalls">SwapCalls()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1554  *
1555  * See org_ofono_voice_call_manager_call_swap_calls() for the asynchronous version of this method.
1556  *
1557  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1558  */
1559 gboolean
1560 org_ofono_voice_call_manager_call_swap_calls_sync (
1561     OrgOfonoVoiceCallManager *proxy,
1562     GCancellable *cancellable,
1563     GError **error)
1564 {
1565   GVariant *_ret;
1566   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1567     "SwapCalls",
1568     g_variant_new ("()"),
1569     G_DBUS_CALL_FLAGS_NONE,
1570     -1,
1571     cancellable,
1572     error);
1573   if (_ret == NULL)
1574     goto _out;
1575   g_variant_get (_ret,
1576                  "()");
1577   g_variant_unref (_ret);
1578 _out:
1579   return _ret != NULL;
1580 }
1581
1582 /**
1583  * org_ofono_voice_call_manager_call_release_and_answer:
1584  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1585  * @cancellable: (allow-none): A #GCancellable or %NULL.
1586  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1587  * @user_data: User data to pass to @callback.
1588  *
1589  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.ReleaseAndAnswer">ReleaseAndAnswer()</link> D-Bus method on @proxy.
1590  * 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.
1591  * You can then call org_ofono_voice_call_manager_call_release_and_answer_finish() to get the result of the operation.
1592  *
1593  * See org_ofono_voice_call_manager_call_release_and_answer_sync() for the synchronous, blocking version of this method.
1594  */
1595 void
1596 org_ofono_voice_call_manager_call_release_and_answer (
1597     OrgOfonoVoiceCallManager *proxy,
1598     GCancellable *cancellable,
1599     GAsyncReadyCallback callback,
1600     gpointer user_data)
1601 {
1602   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1603     "ReleaseAndAnswer",
1604     g_variant_new ("()"),
1605     G_DBUS_CALL_FLAGS_NONE,
1606     -1,
1607     cancellable,
1608     callback,
1609     user_data);
1610 }
1611
1612 /**
1613  * org_ofono_voice_call_manager_call_release_and_answer_finish:
1614  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1615  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_release_and_answer().
1616  * @error: Return location for error or %NULL.
1617  *
1618  * Finishes an operation started with org_ofono_voice_call_manager_call_release_and_answer().
1619  *
1620  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1621  */
1622 gboolean
1623 org_ofono_voice_call_manager_call_release_and_answer_finish (
1624     OrgOfonoVoiceCallManager *proxy,
1625     GAsyncResult *res,
1626     GError **error)
1627 {
1628   GVariant *_ret;
1629   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1630   if (_ret == NULL)
1631     goto _out;
1632   g_variant_get (_ret,
1633                  "()");
1634   g_variant_unref (_ret);
1635 _out:
1636   return _ret != NULL;
1637 }
1638
1639 /**
1640  * org_ofono_voice_call_manager_call_release_and_answer_sync:
1641  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1642  * @cancellable: (allow-none): A #GCancellable or %NULL.
1643  * @error: Return location for error or %NULL.
1644  *
1645  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.ReleaseAndAnswer">ReleaseAndAnswer()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1646  *
1647  * See org_ofono_voice_call_manager_call_release_and_answer() for the asynchronous version of this method.
1648  *
1649  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1650  */
1651 gboolean
1652 org_ofono_voice_call_manager_call_release_and_answer_sync (
1653     OrgOfonoVoiceCallManager *proxy,
1654     GCancellable *cancellable,
1655     GError **error)
1656 {
1657   GVariant *_ret;
1658   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1659     "ReleaseAndAnswer",
1660     g_variant_new ("()"),
1661     G_DBUS_CALL_FLAGS_NONE,
1662     -1,
1663     cancellable,
1664     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_ofono_voice_call_manager_call_hold_and_answer:
1676  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1677  * @cancellable: (allow-none): A #GCancellable or %NULL.
1678  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1679  * @user_data: User data to pass to @callback.
1680  *
1681  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HoldAndAnswer">HoldAndAnswer()</link> D-Bus method on @proxy.
1682  * 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.
1683  * You can then call org_ofono_voice_call_manager_call_hold_and_answer_finish() to get the result of the operation.
1684  *
1685  * See org_ofono_voice_call_manager_call_hold_and_answer_sync() for the synchronous, blocking version of this method.
1686  */
1687 void
1688 org_ofono_voice_call_manager_call_hold_and_answer (
1689     OrgOfonoVoiceCallManager *proxy,
1690     GCancellable *cancellable,
1691     GAsyncReadyCallback callback,
1692     gpointer user_data)
1693 {
1694   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1695     "HoldAndAnswer",
1696     g_variant_new ("()"),
1697     G_DBUS_CALL_FLAGS_NONE,
1698     -1,
1699     cancellable,
1700     callback,
1701     user_data);
1702 }
1703
1704 /**
1705  * org_ofono_voice_call_manager_call_hold_and_answer_finish:
1706  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1707  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_hold_and_answer().
1708  * @error: Return location for error or %NULL.
1709  *
1710  * Finishes an operation started with org_ofono_voice_call_manager_call_hold_and_answer().
1711  *
1712  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1713  */
1714 gboolean
1715 org_ofono_voice_call_manager_call_hold_and_answer_finish (
1716     OrgOfonoVoiceCallManager *proxy,
1717     GAsyncResult *res,
1718     GError **error)
1719 {
1720   GVariant *_ret;
1721   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1722   if (_ret == NULL)
1723     goto _out;
1724   g_variant_get (_ret,
1725                  "()");
1726   g_variant_unref (_ret);
1727 _out:
1728   return _ret != NULL;
1729 }
1730
1731 /**
1732  * org_ofono_voice_call_manager_call_hold_and_answer_sync:
1733  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1734  * @cancellable: (allow-none): A #GCancellable or %NULL.
1735  * @error: Return location for error or %NULL.
1736  *
1737  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HoldAndAnswer">HoldAndAnswer()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1738  *
1739  * See org_ofono_voice_call_manager_call_hold_and_answer() for the asynchronous version of this method.
1740  *
1741  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1742  */
1743 gboolean
1744 org_ofono_voice_call_manager_call_hold_and_answer_sync (
1745     OrgOfonoVoiceCallManager *proxy,
1746     GCancellable *cancellable,
1747     GError **error)
1748 {
1749   GVariant *_ret;
1750   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1751     "HoldAndAnswer",
1752     g_variant_new ("()"),
1753     G_DBUS_CALL_FLAGS_NONE,
1754     -1,
1755     cancellable,
1756     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_ofono_voice_call_manager_call_hangup_all:
1768  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1769  * @cancellable: (allow-none): A #GCancellable or %NULL.
1770  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1771  * @user_data: User data to pass to @callback.
1772  *
1773  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupAll">HangupAll()</link> D-Bus method on @proxy.
1774  * 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.
1775  * You can then call org_ofono_voice_call_manager_call_hangup_all_finish() to get the result of the operation.
1776  *
1777  * See org_ofono_voice_call_manager_call_hangup_all_sync() for the synchronous, blocking version of this method.
1778  */
1779 void
1780 org_ofono_voice_call_manager_call_hangup_all (
1781     OrgOfonoVoiceCallManager *proxy,
1782     GCancellable *cancellable,
1783     GAsyncReadyCallback callback,
1784     gpointer user_data)
1785 {
1786   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1787     "HangupAll",
1788     g_variant_new ("()"),
1789     G_DBUS_CALL_FLAGS_NONE,
1790     -1,
1791     cancellable,
1792     callback,
1793     user_data);
1794 }
1795
1796 /**
1797  * org_ofono_voice_call_manager_call_hangup_all_finish:
1798  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1799  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_hangup_all().
1800  * @error: Return location for error or %NULL.
1801  *
1802  * Finishes an operation started with org_ofono_voice_call_manager_call_hangup_all().
1803  *
1804  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1805  */
1806 gboolean
1807 org_ofono_voice_call_manager_call_hangup_all_finish (
1808     OrgOfonoVoiceCallManager *proxy,
1809     GAsyncResult *res,
1810     GError **error)
1811 {
1812   GVariant *_ret;
1813   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1814   if (_ret == NULL)
1815     goto _out;
1816   g_variant_get (_ret,
1817                  "()");
1818   g_variant_unref (_ret);
1819 _out:
1820   return _ret != NULL;
1821 }
1822
1823 /**
1824  * org_ofono_voice_call_manager_call_hangup_all_sync:
1825  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1826  * @cancellable: (allow-none): A #GCancellable or %NULL.
1827  * @error: Return location for error or %NULL.
1828  *
1829  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupAll">HangupAll()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1830  *
1831  * See org_ofono_voice_call_manager_call_hangup_all() for the asynchronous version of this method.
1832  *
1833  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1834  */
1835 gboolean
1836 org_ofono_voice_call_manager_call_hangup_all_sync (
1837     OrgOfonoVoiceCallManager *proxy,
1838     GCancellable *cancellable,
1839     GError **error)
1840 {
1841   GVariant *_ret;
1842   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1843     "HangupAll",
1844     g_variant_new ("()"),
1845     G_DBUS_CALL_FLAGS_NONE,
1846     -1,
1847     cancellable,
1848     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_ofono_voice_call_manager_call_private_chat:
1860  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1861  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1862  * @cancellable: (allow-none): A #GCancellable or %NULL.
1863  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1864  * @user_data: User data to pass to @callback.
1865  *
1866  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.PrivateChat">PrivateChat()</link> D-Bus method on @proxy.
1867  * 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.
1868  * You can then call org_ofono_voice_call_manager_call_private_chat_finish() to get the result of the operation.
1869  *
1870  * See org_ofono_voice_call_manager_call_private_chat_sync() for the synchronous, blocking version of this method.
1871  */
1872 void
1873 org_ofono_voice_call_manager_call_private_chat (
1874     OrgOfonoVoiceCallManager *proxy,
1875     const gchar *arg_unnamed_arg0,
1876     GCancellable *cancellable,
1877     GAsyncReadyCallback callback,
1878     gpointer user_data)
1879 {
1880   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1881     "PrivateChat",
1882     g_variant_new ("(o)",
1883                    arg_unnamed_arg0),
1884     G_DBUS_CALL_FLAGS_NONE,
1885     -1,
1886     cancellable,
1887     callback,
1888     user_data);
1889 }
1890
1891 /**
1892  * org_ofono_voice_call_manager_call_private_chat_finish:
1893  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1894  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
1895  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_private_chat().
1896  * @error: Return location for error or %NULL.
1897  *
1898  * Finishes an operation started with org_ofono_voice_call_manager_call_private_chat().
1899  *
1900  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1901  */
1902 gboolean
1903 org_ofono_voice_call_manager_call_private_chat_finish (
1904     OrgOfonoVoiceCallManager *proxy,
1905     gchar ***out_unnamed_arg1,
1906     GAsyncResult *res,
1907     GError **error)
1908 {
1909   GVariant *_ret;
1910   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1911   if (_ret == NULL)
1912     goto _out;
1913   g_variant_get (_ret,
1914                  "(^ao)",
1915                  out_unnamed_arg1);
1916   g_variant_unref (_ret);
1917 _out:
1918   return _ret != NULL;
1919 }
1920
1921 /**
1922  * org_ofono_voice_call_manager_call_private_chat_sync:
1923  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1924  * @arg_unnamed_arg0: Argument to pass with the method invocation.
1925  * @out_unnamed_arg1: (out): Return location for return parameter or %NULL to ignore.
1926  * @cancellable: (allow-none): A #GCancellable or %NULL.
1927  * @error: Return location for error or %NULL.
1928  *
1929  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.PrivateChat">PrivateChat()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1930  *
1931  * See org_ofono_voice_call_manager_call_private_chat() for the asynchronous version of this method.
1932  *
1933  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1934  */
1935 gboolean
1936 org_ofono_voice_call_manager_call_private_chat_sync (
1937     OrgOfonoVoiceCallManager *proxy,
1938     const gchar *arg_unnamed_arg0,
1939     gchar ***out_unnamed_arg1,
1940     GCancellable *cancellable,
1941     GError **error)
1942 {
1943   GVariant *_ret;
1944   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1945     "PrivateChat",
1946     g_variant_new ("(o)",
1947                    arg_unnamed_arg0),
1948     G_DBUS_CALL_FLAGS_NONE,
1949     -1,
1950     cancellable,
1951     error);
1952   if (_ret == NULL)
1953     goto _out;
1954   g_variant_get (_ret,
1955                  "(^ao)",
1956                  out_unnamed_arg1);
1957   g_variant_unref (_ret);
1958 _out:
1959   return _ret != NULL;
1960 }
1961
1962 /**
1963  * org_ofono_voice_call_manager_call_create_multiparty:
1964  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1965  * @cancellable: (allow-none): A #GCancellable or %NULL.
1966  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1967  * @user_data: User data to pass to @callback.
1968  *
1969  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.CreateMultiparty">CreateMultiparty()</link> D-Bus method on @proxy.
1970  * 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.
1971  * You can then call org_ofono_voice_call_manager_call_create_multiparty_finish() to get the result of the operation.
1972  *
1973  * See org_ofono_voice_call_manager_call_create_multiparty_sync() for the synchronous, blocking version of this method.
1974  */
1975 void
1976 org_ofono_voice_call_manager_call_create_multiparty (
1977     OrgOfonoVoiceCallManager *proxy,
1978     GCancellable *cancellable,
1979     GAsyncReadyCallback callback,
1980     gpointer user_data)
1981 {
1982   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1983     "CreateMultiparty",
1984     g_variant_new ("()"),
1985     G_DBUS_CALL_FLAGS_NONE,
1986     -1,
1987     cancellable,
1988     callback,
1989     user_data);
1990 }
1991
1992 /**
1993  * org_ofono_voice_call_manager_call_create_multiparty_finish:
1994  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
1995  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
1996  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_create_multiparty().
1997  * @error: Return location for error or %NULL.
1998  *
1999  * Finishes an operation started with org_ofono_voice_call_manager_call_create_multiparty().
2000  *
2001  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2002  */
2003 gboolean
2004 org_ofono_voice_call_manager_call_create_multiparty_finish (
2005     OrgOfonoVoiceCallManager *proxy,
2006     gchar ***out_unnamed_arg0,
2007     GAsyncResult *res,
2008     GError **error)
2009 {
2010   GVariant *_ret;
2011   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2012   if (_ret == NULL)
2013     goto _out;
2014   g_variant_get (_ret,
2015                  "(^ao)",
2016                  out_unnamed_arg0);
2017   g_variant_unref (_ret);
2018 _out:
2019   return _ret != NULL;
2020 }
2021
2022 /**
2023  * org_ofono_voice_call_manager_call_create_multiparty_sync:
2024  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2025  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
2026  * @cancellable: (allow-none): A #GCancellable or %NULL.
2027  * @error: Return location for error or %NULL.
2028  *
2029  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.CreateMultiparty">CreateMultiparty()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2030  *
2031  * See org_ofono_voice_call_manager_call_create_multiparty() for the asynchronous version of this method.
2032  *
2033  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2034  */
2035 gboolean
2036 org_ofono_voice_call_manager_call_create_multiparty_sync (
2037     OrgOfonoVoiceCallManager *proxy,
2038     gchar ***out_unnamed_arg0,
2039     GCancellable *cancellable,
2040     GError **error)
2041 {
2042   GVariant *_ret;
2043   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2044     "CreateMultiparty",
2045     g_variant_new ("()"),
2046     G_DBUS_CALL_FLAGS_NONE,
2047     -1,
2048     cancellable,
2049     error);
2050   if (_ret == NULL)
2051     goto _out;
2052   g_variant_get (_ret,
2053                  "(^ao)",
2054                  out_unnamed_arg0);
2055   g_variant_unref (_ret);
2056 _out:
2057   return _ret != NULL;
2058 }
2059
2060 /**
2061  * org_ofono_voice_call_manager_call_hangup_multiparty:
2062  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2063  * @cancellable: (allow-none): A #GCancellable or %NULL.
2064  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2065  * @user_data: User data to pass to @callback.
2066  *
2067  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupMultiparty">HangupMultiparty()</link> D-Bus method on @proxy.
2068  * 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.
2069  * You can then call org_ofono_voice_call_manager_call_hangup_multiparty_finish() to get the result of the operation.
2070  *
2071  * See org_ofono_voice_call_manager_call_hangup_multiparty_sync() for the synchronous, blocking version of this method.
2072  */
2073 void
2074 org_ofono_voice_call_manager_call_hangup_multiparty (
2075     OrgOfonoVoiceCallManager *proxy,
2076     GCancellable *cancellable,
2077     GAsyncReadyCallback callback,
2078     gpointer user_data)
2079 {
2080   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2081     "HangupMultiparty",
2082     g_variant_new ("()"),
2083     G_DBUS_CALL_FLAGS_NONE,
2084     -1,
2085     cancellable,
2086     callback,
2087     user_data);
2088 }
2089
2090 /**
2091  * org_ofono_voice_call_manager_call_hangup_multiparty_finish:
2092  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2093  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_hangup_multiparty().
2094  * @error: Return location for error or %NULL.
2095  *
2096  * Finishes an operation started with org_ofono_voice_call_manager_call_hangup_multiparty().
2097  *
2098  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2099  */
2100 gboolean
2101 org_ofono_voice_call_manager_call_hangup_multiparty_finish (
2102     OrgOfonoVoiceCallManager *proxy,
2103     GAsyncResult *res,
2104     GError **error)
2105 {
2106   GVariant *_ret;
2107   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2108   if (_ret == NULL)
2109     goto _out;
2110   g_variant_get (_ret,
2111                  "()");
2112   g_variant_unref (_ret);
2113 _out:
2114   return _ret != NULL;
2115 }
2116
2117 /**
2118  * org_ofono_voice_call_manager_call_hangup_multiparty_sync:
2119  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2120  * @cancellable: (allow-none): A #GCancellable or %NULL.
2121  * @error: Return location for error or %NULL.
2122  *
2123  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupMultiparty">HangupMultiparty()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2124  *
2125  * See org_ofono_voice_call_manager_call_hangup_multiparty() for the asynchronous version of this method.
2126  *
2127  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2128  */
2129 gboolean
2130 org_ofono_voice_call_manager_call_hangup_multiparty_sync (
2131     OrgOfonoVoiceCallManager *proxy,
2132     GCancellable *cancellable,
2133     GError **error)
2134 {
2135   GVariant *_ret;
2136   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2137     "HangupMultiparty",
2138     g_variant_new ("()"),
2139     G_DBUS_CALL_FLAGS_NONE,
2140     -1,
2141     cancellable,
2142     error);
2143   if (_ret == NULL)
2144     goto _out;
2145   g_variant_get (_ret,
2146                  "()");
2147   g_variant_unref (_ret);
2148 _out:
2149   return _ret != NULL;
2150 }
2151
2152 /**
2153  * org_ofono_voice_call_manager_call_send_tones:
2154  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2155  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2156  * @cancellable: (allow-none): A #GCancellable or %NULL.
2157  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2158  * @user_data: User data to pass to @callback.
2159  *
2160  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SendTones">SendTones()</link> D-Bus method on @proxy.
2161  * 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.
2162  * You can then call org_ofono_voice_call_manager_call_send_tones_finish() to get the result of the operation.
2163  *
2164  * See org_ofono_voice_call_manager_call_send_tones_sync() for the synchronous, blocking version of this method.
2165  */
2166 void
2167 org_ofono_voice_call_manager_call_send_tones (
2168     OrgOfonoVoiceCallManager *proxy,
2169     const gchar *arg_unnamed_arg0,
2170     GCancellable *cancellable,
2171     GAsyncReadyCallback callback,
2172     gpointer user_data)
2173 {
2174   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2175     "SendTones",
2176     g_variant_new ("(s)",
2177                    arg_unnamed_arg0),
2178     G_DBUS_CALL_FLAGS_NONE,
2179     -1,
2180     cancellable,
2181     callback,
2182     user_data);
2183 }
2184
2185 /**
2186  * org_ofono_voice_call_manager_call_send_tones_finish:
2187  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2188  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_send_tones().
2189  * @error: Return location for error or %NULL.
2190  *
2191  * Finishes an operation started with org_ofono_voice_call_manager_call_send_tones().
2192  *
2193  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2194  */
2195 gboolean
2196 org_ofono_voice_call_manager_call_send_tones_finish (
2197     OrgOfonoVoiceCallManager *proxy,
2198     GAsyncResult *res,
2199     GError **error)
2200 {
2201   GVariant *_ret;
2202   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2203   if (_ret == NULL)
2204     goto _out;
2205   g_variant_get (_ret,
2206                  "()");
2207   g_variant_unref (_ret);
2208 _out:
2209   return _ret != NULL;
2210 }
2211
2212 /**
2213  * org_ofono_voice_call_manager_call_send_tones_sync:
2214  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2215  * @arg_unnamed_arg0: Argument to pass with the method invocation.
2216  * @cancellable: (allow-none): A #GCancellable or %NULL.
2217  * @error: Return location for error or %NULL.
2218  *
2219  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SendTones">SendTones()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2220  *
2221  * See org_ofono_voice_call_manager_call_send_tones() for the asynchronous version of this method.
2222  *
2223  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2224  */
2225 gboolean
2226 org_ofono_voice_call_manager_call_send_tones_sync (
2227     OrgOfonoVoiceCallManager *proxy,
2228     const gchar *arg_unnamed_arg0,
2229     GCancellable *cancellable,
2230     GError **error)
2231 {
2232   GVariant *_ret;
2233   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2234     "SendTones",
2235     g_variant_new ("(s)",
2236                    arg_unnamed_arg0),
2237     G_DBUS_CALL_FLAGS_NONE,
2238     -1,
2239     cancellable,
2240     error);
2241   if (_ret == NULL)
2242     goto _out;
2243   g_variant_get (_ret,
2244                  "()");
2245   g_variant_unref (_ret);
2246 _out:
2247   return _ret != NULL;
2248 }
2249
2250 /**
2251  * org_ofono_voice_call_manager_call_get_calls:
2252  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2253  * @cancellable: (allow-none): A #GCancellable or %NULL.
2254  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
2255  * @user_data: User data to pass to @callback.
2256  *
2257  * Asynchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetCalls">GetCalls()</link> D-Bus method on @proxy.
2258  * 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.
2259  * You can then call org_ofono_voice_call_manager_call_get_calls_finish() to get the result of the operation.
2260  *
2261  * See org_ofono_voice_call_manager_call_get_calls_sync() for the synchronous, blocking version of this method.
2262  */
2263 void
2264 org_ofono_voice_call_manager_call_get_calls (
2265     OrgOfonoVoiceCallManager *proxy,
2266     GCancellable *cancellable,
2267     GAsyncReadyCallback callback,
2268     gpointer user_data)
2269 {
2270   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
2271     "GetCalls",
2272     g_variant_new ("()"),
2273     G_DBUS_CALL_FLAGS_NONE,
2274     -1,
2275     cancellable,
2276     callback,
2277     user_data);
2278 }
2279
2280 /**
2281  * org_ofono_voice_call_manager_call_get_calls_finish:
2282  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2283  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
2284  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_call_get_calls().
2285  * @error: Return location for error or %NULL.
2286  *
2287  * Finishes an operation started with org_ofono_voice_call_manager_call_get_calls().
2288  *
2289  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2290  */
2291 gboolean
2292 org_ofono_voice_call_manager_call_get_calls_finish (
2293     OrgOfonoVoiceCallManager *proxy,
2294     GVariant **out_unnamed_arg0,
2295     GAsyncResult *res,
2296     GError **error)
2297 {
2298   GVariant *_ret;
2299   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
2300   if (_ret == NULL)
2301     goto _out;
2302   g_variant_get (_ret,
2303                  "(@a(oa{sv}))",
2304                  out_unnamed_arg0);
2305   g_variant_unref (_ret);
2306 _out:
2307   return _ret != NULL;
2308 }
2309
2310 /**
2311  * org_ofono_voice_call_manager_call_get_calls_sync:
2312  * @proxy: A #OrgOfonoVoiceCallManagerProxy.
2313  * @out_unnamed_arg0: (out): Return location for return parameter or %NULL to ignore.
2314  * @cancellable: (allow-none): A #GCancellable or %NULL.
2315  * @error: Return location for error or %NULL.
2316  *
2317  * Synchronously invokes the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetCalls">GetCalls()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
2318  *
2319  * See org_ofono_voice_call_manager_call_get_calls() for the asynchronous version of this method.
2320  *
2321  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
2322  */
2323 gboolean
2324 org_ofono_voice_call_manager_call_get_calls_sync (
2325     OrgOfonoVoiceCallManager *proxy,
2326     GVariant **out_unnamed_arg0,
2327     GCancellable *cancellable,
2328     GError **error)
2329 {
2330   GVariant *_ret;
2331   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
2332     "GetCalls",
2333     g_variant_new ("()"),
2334     G_DBUS_CALL_FLAGS_NONE,
2335     -1,
2336     cancellable,
2337     error);
2338   if (_ret == NULL)
2339     goto _out;
2340   g_variant_get (_ret,
2341                  "(@a(oa{sv}))",
2342                  out_unnamed_arg0);
2343   g_variant_unref (_ret);
2344 _out:
2345   return _ret != NULL;
2346 }
2347
2348 /**
2349  * org_ofono_voice_call_manager_complete_get_properties:
2350  * @object: A #OrgOfonoVoiceCallManager.
2351  * @invocation: (transfer full): A #GDBusMethodInvocation.
2352  * @unnamed_arg0: Parameter to return.
2353  *
2354  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.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.
2355  *
2356  * This method will free @invocation, you cannot use it afterwards.
2357  */
2358 void
2359 org_ofono_voice_call_manager_complete_get_properties (
2360     OrgOfonoVoiceCallManager *object,
2361     GDBusMethodInvocation *invocation,
2362     GVariant *unnamed_arg0)
2363 {
2364   g_dbus_method_invocation_return_value (invocation,
2365     g_variant_new ("(@a{sv})",
2366                    unnamed_arg0));
2367 }
2368
2369 /**
2370  * org_ofono_voice_call_manager_complete_dial:
2371  * @object: A #OrgOfonoVoiceCallManager.
2372  * @invocation: (transfer full): A #GDBusMethodInvocation.
2373  * @unnamed_arg2: Parameter to return.
2374  *
2375  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Dial">Dial()</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.
2376  *
2377  * This method will free @invocation, you cannot use it afterwards.
2378  */
2379 void
2380 org_ofono_voice_call_manager_complete_dial (
2381     OrgOfonoVoiceCallManager *object,
2382     GDBusMethodInvocation *invocation,
2383     const gchar *unnamed_arg2)
2384 {
2385   g_dbus_method_invocation_return_value (invocation,
2386     g_variant_new ("(o)",
2387                    unnamed_arg2));
2388 }
2389
2390 /**
2391  * org_ofono_voice_call_manager_complete_transfer:
2392  * @object: A #OrgOfonoVoiceCallManager.
2393  * @invocation: (transfer full): A #GDBusMethodInvocation.
2394  *
2395  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.Transfer">Transfer()</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.
2396  *
2397  * This method will free @invocation, you cannot use it afterwards.
2398  */
2399 void
2400 org_ofono_voice_call_manager_complete_transfer (
2401     OrgOfonoVoiceCallManager *object,
2402     GDBusMethodInvocation *invocation)
2403 {
2404   g_dbus_method_invocation_return_value (invocation,
2405     g_variant_new ("()"));
2406 }
2407
2408 /**
2409  * org_ofono_voice_call_manager_complete_swap_calls:
2410  * @object: A #OrgOfonoVoiceCallManager.
2411  * @invocation: (transfer full): A #GDBusMethodInvocation.
2412  *
2413  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SwapCalls">SwapCalls()</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.
2414  *
2415  * This method will free @invocation, you cannot use it afterwards.
2416  */
2417 void
2418 org_ofono_voice_call_manager_complete_swap_calls (
2419     OrgOfonoVoiceCallManager *object,
2420     GDBusMethodInvocation *invocation)
2421 {
2422   g_dbus_method_invocation_return_value (invocation,
2423     g_variant_new ("()"));
2424 }
2425
2426 /**
2427  * org_ofono_voice_call_manager_complete_release_and_answer:
2428  * @object: A #OrgOfonoVoiceCallManager.
2429  * @invocation: (transfer full): A #GDBusMethodInvocation.
2430  *
2431  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.ReleaseAndAnswer">ReleaseAndAnswer()</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.
2432  *
2433  * This method will free @invocation, you cannot use it afterwards.
2434  */
2435 void
2436 org_ofono_voice_call_manager_complete_release_and_answer (
2437     OrgOfonoVoiceCallManager *object,
2438     GDBusMethodInvocation *invocation)
2439 {
2440   g_dbus_method_invocation_return_value (invocation,
2441     g_variant_new ("()"));
2442 }
2443
2444 /**
2445  * org_ofono_voice_call_manager_complete_hold_and_answer:
2446  * @object: A #OrgOfonoVoiceCallManager.
2447  * @invocation: (transfer full): A #GDBusMethodInvocation.
2448  *
2449  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HoldAndAnswer">HoldAndAnswer()</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.
2450  *
2451  * This method will free @invocation, you cannot use it afterwards.
2452  */
2453 void
2454 org_ofono_voice_call_manager_complete_hold_and_answer (
2455     OrgOfonoVoiceCallManager *object,
2456     GDBusMethodInvocation *invocation)
2457 {
2458   g_dbus_method_invocation_return_value (invocation,
2459     g_variant_new ("()"));
2460 }
2461
2462 /**
2463  * org_ofono_voice_call_manager_complete_hangup_all:
2464  * @object: A #OrgOfonoVoiceCallManager.
2465  * @invocation: (transfer full): A #GDBusMethodInvocation.
2466  *
2467  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupAll">HangupAll()</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.
2468  *
2469  * This method will free @invocation, you cannot use it afterwards.
2470  */
2471 void
2472 org_ofono_voice_call_manager_complete_hangup_all (
2473     OrgOfonoVoiceCallManager *object,
2474     GDBusMethodInvocation *invocation)
2475 {
2476   g_dbus_method_invocation_return_value (invocation,
2477     g_variant_new ("()"));
2478 }
2479
2480 /**
2481  * org_ofono_voice_call_manager_complete_private_chat:
2482  * @object: A #OrgOfonoVoiceCallManager.
2483  * @invocation: (transfer full): A #GDBusMethodInvocation.
2484  * @unnamed_arg1: Parameter to return.
2485  *
2486  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.PrivateChat">PrivateChat()</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.
2487  *
2488  * This method will free @invocation, you cannot use it afterwards.
2489  */
2490 void
2491 org_ofono_voice_call_manager_complete_private_chat (
2492     OrgOfonoVoiceCallManager *object,
2493     GDBusMethodInvocation *invocation,
2494     const gchar *const *unnamed_arg1)
2495 {
2496   g_dbus_method_invocation_return_value (invocation,
2497     g_variant_new ("(^ao)",
2498                    unnamed_arg1));
2499 }
2500
2501 /**
2502  * org_ofono_voice_call_manager_complete_create_multiparty:
2503  * @object: A #OrgOfonoVoiceCallManager.
2504  * @invocation: (transfer full): A #GDBusMethodInvocation.
2505  * @unnamed_arg0: Parameter to return.
2506  *
2507  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.CreateMultiparty">CreateMultiparty()</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.
2508  *
2509  * This method will free @invocation, you cannot use it afterwards.
2510  */
2511 void
2512 org_ofono_voice_call_manager_complete_create_multiparty (
2513     OrgOfonoVoiceCallManager *object,
2514     GDBusMethodInvocation *invocation,
2515     const gchar *const *unnamed_arg0)
2516 {
2517   g_dbus_method_invocation_return_value (invocation,
2518     g_variant_new ("(^ao)",
2519                    unnamed_arg0));
2520 }
2521
2522 /**
2523  * org_ofono_voice_call_manager_complete_hangup_multiparty:
2524  * @object: A #OrgOfonoVoiceCallManager.
2525  * @invocation: (transfer full): A #GDBusMethodInvocation.
2526  *
2527  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.HangupMultiparty">HangupMultiparty()</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.
2528  *
2529  * This method will free @invocation, you cannot use it afterwards.
2530  */
2531 void
2532 org_ofono_voice_call_manager_complete_hangup_multiparty (
2533     OrgOfonoVoiceCallManager *object,
2534     GDBusMethodInvocation *invocation)
2535 {
2536   g_dbus_method_invocation_return_value (invocation,
2537     g_variant_new ("()"));
2538 }
2539
2540 /**
2541  * org_ofono_voice_call_manager_complete_send_tones:
2542  * @object: A #OrgOfonoVoiceCallManager.
2543  * @invocation: (transfer full): A #GDBusMethodInvocation.
2544  *
2545  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.SendTones">SendTones()</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.
2546  *
2547  * This method will free @invocation, you cannot use it afterwards.
2548  */
2549 void
2550 org_ofono_voice_call_manager_complete_send_tones (
2551     OrgOfonoVoiceCallManager *object,
2552     GDBusMethodInvocation *invocation)
2553 {
2554   g_dbus_method_invocation_return_value (invocation,
2555     g_variant_new ("()"));
2556 }
2557
2558 /**
2559  * org_ofono_voice_call_manager_complete_get_calls:
2560  * @object: A #OrgOfonoVoiceCallManager.
2561  * @invocation: (transfer full): A #GDBusMethodInvocation.
2562  * @unnamed_arg0: Parameter to return.
2563  *
2564  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-ofono-VoiceCallManager.GetCalls">GetCalls()</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.
2565  *
2566  * This method will free @invocation, you cannot use it afterwards.
2567  */
2568 void
2569 org_ofono_voice_call_manager_complete_get_calls (
2570     OrgOfonoVoiceCallManager *object,
2571     GDBusMethodInvocation *invocation,
2572     GVariant *unnamed_arg0)
2573 {
2574   g_dbus_method_invocation_return_value (invocation,
2575     g_variant_new ("(@a(oa{sv}))",
2576                    unnamed_arg0));
2577 }
2578
2579 /* ------------------------------------------------------------------------ */
2580
2581 /**
2582  * OrgOfonoVoiceCallManagerProxy:
2583  *
2584  * The #OrgOfonoVoiceCallManagerProxy structure contains only private data and should only be accessed using the provided API.
2585  */
2586
2587 /**
2588  * OrgOfonoVoiceCallManagerProxyClass:
2589  * @parent_class: The parent class.
2590  *
2591  * Class structure for #OrgOfonoVoiceCallManagerProxy.
2592  */
2593
2594 struct _OrgOfonoVoiceCallManagerProxyPrivate
2595 {
2596   GData *qdata;
2597 };
2598
2599 static void org_ofono_voice_call_manager_proxy_iface_init (OrgOfonoVoiceCallManagerIface *iface);
2600
2601 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2602 G_DEFINE_TYPE_WITH_CODE (OrgOfonoVoiceCallManagerProxy, org_ofono_voice_call_manager_proxy, G_TYPE_DBUS_PROXY,
2603                          G_ADD_PRIVATE (OrgOfonoVoiceCallManagerProxy)
2604                          G_IMPLEMENT_INTERFACE (TYPE_ORG_OFONO_VOICE_CALL_MANAGER, org_ofono_voice_call_manager_proxy_iface_init));
2605
2606 #else
2607 G_DEFINE_TYPE_WITH_CODE (OrgOfonoVoiceCallManagerProxy, org_ofono_voice_call_manager_proxy, G_TYPE_DBUS_PROXY,
2608                          G_IMPLEMENT_INTERFACE (TYPE_ORG_OFONO_VOICE_CALL_MANAGER, org_ofono_voice_call_manager_proxy_iface_init));
2609
2610 #endif
2611 static void
2612 org_ofono_voice_call_manager_proxy_finalize (GObject *object)
2613 {
2614   OrgOfonoVoiceCallManagerProxy *proxy = ORG_OFONO_VOICE_CALL_MANAGER_PROXY (object);
2615   g_datalist_clear (&proxy->priv->qdata);
2616   G_OBJECT_CLASS (org_ofono_voice_call_manager_proxy_parent_class)->finalize (object);
2617 }
2618
2619 static void
2620 org_ofono_voice_call_manager_proxy_get_property (GObject      *object,
2621   guint         prop_id,
2622   GValue       *value,
2623   GParamSpec   *pspec G_GNUC_UNUSED)
2624 {
2625 }
2626
2627 static void
2628 org_ofono_voice_call_manager_proxy_set_property (GObject      *object,
2629   guint         prop_id,
2630   const GValue *value,
2631   GParamSpec   *pspec G_GNUC_UNUSED)
2632 {
2633 }
2634
2635 static void
2636 org_ofono_voice_call_manager_proxy_g_signal (GDBusProxy *proxy,
2637   const gchar *sender_name G_GNUC_UNUSED,
2638   const gchar *signal_name,
2639   GVariant *parameters)
2640 {
2641   _ExtendedGDBusSignalInfo *info;
2642   GVariantIter iter;
2643   GVariant *child;
2644   GValue *paramv;
2645   guint num_params;
2646   guint n;
2647   guint signal_id;
2648   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct, signal_name);
2649   if (info == NULL)
2650     return;
2651   num_params = g_variant_n_children (parameters);
2652   paramv = g_new0 (GValue, num_params + 1);
2653   g_value_init (&paramv[0], TYPE_ORG_OFONO_VOICE_CALL_MANAGER);
2654   g_value_set_object (&paramv[0], proxy);
2655   g_variant_iter_init (&iter, parameters);
2656   n = 1;
2657   while ((child = g_variant_iter_next_value (&iter)) != NULL)
2658     {
2659       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
2660       if (arg_info->use_gvariant)
2661         {
2662           g_value_init (&paramv[n], G_TYPE_VARIANT);
2663           g_value_set_variant (&paramv[n], child);
2664           n++;
2665         }
2666       else
2667         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
2668       g_variant_unref (child);
2669     }
2670   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_OFONO_VOICE_CALL_MANAGER);
2671   g_signal_emitv (paramv, signal_id, 0, NULL);
2672   for (n = 0; n < num_params + 1; n++)
2673     g_value_unset (&paramv[n]);
2674   g_free (paramv);
2675 }
2676
2677 static void
2678 org_ofono_voice_call_manager_proxy_g_properties_changed (GDBusProxy *_proxy,
2679   GVariant *changed_properties,
2680   const gchar *const *invalidated_properties)
2681 {
2682   OrgOfonoVoiceCallManagerProxy *proxy = ORG_OFONO_VOICE_CALL_MANAGER_PROXY (_proxy);
2683   guint n;
2684   const gchar *key;
2685   GVariantIter *iter;
2686   _ExtendedGDBusPropertyInfo *info;
2687   g_variant_get (changed_properties, "a{sv}", &iter);
2688   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
2689     {
2690       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct, key);
2691       g_datalist_remove_data (&proxy->priv->qdata, key);
2692       if (info != NULL)
2693         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
2694     }
2695   g_variant_iter_free (iter);
2696   for (n = 0; invalidated_properties[n] != NULL; n++)
2697     {
2698       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct, invalidated_properties[n]);
2699       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
2700       if (info != NULL)
2701         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
2702     }
2703 }
2704
2705 static void
2706 org_ofono_voice_call_manager_proxy_init (OrgOfonoVoiceCallManagerProxy *proxy)
2707 {
2708 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2709   proxy->priv = org_ofono_voice_call_manager_proxy_get_instance_private (proxy);
2710 #else
2711   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_OFONO_VOICE_CALL_MANAGER_PROXY, OrgOfonoVoiceCallManagerProxyPrivate);
2712 #endif
2713
2714   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_ofono_voice_call_manager_interface_info ());
2715 }
2716
2717 static void
2718 org_ofono_voice_call_manager_proxy_class_init (OrgOfonoVoiceCallManagerProxyClass *klass)
2719 {
2720   GObjectClass *gobject_class;
2721   GDBusProxyClass *proxy_class;
2722
2723   gobject_class = G_OBJECT_CLASS (klass);
2724   gobject_class->finalize     = org_ofono_voice_call_manager_proxy_finalize;
2725   gobject_class->get_property = org_ofono_voice_call_manager_proxy_get_property;
2726   gobject_class->set_property = org_ofono_voice_call_manager_proxy_set_property;
2727
2728   proxy_class = G_DBUS_PROXY_CLASS (klass);
2729   proxy_class->g_signal = org_ofono_voice_call_manager_proxy_g_signal;
2730   proxy_class->g_properties_changed = org_ofono_voice_call_manager_proxy_g_properties_changed;
2731
2732 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
2733   g_type_class_add_private (klass, sizeof (OrgOfonoVoiceCallManagerProxyPrivate));
2734 #endif
2735 }
2736
2737 static void
2738 org_ofono_voice_call_manager_proxy_iface_init (OrgOfonoVoiceCallManagerIface *iface)
2739 {
2740 }
2741
2742 /**
2743  * org_ofono_voice_call_manager_proxy_new:
2744  * @connection: A #GDBusConnection.
2745  * @flags: Flags from the #GDBusProxyFlags enumeration.
2746  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
2747  * @object_path: An object path.
2748  * @cancellable: (allow-none): A #GCancellable or %NULL.
2749  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
2750  * @user_data: User data to pass to @callback.
2751  *
2752  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link>. See g_dbus_proxy_new() for more details.
2753  *
2754  * 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.
2755  * You can then call org_ofono_voice_call_manager_proxy_new_finish() to get the result of the operation.
2756  *
2757  * See org_ofono_voice_call_manager_proxy_new_sync() for the synchronous, blocking version of this constructor.
2758  */
2759 void
2760 org_ofono_voice_call_manager_proxy_new (
2761     GDBusConnection     *connection,
2762     GDBusProxyFlags      flags,
2763     const gchar         *name,
2764     const gchar         *object_path,
2765     GCancellable        *cancellable,
2766     GAsyncReadyCallback  callback,
2767     gpointer             user_data)
2768 {
2769   g_async_initable_new_async (TYPE_ORG_OFONO_VOICE_CALL_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.ofono.VoiceCallManager", NULL);
2770 }
2771
2772 /**
2773  * org_ofono_voice_call_manager_proxy_new_finish:
2774  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_proxy_new().
2775  * @error: Return location for error or %NULL
2776  *
2777  * Finishes an operation started with org_ofono_voice_call_manager_proxy_new().
2778  *
2779  * Returns: (transfer full) (type OrgOfonoVoiceCallManagerProxy): The constructed proxy object or %NULL if @error is set.
2780  */
2781 OrgOfonoVoiceCallManager *
2782 org_ofono_voice_call_manager_proxy_new_finish (
2783     GAsyncResult        *res,
2784     GError             **error)
2785 {
2786   GObject *ret;
2787   GObject *source_object;
2788   source_object = g_async_result_get_source_object (res);
2789   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
2790   g_object_unref (source_object);
2791   if (ret != NULL)
2792     return ORG_OFONO_VOICE_CALL_MANAGER (ret);
2793   else
2794     return NULL;
2795 }
2796
2797 /**
2798  * org_ofono_voice_call_manager_proxy_new_sync:
2799  * @connection: A #GDBusConnection.
2800  * @flags: Flags from the #GDBusProxyFlags enumeration.
2801  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
2802  * @object_path: An object path.
2803  * @cancellable: (allow-none): A #GCancellable or %NULL.
2804  * @error: Return location for error or %NULL
2805  *
2806  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link>. See g_dbus_proxy_new_sync() for more details.
2807  *
2808  * The calling thread is blocked until a reply is received.
2809  *
2810  * See org_ofono_voice_call_manager_proxy_new() for the asynchronous version of this constructor.
2811  *
2812  * Returns: (transfer full) (type OrgOfonoVoiceCallManagerProxy): The constructed proxy object or %NULL if @error is set.
2813  */
2814 OrgOfonoVoiceCallManager *
2815 org_ofono_voice_call_manager_proxy_new_sync (
2816     GDBusConnection     *connection,
2817     GDBusProxyFlags      flags,
2818     const gchar         *name,
2819     const gchar         *object_path,
2820     GCancellable        *cancellable,
2821     GError             **error)
2822 {
2823   GInitable *ret;
2824   ret = g_initable_new (TYPE_ORG_OFONO_VOICE_CALL_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.ofono.VoiceCallManager", NULL);
2825   if (ret != NULL)
2826     return ORG_OFONO_VOICE_CALL_MANAGER (ret);
2827   else
2828     return NULL;
2829 }
2830
2831
2832 /**
2833  * org_ofono_voice_call_manager_proxy_new_for_bus:
2834  * @bus_type: A #GBusType.
2835  * @flags: Flags from the #GDBusProxyFlags enumeration.
2836  * @name: A bus name (well-known or unique).
2837  * @object_path: An object path.
2838  * @cancellable: (allow-none): A #GCancellable or %NULL.
2839  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
2840  * @user_data: User data to pass to @callback.
2841  *
2842  * Like org_ofono_voice_call_manager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
2843  *
2844  * 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.
2845  * You can then call org_ofono_voice_call_manager_proxy_new_for_bus_finish() to get the result of the operation.
2846  *
2847  * See org_ofono_voice_call_manager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
2848  */
2849 void
2850 org_ofono_voice_call_manager_proxy_new_for_bus (
2851     GBusType             bus_type,
2852     GDBusProxyFlags      flags,
2853     const gchar         *name,
2854     const gchar         *object_path,
2855     GCancellable        *cancellable,
2856     GAsyncReadyCallback  callback,
2857     gpointer             user_data)
2858 {
2859   g_async_initable_new_async (TYPE_ORG_OFONO_VOICE_CALL_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.ofono.VoiceCallManager", NULL);
2860 }
2861
2862 /**
2863  * org_ofono_voice_call_manager_proxy_new_for_bus_finish:
2864  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_ofono_voice_call_manager_proxy_new_for_bus().
2865  * @error: Return location for error or %NULL
2866  *
2867  * Finishes an operation started with org_ofono_voice_call_manager_proxy_new_for_bus().
2868  *
2869  * Returns: (transfer full) (type OrgOfonoVoiceCallManagerProxy): The constructed proxy object or %NULL if @error is set.
2870  */
2871 OrgOfonoVoiceCallManager *
2872 org_ofono_voice_call_manager_proxy_new_for_bus_finish (
2873     GAsyncResult        *res,
2874     GError             **error)
2875 {
2876   GObject *ret;
2877   GObject *source_object;
2878   source_object = g_async_result_get_source_object (res);
2879   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
2880   g_object_unref (source_object);
2881   if (ret != NULL)
2882     return ORG_OFONO_VOICE_CALL_MANAGER (ret);
2883   else
2884     return NULL;
2885 }
2886
2887 /**
2888  * org_ofono_voice_call_manager_proxy_new_for_bus_sync:
2889  * @bus_type: A #GBusType.
2890  * @flags: Flags from the #GDBusProxyFlags enumeration.
2891  * @name: A bus name (well-known or unique).
2892  * @object_path: An object path.
2893  * @cancellable: (allow-none): A #GCancellable or %NULL.
2894  * @error: Return location for error or %NULL
2895  *
2896  * Like org_ofono_voice_call_manager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
2897  *
2898  * The calling thread is blocked until a reply is received.
2899  *
2900  * See org_ofono_voice_call_manager_proxy_new_for_bus() for the asynchronous version of this constructor.
2901  *
2902  * Returns: (transfer full) (type OrgOfonoVoiceCallManagerProxy): The constructed proxy object or %NULL if @error is set.
2903  */
2904 OrgOfonoVoiceCallManager *
2905 org_ofono_voice_call_manager_proxy_new_for_bus_sync (
2906     GBusType             bus_type,
2907     GDBusProxyFlags      flags,
2908     const gchar         *name,
2909     const gchar         *object_path,
2910     GCancellable        *cancellable,
2911     GError             **error)
2912 {
2913   GInitable *ret;
2914   ret = g_initable_new (TYPE_ORG_OFONO_VOICE_CALL_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.ofono.VoiceCallManager", NULL);
2915   if (ret != NULL)
2916     return ORG_OFONO_VOICE_CALL_MANAGER (ret);
2917   else
2918     return NULL;
2919 }
2920
2921
2922 /* ------------------------------------------------------------------------ */
2923
2924 /**
2925  * OrgOfonoVoiceCallManagerSkeleton:
2926  *
2927  * The #OrgOfonoVoiceCallManagerSkeleton structure contains only private data and should only be accessed using the provided API.
2928  */
2929
2930 /**
2931  * OrgOfonoVoiceCallManagerSkeletonClass:
2932  * @parent_class: The parent class.
2933  *
2934  * Class structure for #OrgOfonoVoiceCallManagerSkeleton.
2935  */
2936
2937 struct _OrgOfonoVoiceCallManagerSkeletonPrivate
2938 {
2939   GValue *properties;
2940   GList *changed_properties;
2941   GSource *changed_properties_idle_source;
2942   GMainContext *context;
2943   GMutex lock;
2944 };
2945
2946 static void
2947 _org_ofono_voice_call_manager_skeleton_handle_method_call (
2948   GDBusConnection *connection G_GNUC_UNUSED,
2949   const gchar *sender G_GNUC_UNUSED,
2950   const gchar *object_path G_GNUC_UNUSED,
2951   const gchar *interface_name,
2952   const gchar *method_name,
2953   GVariant *parameters,
2954   GDBusMethodInvocation *invocation,
2955   gpointer user_data)
2956 {
2957   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (user_data);
2958   _ExtendedGDBusMethodInfo *info;
2959   GVariantIter iter;
2960   GVariant *child;
2961   GValue *paramv;
2962   guint num_params;
2963   guint num_extra;
2964   guint n;
2965   guint signal_id;
2966   GValue return_value = G_VALUE_INIT;
2967   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
2968   g_assert (info != NULL);
2969   num_params = g_variant_n_children (parameters);
2970   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
2971   n = 0;
2972   g_value_init (&paramv[n], TYPE_ORG_OFONO_VOICE_CALL_MANAGER);
2973   g_value_set_object (&paramv[n++], skeleton);
2974   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
2975   g_value_set_object (&paramv[n++], invocation);
2976   if (info->pass_fdlist)
2977     {
2978 #ifdef G_OS_UNIX
2979       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
2980       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
2981 #else
2982       g_assert_not_reached ();
2983 #endif
2984     }
2985   g_variant_iter_init (&iter, parameters);
2986   while ((child = g_variant_iter_next_value (&iter)) != NULL)
2987     {
2988       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
2989       if (arg_info->use_gvariant)
2990         {
2991           g_value_init (&paramv[n], G_TYPE_VARIANT);
2992           g_value_set_variant (&paramv[n], child);
2993           n++;
2994         }
2995       else
2996         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
2997       g_variant_unref (child);
2998     }
2999   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_OFONO_VOICE_CALL_MANAGER);
3000   g_value_init (&return_value, G_TYPE_BOOLEAN);
3001   g_signal_emitv (paramv, signal_id, 0, &return_value);
3002   if (!g_value_get_boolean (&return_value))
3003     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);
3004   g_value_unset (&return_value);
3005   for (n = 0; n < num_params + num_extra; n++)
3006     g_value_unset (&paramv[n]);
3007   g_free (paramv);
3008 }
3009
3010 static GVariant *
3011 _org_ofono_voice_call_manager_skeleton_handle_get_property (
3012   GDBusConnection *connection G_GNUC_UNUSED,
3013   const gchar *sender G_GNUC_UNUSED,
3014   const gchar *object_path G_GNUC_UNUSED,
3015   const gchar *interface_name G_GNUC_UNUSED,
3016   const gchar *property_name,
3017   GError **error,
3018   gpointer user_data)
3019 {
3020   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (user_data);
3021   GValue value = G_VALUE_INIT;
3022   GParamSpec *pspec;
3023   _ExtendedGDBusPropertyInfo *info;
3024   GVariant *ret;
3025   ret = NULL;
3026   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct, property_name);
3027   g_assert (info != NULL);
3028   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
3029   if (pspec == NULL)
3030     {
3031       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
3032     }
3033   else
3034     {
3035       g_value_init (&value, pspec->value_type);
3036       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
3037       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
3038       g_value_unset (&value);
3039     }
3040   return ret;
3041 }
3042
3043 static gboolean
3044 _org_ofono_voice_call_manager_skeleton_handle_set_property (
3045   GDBusConnection *connection G_GNUC_UNUSED,
3046   const gchar *sender G_GNUC_UNUSED,
3047   const gchar *object_path G_GNUC_UNUSED,
3048   const gchar *interface_name G_GNUC_UNUSED,
3049   const gchar *property_name,
3050   GVariant *variant,
3051   GError **error,
3052   gpointer user_data)
3053 {
3054   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (user_data);
3055   GValue value = G_VALUE_INIT;
3056   GParamSpec *pspec;
3057   _ExtendedGDBusPropertyInfo *info;
3058   gboolean ret;
3059   ret = FALSE;
3060   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_ofono_voice_call_manager_interface_info.parent_struct, property_name);
3061   g_assert (info != NULL);
3062   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
3063   if (pspec == NULL)
3064     {
3065       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
3066     }
3067   else
3068     {
3069       if (info->use_gvariant)
3070         g_value_set_variant (&value, variant);
3071       else
3072         g_dbus_gvariant_to_gvalue (variant, &value);
3073       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
3074       g_value_unset (&value);
3075       ret = TRUE;
3076     }
3077   return ret;
3078 }
3079
3080 static const GDBusInterfaceVTable _org_ofono_voice_call_manager_skeleton_vtable =
3081 {
3082   _org_ofono_voice_call_manager_skeleton_handle_method_call,
3083   _org_ofono_voice_call_manager_skeleton_handle_get_property,
3084   _org_ofono_voice_call_manager_skeleton_handle_set_property,
3085   {NULL}
3086 };
3087
3088 static GDBusInterfaceInfo *
3089 org_ofono_voice_call_manager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
3090 {
3091   return org_ofono_voice_call_manager_interface_info ();
3092 }
3093
3094 static GDBusInterfaceVTable *
3095 org_ofono_voice_call_manager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
3096 {
3097   return (GDBusInterfaceVTable *) &_org_ofono_voice_call_manager_skeleton_vtable;
3098 }
3099
3100 static GVariant *
3101 org_ofono_voice_call_manager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
3102 {
3103   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (_skeleton);
3104
3105   GVariantBuilder builder;
3106   guint n;
3107   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
3108   if (_org_ofono_voice_call_manager_interface_info.parent_struct.properties == NULL)
3109     goto out;
3110   for (n = 0; _org_ofono_voice_call_manager_interface_info.parent_struct.properties[n] != NULL; n++)
3111     {
3112       GDBusPropertyInfo *info = _org_ofono_voice_call_manager_interface_info.parent_struct.properties[n];
3113       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
3114         {
3115           GVariant *value;
3116           value = _org_ofono_voice_call_manager_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", info->name, NULL, skeleton);
3117           if (value != NULL)
3118             {
3119               g_variant_take_ref (value);
3120               g_variant_builder_add (&builder, "{sv}", info->name, value);
3121               g_variant_unref (value);
3122             }
3123         }
3124     }
3125 out:
3126   return g_variant_builder_end (&builder);
3127 }
3128
3129 static void
3130 org_ofono_voice_call_manager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
3131 {
3132 }
3133
3134 static void
3135 _org_ofono_voice_call_manager_on_signal_property_changed (
3136     OrgOfonoVoiceCallManager *object,
3137     const gchar *arg_unnamed_arg0,
3138     GVariant *arg_unnamed_arg1)
3139 {
3140   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3141
3142   GList      *connections, *l;
3143   GVariant   *signal_variant;
3144   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3145
3146   signal_variant = g_variant_ref_sink (g_variant_new ("(s@v)",
3147                    arg_unnamed_arg0,
3148                    arg_unnamed_arg1));
3149   for (l = connections; l != NULL; l = l->next)
3150     {
3151       GDBusConnection *connection = l->data;
3152       g_dbus_connection_emit_signal (connection,
3153         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", "PropertyChanged",
3154         signal_variant, NULL);
3155     }
3156   g_variant_unref (signal_variant);
3157   g_list_free_full (connections, g_object_unref);
3158 }
3159
3160 static void
3161 _org_ofono_voice_call_manager_on_signal_call_added (
3162     OrgOfonoVoiceCallManager *object,
3163     const gchar *arg_unnamed_arg0,
3164     GVariant *arg_unnamed_arg1)
3165 {
3166   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3167
3168   GList      *connections, *l;
3169   GVariant   *signal_variant;
3170   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3171
3172   signal_variant = g_variant_ref_sink (g_variant_new ("(o@a{sv})",
3173                    arg_unnamed_arg0,
3174                    arg_unnamed_arg1));
3175   for (l = connections; l != NULL; l = l->next)
3176     {
3177       GDBusConnection *connection = l->data;
3178       g_dbus_connection_emit_signal (connection,
3179         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", "CallAdded",
3180         signal_variant, NULL);
3181     }
3182   g_variant_unref (signal_variant);
3183   g_list_free_full (connections, g_object_unref);
3184 }
3185
3186 static void
3187 _org_ofono_voice_call_manager_on_signal_call_removed (
3188     OrgOfonoVoiceCallManager *object,
3189     const gchar *arg_unnamed_arg0)
3190 {
3191   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3192
3193   GList      *connections, *l;
3194   GVariant   *signal_variant;
3195   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3196
3197   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
3198                    arg_unnamed_arg0));
3199   for (l = connections; l != NULL; l = l->next)
3200     {
3201       GDBusConnection *connection = l->data;
3202       g_dbus_connection_emit_signal (connection,
3203         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", "CallRemoved",
3204         signal_variant, NULL);
3205     }
3206   g_variant_unref (signal_variant);
3207   g_list_free_full (connections, g_object_unref);
3208 }
3209
3210 static void
3211 _org_ofono_voice_call_manager_on_signal_barring_active (
3212     OrgOfonoVoiceCallManager *object,
3213     const gchar *arg_unnamed_arg0)
3214 {
3215   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3216
3217   GList      *connections, *l;
3218   GVariant   *signal_variant;
3219   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3220
3221   signal_variant = g_variant_ref_sink (g_variant_new ("(s)",
3222                    arg_unnamed_arg0));
3223   for (l = connections; l != NULL; l = l->next)
3224     {
3225       GDBusConnection *connection = l->data;
3226       g_dbus_connection_emit_signal (connection,
3227         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", "BarringActive",
3228         signal_variant, NULL);
3229     }
3230   g_variant_unref (signal_variant);
3231   g_list_free_full (connections, g_object_unref);
3232 }
3233
3234 static void
3235 _org_ofono_voice_call_manager_on_signal_forwarded (
3236     OrgOfonoVoiceCallManager *object,
3237     const gchar *arg_unnamed_arg0)
3238 {
3239   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3240
3241   GList      *connections, *l;
3242   GVariant   *signal_variant;
3243   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
3244
3245   signal_variant = g_variant_ref_sink (g_variant_new ("(s)",
3246                    arg_unnamed_arg0));
3247   for (l = connections; l != NULL; l = l->next)
3248     {
3249       GDBusConnection *connection = l->data;
3250       g_dbus_connection_emit_signal (connection,
3251         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.ofono.VoiceCallManager", "Forwarded",
3252         signal_variant, NULL);
3253     }
3254   g_variant_unref (signal_variant);
3255   g_list_free_full (connections, g_object_unref);
3256 }
3257
3258 static void org_ofono_voice_call_manager_skeleton_iface_init (OrgOfonoVoiceCallManagerIface *iface);
3259 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
3260 G_DEFINE_TYPE_WITH_CODE (OrgOfonoVoiceCallManagerSkeleton, org_ofono_voice_call_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
3261                          G_ADD_PRIVATE (OrgOfonoVoiceCallManagerSkeleton)
3262                          G_IMPLEMENT_INTERFACE (TYPE_ORG_OFONO_VOICE_CALL_MANAGER, org_ofono_voice_call_manager_skeleton_iface_init));
3263
3264 #else
3265 G_DEFINE_TYPE_WITH_CODE (OrgOfonoVoiceCallManagerSkeleton, org_ofono_voice_call_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
3266                          G_IMPLEMENT_INTERFACE (TYPE_ORG_OFONO_VOICE_CALL_MANAGER, org_ofono_voice_call_manager_skeleton_iface_init));
3267
3268 #endif
3269 static void
3270 org_ofono_voice_call_manager_skeleton_finalize (GObject *object)
3271 {
3272   OrgOfonoVoiceCallManagerSkeleton *skeleton = ORG_OFONO_VOICE_CALL_MANAGER_SKELETON (object);
3273   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
3274   if (skeleton->priv->changed_properties_idle_source != NULL)
3275     g_source_destroy (skeleton->priv->changed_properties_idle_source);
3276   g_main_context_unref (skeleton->priv->context);
3277   g_mutex_clear (&skeleton->priv->lock);
3278   G_OBJECT_CLASS (org_ofono_voice_call_manager_skeleton_parent_class)->finalize (object);
3279 }
3280
3281 static void
3282 org_ofono_voice_call_manager_skeleton_init (OrgOfonoVoiceCallManagerSkeleton *skeleton)
3283 {
3284 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
3285   skeleton->priv = org_ofono_voice_call_manager_skeleton_get_instance_private (skeleton);
3286 #else
3287   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_OFONO_VOICE_CALL_MANAGER_SKELETON, OrgOfonoVoiceCallManagerSkeletonPrivate);
3288 #endif
3289
3290   g_mutex_init (&skeleton->priv->lock);
3291   skeleton->priv->context = g_main_context_ref_thread_default ();
3292 }
3293
3294 static void
3295 org_ofono_voice_call_manager_skeleton_class_init (OrgOfonoVoiceCallManagerSkeletonClass *klass)
3296 {
3297   GObjectClass *gobject_class;
3298   GDBusInterfaceSkeletonClass *skeleton_class;
3299
3300   gobject_class = G_OBJECT_CLASS (klass);
3301   gobject_class->finalize = org_ofono_voice_call_manager_skeleton_finalize;
3302
3303   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
3304   skeleton_class->get_info = org_ofono_voice_call_manager_skeleton_dbus_interface_get_info;
3305   skeleton_class->get_properties = org_ofono_voice_call_manager_skeleton_dbus_interface_get_properties;
3306   skeleton_class->flush = org_ofono_voice_call_manager_skeleton_dbus_interface_flush;
3307   skeleton_class->get_vtable = org_ofono_voice_call_manager_skeleton_dbus_interface_get_vtable;
3308
3309 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
3310   g_type_class_add_private (klass, sizeof (OrgOfonoVoiceCallManagerSkeletonPrivate));
3311 #endif
3312 }
3313
3314 static void
3315 org_ofono_voice_call_manager_skeleton_iface_init (OrgOfonoVoiceCallManagerIface *iface)
3316 {
3317   iface->property_changed = _org_ofono_voice_call_manager_on_signal_property_changed;
3318   iface->call_added = _org_ofono_voice_call_manager_on_signal_call_added;
3319   iface->call_removed = _org_ofono_voice_call_manager_on_signal_call_removed;
3320   iface->barring_active = _org_ofono_voice_call_manager_on_signal_barring_active;
3321   iface->forwarded = _org_ofono_voice_call_manager_on_signal_forwarded;
3322 }
3323
3324 /**
3325  * org_ofono_voice_call_manager_skeleton_new:
3326  *
3327  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-ofono-VoiceCallManager.top_of_page">org.ofono.VoiceCallManager</link>.
3328  *
3329  * Returns: (transfer full) (type OrgOfonoVoiceCallManagerSkeleton): The skeleton object.
3330  */
3331 OrgOfonoVoiceCallManager *
3332 org_ofono_voice_call_manager_skeleton_new (void)
3333 {
3334   return ORG_OFONO_VOICE_CALL_MANAGER (g_object_new (TYPE_ORG_OFONO_VOICE_CALL_MANAGER_SKELETON, NULL));
3335 }
3336