soundmanager_binging/dbus/audio_manager_interface.c

   1 /*
   2  * Generated by gdbus-codegen 2.48.1. DO NOT EDIT.
   3  *
   4  * The license of this code is the same as for the source it was derived from.
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #  include "config.h"
   9 #endif
  10
  11 #include "audio_manager_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.genivi.audiomanager.commandinterface
 153  * ------------------------------------------------------------------------
 154  */
 155
 156 /**
 157  * SECTION:AudiomanagerCommandinterface
 158  * @title: AudiomanagerCommandinterface
 159  * @short_description: Generated C code for the org.genivi.audiomanager.commandinterface D-Bus interface
 160  *
 161  * This section contains code for working with the <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link> D-Bus interface in C.
 162  */
 163
 164 /* ---- Introspection data for org.genivi.audiomanager.commandinterface ---- */
 165
 166 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_IN_ARG_sourceID =
 167 {
 168   {
 169     -1,
 170     (gchar *) "sourceID",
 171     (gchar *) "q",
 172     NULL
 173   },
 174   FALSE
 175 };
 176
 177 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_IN_ARG_sinkID =
 178 {
 179   {
 180     -1,
 181     (gchar *) "sinkID",
 182     (gchar *) "q",
 183     NULL
 184   },
 185   FALSE
 186 };
 187
 188 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_connect_IN_ARG_pointers[] =
 189 {
 190   &_audiomanager_commandinterface_method_info_connect_IN_ARG_sourceID,
 191   &_audiomanager_commandinterface_method_info_connect_IN_ARG_sinkID,
 192   NULL
 193 };
 194
 195 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_OUT_ARG_result =
 196 {
 197   {
 198     -1,
 199     (gchar *) "result",
 200     (gchar *) "n",
 201     NULL
 202   },
 203   FALSE
 204 };
 205
 206 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_OUT_ARG_mainConnectionID =
 207 {
 208   {
 209     -1,
 210     (gchar *) "mainConnectionID",
 211     (gchar *) "q",
 212     NULL
 213   },
 214   FALSE
 215 };
 216
 217 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_connect_OUT_ARG_pointers[] =
 218 {
 219   &_audiomanager_commandinterface_method_info_connect_OUT_ARG_result,
 220   &_audiomanager_commandinterface_method_info_connect_OUT_ARG_mainConnectionID,
 221   NULL
 222 };
 223
 224 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_connect =
 225 {
 226   {
 227     -1,
 228     (gchar *) "Connect",
 229     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_connect_IN_ARG_pointers,
 230     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_connect_OUT_ARG_pointers,
 231     NULL
 232   },
 233   "handle-connect",
 234   FALSE
 235 };
 236
 237 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_disconnect_IN_ARG_mainConnectionID =
 238 {
 239   {
 240     -1,
 241     (gchar *) "mainConnectionID",
 242     (gchar *) "q",
 243     NULL
 244   },
 245   FALSE
 246 };
 247
 248 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_disconnect_IN_ARG_pointers[] =
 249 {
 250   &_audiomanager_commandinterface_method_info_disconnect_IN_ARG_mainConnectionID,
 251   NULL
 252 };
 253
 254 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_disconnect_OUT_ARG_result =
 255 {
 256   {
 257     -1,
 258     (gchar *) "result",
 259     (gchar *) "n",
 260     NULL
 261   },
 262   FALSE
 263 };
 264
 265 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_disconnect_OUT_ARG_pointers[] =
 266 {
 267   &_audiomanager_commandinterface_method_info_disconnect_OUT_ARG_result,
 268   NULL
 269 };
 270
 271 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_disconnect =
 272 {
 273   {
 274     -1,
 275     (gchar *) "Disconnect",
 276     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_disconnect_IN_ARG_pointers,
 277     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_disconnect_OUT_ARG_pointers,
 278     NULL
 279   },
 280   "handle-disconnect",
 281   FALSE
 282 };
 283
 284 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_IN_ARG_sinkID =
 285 {
 286   {
 287     -1,
 288     (gchar *) "sinkID",
 289     (gchar *) "q",
 290     NULL
 291   },
 292   FALSE
 293 };
 294
 295 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_IN_ARG_volume =
 296 {
 297   {
 298     -1,
 299     (gchar *) "volume",
 300     (gchar *) "n",
 301     NULL
 302   },
 303   FALSE
 304 };
 305
 306 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_volume_IN_ARG_pointers[] =
 307 {
 308   &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_sinkID,
 309   &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_volume,
 310   NULL
 311 };
 312
 313 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_OUT_ARG_result =
 314 {
 315   {
 316     -1,
 317     (gchar *) "result",
 318     (gchar *) "n",
 319     NULL
 320   },
 321   FALSE
 322 };
 323
 324 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_volume_OUT_ARG_pointers[] =
 325 {
 326   &_audiomanager_commandinterface_method_info_set_volume_OUT_ARG_result,
 327   NULL
 328 };
 329
 330 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_set_volume =
 331 {
 332   {
 333     -1,
 334     (gchar *) "SetVolume",
 335     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_pointers,
 336     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_volume_OUT_ARG_pointers,
 337     NULL
 338   },
 339   "handle-set-volume",
 340   FALSE
 341 };
 342
 343 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_IN_ARG_sinkID =
 344 {
 345   {
 346     -1,
 347     (gchar *) "sinkID",
 348     (gchar *) "q",
 349     NULL
 350   },
 351   FALSE
 352 };
 353
 354 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_IN_ARG_volumeStep =
 355 {
 356   {
 357     -1,
 358     (gchar *) "volumeStep",
 359     (gchar *) "n",
 360     NULL
 361   },
 362   FALSE
 363 };
 364
 365 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_volume_step_IN_ARG_pointers[] =
 366 {
 367   &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_sinkID,
 368   &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_volumeStep,
 369   NULL
 370 };
 371
 372 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_OUT_ARG_result =
 373 {
 374   {
 375     -1,
 376     (gchar *) "result",
 377     (gchar *) "n",
 378     NULL
 379   },
 380   FALSE
 381 };
 382
 383 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_volume_step_OUT_ARG_pointers[] =
 384 {
 385   &_audiomanager_commandinterface_method_info_volume_step_OUT_ARG_result,
 386   NULL
 387 };
 388
 389 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_volume_step =
 390 {
 391   {
 392     -1,
 393     (gchar *) "VolumeStep",
 394     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_pointers,
 395     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_volume_step_OUT_ARG_pointers,
 396     NULL
 397   },
 398   "handle-volume-step",
 399   FALSE
 400 };
 401
 402 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_sinkID =
 403 {
 404   {
 405     -1,
 406     (gchar *) "sinkID",
 407     (gchar *) "q",
 408     NULL
 409   },
 410   FALSE
 411 };
 412
 413 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_muteState =
 414 {
 415   {
 416     -1,
 417     (gchar *) "muteState",
 418     (gchar *) "n",
 419     NULL
 420   },
 421   FALSE
 422 };
 423
 424 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_pointers[] =
 425 {
 426   &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_sinkID,
 427   &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_muteState,
 428   NULL
 429 };
 430
 431 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_result =
 432 {
 433   {
 434     -1,
 435     (gchar *) "result",
 436     (gchar *) "n",
 437     NULL
 438   },
 439   FALSE
 440 };
 441
 442 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_pointers[] =
 443 {
 444   &_audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_result,
 445   NULL
 446 };
 447
 448 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_set_sink_mute_state =
 449 {
 450   {
 451     -1,
 452     (gchar *) "SetSinkMuteState",
 453     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_pointers,
 454     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_pointers,
 455     NULL
 456   },
 457   "handle-set-sink-mute-state",
 458   FALSE
 459 };
 460
 461 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_result =
 462 {
 463   {
 464     -1,
 465     (gchar *) "result",
 466     (gchar *) "n",
 467     NULL
 468   },
 469   FALSE
 470 };
 471
 472 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_listConnections =
 473 {
 474   {
 475     -1,
 476     (gchar *) "listConnections",
 477     (gchar *) "a(qqqnn)",
 478     NULL
 479   },
 480   FALSE
 481 };
 482
 483 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_pointers[] =
 484 {
 485   &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_result,
 486   &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_listConnections,
 487   NULL
 488 };
 489
 490 static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_get_list_main_connections =
 491 {
 492   {
 493     -1,
 494     (gchar *) "GetListMainConnections",
 495     NULL,
 496     (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_pointers,
 497     NULL
 498   },
 499   "handle-get-list-main-connections",
 500   FALSE
 501 };
 502
 503 static const _ExtendedGDBusMethodInfo * const _audiomanager_commandinterface_method_info_pointers[] =
 504 {
 505   &_audiomanager_commandinterface_method_info_connect,
 506   &_audiomanager_commandinterface_method_info_disconnect,
 507   &_audiomanager_commandinterface_method_info_set_volume,
 508   &_audiomanager_commandinterface_method_info_volume_step,
 509   &_audiomanager_commandinterface_method_info_set_sink_mute_state,
 510   &_audiomanager_commandinterface_method_info_get_list_main_connections,
 511   NULL
 512 };
 513
 514 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_new_main_connection_ARG_mainConnection =
 515 {
 516   {
 517     -1,
 518     (gchar *) "mainConnection",
 519     (gchar *) "(qqqnn)",
 520     NULL
 521   },
 522   FALSE
 523 };
 524
 525 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_new_main_connection_ARG_pointers[] =
 526 {
 527   &_audiomanager_commandinterface_signal_info_new_main_connection_ARG_mainConnection,
 528   NULL
 529 };
 530
 531 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_new_main_connection =
 532 {
 533   {
 534     -1,
 535     (gchar *) "NewMainConnection",
 536     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_new_main_connection_ARG_pointers,
 537     NULL
 538   },
 539   "new-main-connection"
 540 };
 541
 542 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_removed_main_connection_ARG_mainConnectionId =
 543 {
 544   {
 545     -1,
 546     (gchar *) "mainConnectionId",
 547     (gchar *) "q",
 548     NULL
 549   },
 550   FALSE
 551 };
 552
 553 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_removed_main_connection_ARG_pointers[] =
 554 {
 555   &_audiomanager_commandinterface_signal_info_removed_main_connection_ARG_mainConnectionId,
 556   NULL
 557 };
 558
 559 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_removed_main_connection =
 560 {
 561   {
 562     -1,
 563     (gchar *) "RemovedMainConnection",
 564     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_removed_main_connection_ARG_pointers,
 565     NULL
 566   },
 567   "removed-main-connection"
 568 };
 569
 570 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionID =
 571 {
 572   {
 573     -1,
 574     (gchar *) "connectionID",
 575     (gchar *) "q",
 576     NULL
 577   },
 578   FALSE
 579 };
 580
 581 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionState =
 582 {
 583   {
 584     -1,
 585     (gchar *) "connectionState",
 586     (gchar *) "n",
 587     NULL
 588   },
 589   FALSE
 590 };
 591
 592 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_pointers[] =
 593 {
 594   &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionID,
 595   &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionState,
 596   NULL
 597 };
 598
 599 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed =
 600 {
 601   {
 602     -1,
 603     (gchar *) "MainConnectionStateChanged",
 604     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_pointers,
 605     NULL
 606   },
 607   "main-connection-state-changed"
 608 };
 609
 610 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_volume_changed_ARG_sinkID =
 611 {
 612   {
 613     -1,
 614     (gchar *) "sinkID",
 615     (gchar *) "q",
 616     NULL
 617   },
 618   FALSE
 619 };
 620
 621 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_volume_changed_ARG_volume =
 622 {
 623   {
 624     -1,
 625     (gchar *) "volume",
 626     (gchar *) "n",
 627     NULL
 628   },
 629   FALSE
 630 };
 631
 632 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_volume_changed_ARG_pointers[] =
 633 {
 634   &_audiomanager_commandinterface_signal_info_volume_changed_ARG_sinkID,
 635   &_audiomanager_commandinterface_signal_info_volume_changed_ARG_volume,
 636   NULL
 637 };
 638
 639 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_volume_changed =
 640 {
 641   {
 642     -1,
 643     (gchar *) "VolumeChanged",
 644     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_volume_changed_ARG_pointers,
 645     NULL
 646   },
 647   "volume-changed"
 648 };
 649
 650 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_sinkID =
 651 {
 652   {
 653     -1,
 654     (gchar *) "sinkID",
 655     (gchar *) "q",
 656     NULL
 657   },
 658   FALSE
 659 };
 660
 661 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_muteState =
 662 {
 663   {
 664     -1,
 665     (gchar *) "muteState",
 666     (gchar *) "n",
 667     NULL
 668   },
 669   FALSE
 670 };
 671
 672 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_pointers[] =
 673 {
 674   &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_sinkID,
 675   &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_muteState,
 676   NULL
 677 };
 678
 679 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed =
 680 {
 681   {
 682     -1,
 683     (gchar *) "SinkMuteStateChanged",
 684     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_pointers,
 685     NULL
 686   },
 687   "sink-mute-state-changed"
 688 };
 689
 690 static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_system_property_changed_ARG_SystemProperty =
 691 {
 692   {
 693     -1,
 694     (gchar *) "SystemProperty",
 695     (gchar *) "(nn)",
 696     NULL
 697   },
 698   FALSE
 699 };
 700
 701 static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_system_property_changed_ARG_pointers[] =
 702 {
 703   &_audiomanager_commandinterface_signal_info_system_property_changed_ARG_SystemProperty,
 704   NULL
 705 };
 706
 707 static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_system_property_changed =
 708 {
 709   {
 710     -1,
 711     (gchar *) "SystemPropertyChanged",
 712     (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_system_property_changed_ARG_pointers,
 713     NULL
 714   },
 715   "system-property-changed"
 716 };
 717
 718 static const _ExtendedGDBusSignalInfo * const _audiomanager_commandinterface_signal_info_pointers[] =
 719 {
 720   &_audiomanager_commandinterface_signal_info_new_main_connection,
 721   &_audiomanager_commandinterface_signal_info_removed_main_connection,
 722   &_audiomanager_commandinterface_signal_info_main_connection_state_changed,
 723   &_audiomanager_commandinterface_signal_info_volume_changed,
 724   &_audiomanager_commandinterface_signal_info_sink_mute_state_changed,
 725   &_audiomanager_commandinterface_signal_info_system_property_changed,
 726   NULL
 727 };
 728
 729 static const _ExtendedGDBusInterfaceInfo _audiomanager_commandinterface_interface_info =
 730 {
 731   {
 732     -1,
 733     (gchar *) "org.genivi.audiomanager.commandinterface",
 734     (GDBusMethodInfo **) &_audiomanager_commandinterface_method_info_pointers,
 735     (GDBusSignalInfo **) &_audiomanager_commandinterface_signal_info_pointers,
 736     NULL,
 737     NULL
 738   },
 739   "audiomanager-commandinterface",
 740 };
 741
 742
 743 /**
 744  * audiomanager_commandinterface_interface_info:
 745  *
 746  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link> D-Bus interface.
 747  *
 748  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 749  */
 750 GDBusInterfaceInfo *
 751 audiomanager_commandinterface_interface_info (void)
 752 {
 753   return (GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct;
 754 }
 755
 756 /**
 757  * audiomanager_commandinterface_override_properties:
 758  * @klass: The class structure for a #GObject<!-- -->-derived class.
 759  * @property_id_begin: The property id to assign to the first overridden property.
 760  *
 761  * Overrides all #GObject properties in the #AudiomanagerCommandinterface interface for a concrete class.
 762  * The properties are overridden in the order they are defined.
 763  *
 764  * Returns: The last property id.
 765  */
 766 guint
 767 audiomanager_commandinterface_override_properties (GObjectClass *klass, guint property_id_begin)
 768 {
 769   return property_id_begin - 1;
 770 }
 771
 772
 773
 774 /**
 775  * AudiomanagerCommandinterface:
 776  *
 777  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>.
 778  */
 779
 780 /**
 781  * AudiomanagerCommandinterfaceIface:
 782  * @parent_iface: The parent interface.
 783  * @handle_connect: Handler for the #AudiomanagerCommandinterface::handle-connect signal.
 784  * @handle_disconnect: Handler for the #AudiomanagerCommandinterface::handle-disconnect signal.
 785  * @handle_get_list_main_connections: Handler for the #AudiomanagerCommandinterface::handle-get-list-main-connections signal.
 786  * @handle_set_sink_mute_state: Handler for the #AudiomanagerCommandinterface::handle-set-sink-mute-state signal.
 787  * @handle_set_volume: Handler for the #AudiomanagerCommandinterface::handle-set-volume signal.
 788  * @handle_volume_step: Handler for the #AudiomanagerCommandinterface::handle-volume-step signal.
 789  * @main_connection_state_changed: Handler for the #AudiomanagerCommandinterface::main-connection-state-changed signal.
 790  * @new_main_connection: Handler for the #AudiomanagerCommandinterface::new-main-connection signal.
 791  * @removed_main_connection: Handler for the #AudiomanagerCommandinterface::removed-main-connection signal.
 792  * @sink_mute_state_changed: Handler for the #AudiomanagerCommandinterface::sink-mute-state-changed signal.
 793  * @system_property_changed: Handler for the #AudiomanagerCommandinterface::system-property-changed signal.
 794  * @volume_changed: Handler for the #AudiomanagerCommandinterface::volume-changed signal.
 795  *
 796  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>.
 797  */
 798
 799 typedef AudiomanagerCommandinterfaceIface AudiomanagerCommandinterfaceInterface;
 800 G_DEFINE_INTERFACE (AudiomanagerCommandinterface, audiomanager_commandinterface, G_TYPE_OBJECT);
 801
 802 static void
 803 audiomanager_commandinterface_default_init (AudiomanagerCommandinterfaceIface *iface)
 804 {
 805   /* GObject signals for incoming D-Bus method calls: */
 806   /**
 807    * AudiomanagerCommandinterface::handle-connect:
 808    * @object: A #AudiomanagerCommandinterface.
 809    * @invocation: A #GDBusMethodInvocation.
 810    * @arg_sourceID: Argument passed by remote caller.
 811    * @arg_sinkID: Argument passed by remote caller.
 812    *
 813    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Connect">Connect()</link> D-Bus method.
 814    *
 815    * 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 audiomanager_commandinterface_complete_connect() 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.
 816    *
 817    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 818    */
 819   g_signal_new ("handle-connect",
 820     G_TYPE_FROM_INTERFACE (iface),
 821     G_SIGNAL_RUN_LAST,
 822     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_connect),
 823     g_signal_accumulator_true_handled,
 824     NULL,
 825     g_cclosure_marshal_generic,
 826     G_TYPE_BOOLEAN,
 827     3,
 828     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
 829
 830   /**
 831    * AudiomanagerCommandinterface::handle-disconnect:
 832    * @object: A #AudiomanagerCommandinterface.
 833    * @invocation: A #GDBusMethodInvocation.
 834    * @arg_mainConnectionID: Argument passed by remote caller.
 835    *
 836    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Disconnect">Disconnect()</link> D-Bus method.
 837    *
 838    * 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 audiomanager_commandinterface_complete_disconnect() 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.
 839    *
 840    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 841    */
 842   g_signal_new ("handle-disconnect",
 843     G_TYPE_FROM_INTERFACE (iface),
 844     G_SIGNAL_RUN_LAST,
 845     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_disconnect),
 846     g_signal_accumulator_true_handled,
 847     NULL,
 848     g_cclosure_marshal_generic,
 849     G_TYPE_BOOLEAN,
 850     2,
 851     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
 852
 853   /**
 854    * AudiomanagerCommandinterface::handle-set-volume:
 855    * @object: A #AudiomanagerCommandinterface.
 856    * @invocation: A #GDBusMethodInvocation.
 857    * @arg_sinkID: Argument passed by remote caller.
 858    * @arg_volume: Argument passed by remote caller.
 859    *
 860    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetVolume">SetVolume()</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 audiomanager_commandinterface_complete_set_volume() 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-set-volume",
 867     G_TYPE_FROM_INTERFACE (iface),
 868     G_SIGNAL_RUN_LAST,
 869     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_set_volume),
 870     g_signal_accumulator_true_handled,
 871     NULL,
 872     g_cclosure_marshal_generic,
 873     G_TYPE_BOOLEAN,
 874     3,
 875     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT);
 876
 877   /**
 878    * AudiomanagerCommandinterface::handle-volume-step:
 879    * @object: A #AudiomanagerCommandinterface.
 880    * @invocation: A #GDBusMethodInvocation.
 881    * @arg_sinkID: Argument passed by remote caller.
 882    * @arg_volumeStep: Argument passed by remote caller.
 883    *
 884    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.VolumeStep">VolumeStep()</link> D-Bus method.
 885    *
 886    * 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 audiomanager_commandinterface_complete_volume_step() 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.
 887    *
 888    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 889    */
 890   g_signal_new ("handle-volume-step",
 891     G_TYPE_FROM_INTERFACE (iface),
 892     G_SIGNAL_RUN_LAST,
 893     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_volume_step),
 894     g_signal_accumulator_true_handled,
 895     NULL,
 896     g_cclosure_marshal_generic,
 897     G_TYPE_BOOLEAN,
 898     3,
 899     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT);
 900
 901   /**
 902    * AudiomanagerCommandinterface::handle-set-sink-mute-state:
 903    * @object: A #AudiomanagerCommandinterface.
 904    * @invocation: A #GDBusMethodInvocation.
 905    * @arg_sinkID: Argument passed by remote caller.
 906    * @arg_muteState: Argument passed by remote caller.
 907    *
 908    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetSinkMuteState">SetSinkMuteState()</link> D-Bus method.
 909    *
 910    * 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 audiomanager_commandinterface_complete_set_sink_mute_state() 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.
 911    *
 912    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 913    */
 914   g_signal_new ("handle-set-sink-mute-state",
 915     G_TYPE_FROM_INTERFACE (iface),
 916     G_SIGNAL_RUN_LAST,
 917     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_set_sink_mute_state),
 918     g_signal_accumulator_true_handled,
 919     NULL,
 920     g_cclosure_marshal_generic,
 921     G_TYPE_BOOLEAN,
 922     3,
 923     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT);
 924
 925   /**
 926    * AudiomanagerCommandinterface::handle-get-list-main-connections:
 927    * @object: A #AudiomanagerCommandinterface.
 928    * @invocation: A #GDBusMethodInvocation.
 929    *
 930    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.GetListMainConnections">GetListMainConnections()</link> D-Bus method.
 931    *
 932    * 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 audiomanager_commandinterface_complete_get_list_main_connections() 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.
 933    *
 934    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
 935    */
 936   g_signal_new ("handle-get-list-main-connections",
 937     G_TYPE_FROM_INTERFACE (iface),
 938     G_SIGNAL_RUN_LAST,
 939     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_get_list_main_connections),
 940     g_signal_accumulator_true_handled,
 941     NULL,
 942     g_cclosure_marshal_generic,
 943     G_TYPE_BOOLEAN,
 944     1,
 945     G_TYPE_DBUS_METHOD_INVOCATION);
 946
 947   /* GObject signals for received D-Bus signals: */
 948   /**
 949    * AudiomanagerCommandinterface::new-main-connection:
 950    * @object: A #AudiomanagerCommandinterface.
 951    * @arg_mainConnection: Argument.
 952    *
 953    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.NewMainConnection">"NewMainConnection"</link> is received.
 954    *
 955    * 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.
 956    */
 957   g_signal_new ("new-main-connection",
 958     G_TYPE_FROM_INTERFACE (iface),
 959     G_SIGNAL_RUN_LAST,
 960     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, new_main_connection),
 961     NULL,
 962     NULL,
 963     g_cclosure_marshal_generic,
 964     G_TYPE_NONE,
 965     1, G_TYPE_VARIANT);
 966
 967   /**
 968    * AudiomanagerCommandinterface::removed-main-connection:
 969    * @object: A #AudiomanagerCommandinterface.
 970    * @arg_mainConnectionId: Argument.
 971    *
 972    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.RemovedMainConnection">"RemovedMainConnection"</link> is received.
 973    *
 974    * 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.
 975    */
 976   g_signal_new ("removed-main-connection",
 977     G_TYPE_FROM_INTERFACE (iface),
 978     G_SIGNAL_RUN_LAST,
 979     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, removed_main_connection),
 980     NULL,
 981     NULL,
 982     g_cclosure_marshal_generic,
 983     G_TYPE_NONE,
 984     1, G_TYPE_UINT);
 985
 986   /**
 987    * AudiomanagerCommandinterface::main-connection-state-changed:
 988    * @object: A #AudiomanagerCommandinterface.
 989    * @arg_connectionID: Argument.
 990    * @arg_connectionState: Argument.
 991    *
 992    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.MainConnectionStateChanged">"MainConnectionStateChanged"</link> is received.
 993    *
 994    * 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.
 995    */
 996   g_signal_new ("main-connection-state-changed",
 997     G_TYPE_FROM_INTERFACE (iface),
 998     G_SIGNAL_RUN_LAST,
 999     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, main_connection_state_changed),
1000     NULL,
1001     NULL,
1002     g_cclosure_marshal_generic,
1003     G_TYPE_NONE,
1004     2, G_TYPE_UINT, G_TYPE_INT);
1005
1006   /**
1007    * AudiomanagerCommandinterface::volume-changed:
1008    * @object: A #AudiomanagerCommandinterface.
1009    * @arg_sinkID: Argument.
1010    * @arg_volume: Argument.
1011    *
1012    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.VolumeChanged">"VolumeChanged"</link> is received.
1013    *
1014    * 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.
1015    */
1016   g_signal_new ("volume-changed",
1017     G_TYPE_FROM_INTERFACE (iface),
1018     G_SIGNAL_RUN_LAST,
1019     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, volume_changed),
1020     NULL,
1021     NULL,
1022     g_cclosure_marshal_generic,
1023     G_TYPE_NONE,
1024     2, G_TYPE_UINT, G_TYPE_INT);
1025
1026   /**
1027    * AudiomanagerCommandinterface::sink-mute-state-changed:
1028    * @object: A #AudiomanagerCommandinterface.
1029    * @arg_sinkID: Argument.
1030    * @arg_muteState: Argument.
1031    *
1032    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.SinkMuteStateChanged">"SinkMuteStateChanged"</link> is received.
1033    *
1034    * 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.
1035    */
1036   g_signal_new ("sink-mute-state-changed",
1037     G_TYPE_FROM_INTERFACE (iface),
1038     G_SIGNAL_RUN_LAST,
1039     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, sink_mute_state_changed),
1040     NULL,
1041     NULL,
1042     g_cclosure_marshal_generic,
1043     G_TYPE_NONE,
1044     2, G_TYPE_UINT, G_TYPE_INT);
1045
1046   /**
1047    * AudiomanagerCommandinterface::system-property-changed:
1048    * @object: A #AudiomanagerCommandinterface.
1049    * @arg_SystemProperty: Argument.
1050    *
1051    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.SystemPropertyChanged">"SystemPropertyChanged"</link> is received.
1052    *
1053    * 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.
1054    */
1055   g_signal_new ("system-property-changed",
1056     G_TYPE_FROM_INTERFACE (iface),
1057     G_SIGNAL_RUN_LAST,
1058     G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, system_property_changed),
1059     NULL,
1060     NULL,
1061     g_cclosure_marshal_generic,
1062     G_TYPE_NONE,
1063     1, G_TYPE_VARIANT);
1064
1065 }
1066
1067 /**
1068  * audiomanager_commandinterface_emit_new_main_connection:
1069  * @object: A #AudiomanagerCommandinterface.
1070  * @arg_mainConnection: Argument to pass with the signal.
1071  *
1072  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.NewMainConnection">"NewMainConnection"</link> D-Bus signal.
1073  */
1074 void
1075 audiomanager_commandinterface_emit_new_main_connection (
1076     AudiomanagerCommandinterface *object,
1077     GVariant *arg_mainConnection)
1078 {
1079   g_signal_emit_by_name (object, "new-main-connection", arg_mainConnection);
1080 }
1081
1082 /**
1083  * audiomanager_commandinterface_emit_removed_main_connection:
1084  * @object: A #AudiomanagerCommandinterface.
1085  * @arg_mainConnectionId: Argument to pass with the signal.
1086  *
1087  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.RemovedMainConnection">"RemovedMainConnection"</link> D-Bus signal.
1088  */
1089 void
1090 audiomanager_commandinterface_emit_removed_main_connection (
1091     AudiomanagerCommandinterface *object,
1092     guint16 arg_mainConnectionId)
1093 {
1094   g_signal_emit_by_name (object, "removed-main-connection", arg_mainConnectionId);
1095 }
1096
1097 /**
1098  * audiomanager_commandinterface_emit_main_connection_state_changed:
1099  * @object: A #AudiomanagerCommandinterface.
1100  * @arg_connectionID: Argument to pass with the signal.
1101  * @arg_connectionState: Argument to pass with the signal.
1102  *
1103  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.MainConnectionStateChanged">"MainConnectionStateChanged"</link> D-Bus signal.
1104  */
1105 void
1106 audiomanager_commandinterface_emit_main_connection_state_changed (
1107     AudiomanagerCommandinterface *object,
1108     guint16 arg_connectionID,
1109     gint16 arg_connectionState)
1110 {
1111   g_signal_emit_by_name (object, "main-connection-state-changed", arg_connectionID, arg_connectionState);
1112 }
1113
1114 /**
1115  * audiomanager_commandinterface_emit_volume_changed:
1116  * @object: A #AudiomanagerCommandinterface.
1117  * @arg_sinkID: Argument to pass with the signal.
1118  * @arg_volume: Argument to pass with the signal.
1119  *
1120  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.VolumeChanged">"VolumeChanged"</link> D-Bus signal.
1121  */
1122 void
1123 audiomanager_commandinterface_emit_volume_changed (
1124     AudiomanagerCommandinterface *object,
1125     guint16 arg_sinkID,
1126     gint16 arg_volume)
1127 {
1128   g_signal_emit_by_name (object, "volume-changed", arg_sinkID, arg_volume);
1129 }
1130
1131 /**
1132  * audiomanager_commandinterface_emit_sink_mute_state_changed:
1133  * @object: A #AudiomanagerCommandinterface.
1134  * @arg_sinkID: Argument to pass with the signal.
1135  * @arg_muteState: Argument to pass with the signal.
1136  *
1137  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.SinkMuteStateChanged">"SinkMuteStateChanged"</link> D-Bus signal.
1138  */
1139 void
1140 audiomanager_commandinterface_emit_sink_mute_state_changed (
1141     AudiomanagerCommandinterface *object,
1142     guint16 arg_sinkID,
1143     gint16 arg_muteState)
1144 {
1145   g_signal_emit_by_name (object, "sink-mute-state-changed", arg_sinkID, arg_muteState);
1146 }
1147
1148 /**
1149  * audiomanager_commandinterface_emit_system_property_changed:
1150  * @object: A #AudiomanagerCommandinterface.
1151  * @arg_SystemProperty: Argument to pass with the signal.
1152  *
1153  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-commandinterface.SystemPropertyChanged">"SystemPropertyChanged"</link> D-Bus signal.
1154  */
1155 void
1156 audiomanager_commandinterface_emit_system_property_changed (
1157     AudiomanagerCommandinterface *object,
1158     GVariant *arg_SystemProperty)
1159 {
1160   g_signal_emit_by_name (object, "system-property-changed", arg_SystemProperty);
1161 }
1162
1163 /**
1164  * audiomanager_commandinterface_call_connect:
1165  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1166  * @arg_sourceID: Argument to pass with the method invocation.
1167  * @arg_sinkID: Argument to pass with the method invocation.
1168  * @cancellable: (allow-none): A #GCancellable or %NULL.
1169  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1170  * @user_data: User data to pass to @callback.
1171  *
1172  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Connect">Connect()</link> D-Bus method on @proxy.
1173  * 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.
1174  * You can then call audiomanager_commandinterface_call_connect_finish() to get the result of the operation.
1175  *
1176  * See audiomanager_commandinterface_call_connect_sync() for the synchronous, blocking version of this method.
1177  */
1178 void
1179 audiomanager_commandinterface_call_connect (
1180     AudiomanagerCommandinterface *proxy,
1181     guint16 arg_sourceID,
1182     guint16 arg_sinkID,
1183     GCancellable *cancellable,
1184     GAsyncReadyCallback callback,
1185     gpointer user_data)
1186 {
1187   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1188     "Connect",
1189     g_variant_new ("(qq)",
1190                    arg_sourceID,
1191                    arg_sinkID),
1192     G_DBUS_CALL_FLAGS_NONE,
1193     -1,
1194     cancellable,
1195     callback,
1196     user_data);
1197 }
1198
1199 /**
1200  * audiomanager_commandinterface_call_connect_finish:
1201  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1202  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1203  * @out_mainConnectionID: (out): Return location for return parameter or %NULL to ignore.
1204  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_connect().
1205  * @error: Return location for error or %NULL.
1206  *
1207  * Finishes an operation started with audiomanager_commandinterface_call_connect().
1208  *
1209  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1210  */
1211 gboolean
1212 audiomanager_commandinterface_call_connect_finish (
1213     AudiomanagerCommandinterface *proxy,
1214     gint16 *out_result,
1215     guint16 *out_mainConnectionID,
1216     GAsyncResult *res,
1217     GError **error)
1218 {
1219   GVariant *_ret;
1220   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1221   if (_ret == NULL)
1222     goto _out;
1223   g_variant_get (_ret,
1224                  "(nq)",
1225                  out_result,
1226                  out_mainConnectionID);
1227   g_variant_unref (_ret);
1228 _out:
1229   return _ret != NULL;
1230 }
1231
1232 /**
1233  * audiomanager_commandinterface_call_connect_sync:
1234  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1235  * @arg_sourceID: Argument to pass with the method invocation.
1236  * @arg_sinkID: Argument to pass with the method invocation.
1237  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1238  * @out_mainConnectionID: (out): Return location for return parameter or %NULL to ignore.
1239  * @cancellable: (allow-none): A #GCancellable or %NULL.
1240  * @error: Return location for error or %NULL.
1241  *
1242  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Connect">Connect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1243  *
1244  * See audiomanager_commandinterface_call_connect() for the asynchronous version of this method.
1245  *
1246  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1247  */
1248 gboolean
1249 audiomanager_commandinterface_call_connect_sync (
1250     AudiomanagerCommandinterface *proxy,
1251     guint16 arg_sourceID,
1252     guint16 arg_sinkID,
1253     gint16 *out_result,
1254     guint16 *out_mainConnectionID,
1255     GCancellable *cancellable,
1256     GError **error)
1257 {
1258   GVariant *_ret;
1259   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1260     "Connect",
1261     g_variant_new ("(qq)",
1262                    arg_sourceID,
1263                    arg_sinkID),
1264     G_DBUS_CALL_FLAGS_NONE,
1265     -1,
1266     cancellable,
1267     error);
1268   if (_ret == NULL)
1269     goto _out;
1270   g_variant_get (_ret,
1271                  "(nq)",
1272                  out_result,
1273                  out_mainConnectionID);
1274   g_variant_unref (_ret);
1275 _out:
1276   return _ret != NULL;
1277 }
1278
1279 /**
1280  * audiomanager_commandinterface_call_disconnect:
1281  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1282  * @arg_mainConnectionID: Argument to pass with the method invocation.
1283  * @cancellable: (allow-none): A #GCancellable or %NULL.
1284  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1285  * @user_data: User data to pass to @callback.
1286  *
1287  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Disconnect">Disconnect()</link> D-Bus method on @proxy.
1288  * 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.
1289  * You can then call audiomanager_commandinterface_call_disconnect_finish() to get the result of the operation.
1290  *
1291  * See audiomanager_commandinterface_call_disconnect_sync() for the synchronous, blocking version of this method.
1292  */
1293 void
1294 audiomanager_commandinterface_call_disconnect (
1295     AudiomanagerCommandinterface *proxy,
1296     guint16 arg_mainConnectionID,
1297     GCancellable *cancellable,
1298     GAsyncReadyCallback callback,
1299     gpointer user_data)
1300 {
1301   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1302     "Disconnect",
1303     g_variant_new ("(q)",
1304                    arg_mainConnectionID),
1305     G_DBUS_CALL_FLAGS_NONE,
1306     -1,
1307     cancellable,
1308     callback,
1309     user_data);
1310 }
1311
1312 /**
1313  * audiomanager_commandinterface_call_disconnect_finish:
1314  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1315  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1316  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_disconnect().
1317  * @error: Return location for error or %NULL.
1318  *
1319  * Finishes an operation started with audiomanager_commandinterface_call_disconnect().
1320  *
1321  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1322  */
1323 gboolean
1324 audiomanager_commandinterface_call_disconnect_finish (
1325     AudiomanagerCommandinterface *proxy,
1326     gint16 *out_result,
1327     GAsyncResult *res,
1328     GError **error)
1329 {
1330   GVariant *_ret;
1331   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1332   if (_ret == NULL)
1333     goto _out;
1334   g_variant_get (_ret,
1335                  "(n)",
1336                  out_result);
1337   g_variant_unref (_ret);
1338 _out:
1339   return _ret != NULL;
1340 }
1341
1342 /**
1343  * audiomanager_commandinterface_call_disconnect_sync:
1344  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1345  * @arg_mainConnectionID: Argument to pass with the method invocation.
1346  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1347  * @cancellable: (allow-none): A #GCancellable or %NULL.
1348  * @error: Return location for error or %NULL.
1349  *
1350  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Disconnect">Disconnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1351  *
1352  * See audiomanager_commandinterface_call_disconnect() for the asynchronous version of this method.
1353  *
1354  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1355  */
1356 gboolean
1357 audiomanager_commandinterface_call_disconnect_sync (
1358     AudiomanagerCommandinterface *proxy,
1359     guint16 arg_mainConnectionID,
1360     gint16 *out_result,
1361     GCancellable *cancellable,
1362     GError **error)
1363 {
1364   GVariant *_ret;
1365   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1366     "Disconnect",
1367     g_variant_new ("(q)",
1368                    arg_mainConnectionID),
1369     G_DBUS_CALL_FLAGS_NONE,
1370     -1,
1371     cancellable,
1372     error);
1373   if (_ret == NULL)
1374     goto _out;
1375   g_variant_get (_ret,
1376                  "(n)",
1377                  out_result);
1378   g_variant_unref (_ret);
1379 _out:
1380   return _ret != NULL;
1381 }
1382
1383 /**
1384  * audiomanager_commandinterface_call_set_volume:
1385  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1386  * @arg_sinkID: Argument to pass with the method invocation.
1387  * @arg_volume: Argument to pass with the method invocation.
1388  * @cancellable: (allow-none): A #GCancellable or %NULL.
1389  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1390  * @user_data: User data to pass to @callback.
1391  *
1392  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetVolume">SetVolume()</link> D-Bus method on @proxy.
1393  * 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.
1394  * You can then call audiomanager_commandinterface_call_set_volume_finish() to get the result of the operation.
1395  *
1396  * See audiomanager_commandinterface_call_set_volume_sync() for the synchronous, blocking version of this method.
1397  */
1398 void
1399 audiomanager_commandinterface_call_set_volume (
1400     AudiomanagerCommandinterface *proxy,
1401     guint16 arg_sinkID,
1402     gint16 arg_volume,
1403     GCancellable *cancellable,
1404     GAsyncReadyCallback callback,
1405     gpointer user_data)
1406 {
1407   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1408     "SetVolume",
1409     g_variant_new ("(qn)",
1410                    arg_sinkID,
1411                    arg_volume),
1412     G_DBUS_CALL_FLAGS_NONE,
1413     -1,
1414     cancellable,
1415     callback,
1416     user_data);
1417 }
1418
1419 /**
1420  * audiomanager_commandinterface_call_set_volume_finish:
1421  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1422  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1423  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_set_volume().
1424  * @error: Return location for error or %NULL.
1425  *
1426  * Finishes an operation started with audiomanager_commandinterface_call_set_volume().
1427  *
1428  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1429  */
1430 gboolean
1431 audiomanager_commandinterface_call_set_volume_finish (
1432     AudiomanagerCommandinterface *proxy,
1433     gint16 *out_result,
1434     GAsyncResult *res,
1435     GError **error)
1436 {
1437   GVariant *_ret;
1438   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1439   if (_ret == NULL)
1440     goto _out;
1441   g_variant_get (_ret,
1442                  "(n)",
1443                  out_result);
1444   g_variant_unref (_ret);
1445 _out:
1446   return _ret != NULL;
1447 }
1448
1449 /**
1450  * audiomanager_commandinterface_call_set_volume_sync:
1451  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1452  * @arg_sinkID: Argument to pass with the method invocation.
1453  * @arg_volume: Argument to pass with the method invocation.
1454  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1455  * @cancellable: (allow-none): A #GCancellable or %NULL.
1456  * @error: Return location for error or %NULL.
1457  *
1458  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetVolume">SetVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1459  *
1460  * See audiomanager_commandinterface_call_set_volume() for the asynchronous version of this method.
1461  *
1462  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1463  */
1464 gboolean
1465 audiomanager_commandinterface_call_set_volume_sync (
1466     AudiomanagerCommandinterface *proxy,
1467     guint16 arg_sinkID,
1468     gint16 arg_volume,
1469     gint16 *out_result,
1470     GCancellable *cancellable,
1471     GError **error)
1472 {
1473   GVariant *_ret;
1474   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1475     "SetVolume",
1476     g_variant_new ("(qn)",
1477                    arg_sinkID,
1478                    arg_volume),
1479     G_DBUS_CALL_FLAGS_NONE,
1480     -1,
1481     cancellable,
1482     error);
1483   if (_ret == NULL)
1484     goto _out;
1485   g_variant_get (_ret,
1486                  "(n)",
1487                  out_result);
1488   g_variant_unref (_ret);
1489 _out:
1490   return _ret != NULL;
1491 }
1492
1493 /**
1494  * audiomanager_commandinterface_call_volume_step:
1495  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1496  * @arg_sinkID: Argument to pass with the method invocation.
1497  * @arg_volumeStep: Argument to pass with the method invocation.
1498  * @cancellable: (allow-none): A #GCancellable or %NULL.
1499  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1500  * @user_data: User data to pass to @callback.
1501  *
1502  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.VolumeStep">VolumeStep()</link> D-Bus method on @proxy.
1503  * 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.
1504  * You can then call audiomanager_commandinterface_call_volume_step_finish() to get the result of the operation.
1505  *
1506  * See audiomanager_commandinterface_call_volume_step_sync() for the synchronous, blocking version of this method.
1507  */
1508 void
1509 audiomanager_commandinterface_call_volume_step (
1510     AudiomanagerCommandinterface *proxy,
1511     guint16 arg_sinkID,
1512     gint16 arg_volumeStep,
1513     GCancellable *cancellable,
1514     GAsyncReadyCallback callback,
1515     gpointer user_data)
1516 {
1517   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1518     "VolumeStep",
1519     g_variant_new ("(qn)",
1520                    arg_sinkID,
1521                    arg_volumeStep),
1522     G_DBUS_CALL_FLAGS_NONE,
1523     -1,
1524     cancellable,
1525     callback,
1526     user_data);
1527 }
1528
1529 /**
1530  * audiomanager_commandinterface_call_volume_step_finish:
1531  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1532  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1533  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_volume_step().
1534  * @error: Return location for error or %NULL.
1535  *
1536  * Finishes an operation started with audiomanager_commandinterface_call_volume_step().
1537  *
1538  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1539  */
1540 gboolean
1541 audiomanager_commandinterface_call_volume_step_finish (
1542     AudiomanagerCommandinterface *proxy,
1543     gint16 *out_result,
1544     GAsyncResult *res,
1545     GError **error)
1546 {
1547   GVariant *_ret;
1548   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1549   if (_ret == NULL)
1550     goto _out;
1551   g_variant_get (_ret,
1552                  "(n)",
1553                  out_result);
1554   g_variant_unref (_ret);
1555 _out:
1556   return _ret != NULL;
1557 }
1558
1559 /**
1560  * audiomanager_commandinterface_call_volume_step_sync:
1561  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1562  * @arg_sinkID: Argument to pass with the method invocation.
1563  * @arg_volumeStep: Argument to pass with the method invocation.
1564  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1565  * @cancellable: (allow-none): A #GCancellable or %NULL.
1566  * @error: Return location for error or %NULL.
1567  *
1568  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.VolumeStep">VolumeStep()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1569  *
1570  * See audiomanager_commandinterface_call_volume_step() for the asynchronous version of this method.
1571  *
1572  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1573  */
1574 gboolean
1575 audiomanager_commandinterface_call_volume_step_sync (
1576     AudiomanagerCommandinterface *proxy,
1577     guint16 arg_sinkID,
1578     gint16 arg_volumeStep,
1579     gint16 *out_result,
1580     GCancellable *cancellable,
1581     GError **error)
1582 {
1583   GVariant *_ret;
1584   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1585     "VolumeStep",
1586     g_variant_new ("(qn)",
1587                    arg_sinkID,
1588                    arg_volumeStep),
1589     G_DBUS_CALL_FLAGS_NONE,
1590     -1,
1591     cancellable,
1592     error);
1593   if (_ret == NULL)
1594     goto _out;
1595   g_variant_get (_ret,
1596                  "(n)",
1597                  out_result);
1598   g_variant_unref (_ret);
1599 _out:
1600   return _ret != NULL;
1601 }
1602
1603 /**
1604  * audiomanager_commandinterface_call_set_sink_mute_state:
1605  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1606  * @arg_sinkID: Argument to pass with the method invocation.
1607  * @arg_muteState: Argument to pass with the method invocation.
1608  * @cancellable: (allow-none): A #GCancellable or %NULL.
1609  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1610  * @user_data: User data to pass to @callback.
1611  *
1612  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetSinkMuteState">SetSinkMuteState()</link> D-Bus method on @proxy.
1613  * 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.
1614  * You can then call audiomanager_commandinterface_call_set_sink_mute_state_finish() to get the result of the operation.
1615  *
1616  * See audiomanager_commandinterface_call_set_sink_mute_state_sync() for the synchronous, blocking version of this method.
1617  */
1618 void
1619 audiomanager_commandinterface_call_set_sink_mute_state (
1620     AudiomanagerCommandinterface *proxy,
1621     guint16 arg_sinkID,
1622     gint16 arg_muteState,
1623     GCancellable *cancellable,
1624     GAsyncReadyCallback callback,
1625     gpointer user_data)
1626 {
1627   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1628     "SetSinkMuteState",
1629     g_variant_new ("(qn)",
1630                    arg_sinkID,
1631                    arg_muteState),
1632     G_DBUS_CALL_FLAGS_NONE,
1633     -1,
1634     cancellable,
1635     callback,
1636     user_data);
1637 }
1638
1639 /**
1640  * audiomanager_commandinterface_call_set_sink_mute_state_finish:
1641  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1642  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1643  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_set_sink_mute_state().
1644  * @error: Return location for error or %NULL.
1645  *
1646  * Finishes an operation started with audiomanager_commandinterface_call_set_sink_mute_state().
1647  *
1648  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1649  */
1650 gboolean
1651 audiomanager_commandinterface_call_set_sink_mute_state_finish (
1652     AudiomanagerCommandinterface *proxy,
1653     gint16 *out_result,
1654     GAsyncResult *res,
1655     GError **error)
1656 {
1657   GVariant *_ret;
1658   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1659   if (_ret == NULL)
1660     goto _out;
1661   g_variant_get (_ret,
1662                  "(n)",
1663                  out_result);
1664   g_variant_unref (_ret);
1665 _out:
1666   return _ret != NULL;
1667 }
1668
1669 /**
1670  * audiomanager_commandinterface_call_set_sink_mute_state_sync:
1671  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1672  * @arg_sinkID: Argument to pass with the method invocation.
1673  * @arg_muteState: Argument to pass with the method invocation.
1674  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1675  * @cancellable: (allow-none): A #GCancellable or %NULL.
1676  * @error: Return location for error or %NULL.
1677  *
1678  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetSinkMuteState">SetSinkMuteState()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1679  *
1680  * See audiomanager_commandinterface_call_set_sink_mute_state() for the asynchronous version of this method.
1681  *
1682  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1683  */
1684 gboolean
1685 audiomanager_commandinterface_call_set_sink_mute_state_sync (
1686     AudiomanagerCommandinterface *proxy,
1687     guint16 arg_sinkID,
1688     gint16 arg_muteState,
1689     gint16 *out_result,
1690     GCancellable *cancellable,
1691     GError **error)
1692 {
1693   GVariant *_ret;
1694   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1695     "SetSinkMuteState",
1696     g_variant_new ("(qn)",
1697                    arg_sinkID,
1698                    arg_muteState),
1699     G_DBUS_CALL_FLAGS_NONE,
1700     -1,
1701     cancellable,
1702     error);
1703   if (_ret == NULL)
1704     goto _out;
1705   g_variant_get (_ret,
1706                  "(n)",
1707                  out_result);
1708   g_variant_unref (_ret);
1709 _out:
1710   return _ret != NULL;
1711 }
1712
1713 /**
1714  * audiomanager_commandinterface_call_get_list_main_connections:
1715  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1716  * @cancellable: (allow-none): A #GCancellable or %NULL.
1717  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
1718  * @user_data: User data to pass to @callback.
1719  *
1720  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.GetListMainConnections">GetListMainConnections()</link> D-Bus method on @proxy.
1721  * 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.
1722  * You can then call audiomanager_commandinterface_call_get_list_main_connections_finish() to get the result of the operation.
1723  *
1724  * See audiomanager_commandinterface_call_get_list_main_connections_sync() for the synchronous, blocking version of this method.
1725  */
1726 void
1727 audiomanager_commandinterface_call_get_list_main_connections (
1728     AudiomanagerCommandinterface *proxy,
1729     GCancellable *cancellable,
1730     GAsyncReadyCallback callback,
1731     gpointer user_data)
1732 {
1733   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
1734     "GetListMainConnections",
1735     g_variant_new ("()"),
1736     G_DBUS_CALL_FLAGS_NONE,
1737     -1,
1738     cancellable,
1739     callback,
1740     user_data);
1741 }
1742
1743 /**
1744  * audiomanager_commandinterface_call_get_list_main_connections_finish:
1745  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1746  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1747  * @out_listConnections: (out): Return location for return parameter or %NULL to ignore.
1748  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_get_list_main_connections().
1749  * @error: Return location for error or %NULL.
1750  *
1751  * Finishes an operation started with audiomanager_commandinterface_call_get_list_main_connections().
1752  *
1753  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1754  */
1755 gboolean
1756 audiomanager_commandinterface_call_get_list_main_connections_finish (
1757     AudiomanagerCommandinterface *proxy,
1758     gint16 *out_result,
1759     GVariant **out_listConnections,
1760     GAsyncResult *res,
1761     GError **error)
1762 {
1763   GVariant *_ret;
1764   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
1765   if (_ret == NULL)
1766     goto _out;
1767   g_variant_get (_ret,
1768                  "(n@a(qqqnn))",
1769                  out_result,
1770                  out_listConnections);
1771   g_variant_unref (_ret);
1772 _out:
1773   return _ret != NULL;
1774 }
1775
1776 /**
1777  * audiomanager_commandinterface_call_get_list_main_connections_sync:
1778  * @proxy: A #AudiomanagerCommandinterfaceProxy.
1779  * @out_result: (out): Return location for return parameter or %NULL to ignore.
1780  * @out_listConnections: (out): Return location for return parameter or %NULL to ignore.
1781  * @cancellable: (allow-none): A #GCancellable or %NULL.
1782  * @error: Return location for error or %NULL.
1783  *
1784  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.GetListMainConnections">GetListMainConnections()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
1785  *
1786  * See audiomanager_commandinterface_call_get_list_main_connections() for the asynchronous version of this method.
1787  *
1788  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
1789  */
1790 gboolean
1791 audiomanager_commandinterface_call_get_list_main_connections_sync (
1792     AudiomanagerCommandinterface *proxy,
1793     gint16 *out_result,
1794     GVariant **out_listConnections,
1795     GCancellable *cancellable,
1796     GError **error)
1797 {
1798   GVariant *_ret;
1799   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
1800     "GetListMainConnections",
1801     g_variant_new ("()"),
1802     G_DBUS_CALL_FLAGS_NONE,
1803     -1,
1804     cancellable,
1805     error);
1806   if (_ret == NULL)
1807     goto _out;
1808   g_variant_get (_ret,
1809                  "(n@a(qqqnn))",
1810                  out_result,
1811                  out_listConnections);
1812   g_variant_unref (_ret);
1813 _out:
1814   return _ret != NULL;
1815 }
1816
1817 /**
1818  * audiomanager_commandinterface_complete_connect:
1819  * @object: A #AudiomanagerCommandinterface.
1820  * @invocation: (transfer full): A #GDBusMethodInvocation.
1821  * @result: Parameter to return.
1822  * @mainConnectionID: Parameter to return.
1823  *
1824  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Connect">Connect()</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.
1825  *
1826  * This method will free @invocation, you cannot use it afterwards.
1827  */
1828 void
1829 audiomanager_commandinterface_complete_connect (
1830     AudiomanagerCommandinterface *object,
1831     GDBusMethodInvocation *invocation,
1832     gint16 result,
1833     guint16 mainConnectionID)
1834 {
1835   g_dbus_method_invocation_return_value (invocation,
1836     g_variant_new ("(nq)",
1837                    result,
1838                    mainConnectionID));
1839 }
1840
1841 /**
1842  * audiomanager_commandinterface_complete_disconnect:
1843  * @object: A #AudiomanagerCommandinterface.
1844  * @invocation: (transfer full): A #GDBusMethodInvocation.
1845  * @result: Parameter to return.
1846  *
1847  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.Disconnect">Disconnect()</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.
1848  *
1849  * This method will free @invocation, you cannot use it afterwards.
1850  */
1851 void
1852 audiomanager_commandinterface_complete_disconnect (
1853     AudiomanagerCommandinterface *object,
1854     GDBusMethodInvocation *invocation,
1855     gint16 result)
1856 {
1857   g_dbus_method_invocation_return_value (invocation,
1858     g_variant_new ("(n)",
1859                    result));
1860 }
1861
1862 /**
1863  * audiomanager_commandinterface_complete_set_volume:
1864  * @object: A #AudiomanagerCommandinterface.
1865  * @invocation: (transfer full): A #GDBusMethodInvocation.
1866  * @result: Parameter to return.
1867  *
1868  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetVolume">SetVolume()</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.
1869  *
1870  * This method will free @invocation, you cannot use it afterwards.
1871  */
1872 void
1873 audiomanager_commandinterface_complete_set_volume (
1874     AudiomanagerCommandinterface *object,
1875     GDBusMethodInvocation *invocation,
1876     gint16 result)
1877 {
1878   g_dbus_method_invocation_return_value (invocation,
1879     g_variant_new ("(n)",
1880                    result));
1881 }
1882
1883 /**
1884  * audiomanager_commandinterface_complete_volume_step:
1885  * @object: A #AudiomanagerCommandinterface.
1886  * @invocation: (transfer full): A #GDBusMethodInvocation.
1887  * @result: Parameter to return.
1888  *
1889  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.VolumeStep">VolumeStep()</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.
1890  *
1891  * This method will free @invocation, you cannot use it afterwards.
1892  */
1893 void
1894 audiomanager_commandinterface_complete_volume_step (
1895     AudiomanagerCommandinterface *object,
1896     GDBusMethodInvocation *invocation,
1897     gint16 result)
1898 {
1899   g_dbus_method_invocation_return_value (invocation,
1900     g_variant_new ("(n)",
1901                    result));
1902 }
1903
1904 /**
1905  * audiomanager_commandinterface_complete_set_sink_mute_state:
1906  * @object: A #AudiomanagerCommandinterface.
1907  * @invocation: (transfer full): A #GDBusMethodInvocation.
1908  * @result: Parameter to return.
1909  *
1910  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.SetSinkMuteState">SetSinkMuteState()</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.
1911  *
1912  * This method will free @invocation, you cannot use it afterwards.
1913  */
1914 void
1915 audiomanager_commandinterface_complete_set_sink_mute_state (
1916     AudiomanagerCommandinterface *object,
1917     GDBusMethodInvocation *invocation,
1918     gint16 result)
1919 {
1920   g_dbus_method_invocation_return_value (invocation,
1921     g_variant_new ("(n)",
1922                    result));
1923 }
1924
1925 /**
1926  * audiomanager_commandinterface_complete_get_list_main_connections:
1927  * @object: A #AudiomanagerCommandinterface.
1928  * @invocation: (transfer full): A #GDBusMethodInvocation.
1929  * @result: Parameter to return.
1930  * @listConnections: Parameter to return.
1931  *
1932  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-commandinterface.GetListMainConnections">GetListMainConnections()</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.
1933  *
1934  * This method will free @invocation, you cannot use it afterwards.
1935  */
1936 void
1937 audiomanager_commandinterface_complete_get_list_main_connections (
1938     AudiomanagerCommandinterface *object,
1939     GDBusMethodInvocation *invocation,
1940     gint16 result,
1941     GVariant *listConnections)
1942 {
1943   g_dbus_method_invocation_return_value (invocation,
1944     g_variant_new ("(n@a(qqqnn))",
1945                    result,
1946                    listConnections));
1947 }
1948
1949 /* ------------------------------------------------------------------------ */
1950
1951 /**
1952  * AudiomanagerCommandinterfaceProxy:
1953  *
1954  * The #AudiomanagerCommandinterfaceProxy structure contains only private data and should only be accessed using the provided API.
1955  */
1956
1957 /**
1958  * AudiomanagerCommandinterfaceProxyClass:
1959  * @parent_class: The parent class.
1960  *
1961  * Class structure for #AudiomanagerCommandinterfaceProxy.
1962  */
1963
1964 struct _AudiomanagerCommandinterfaceProxyPrivate
1965 {
1966   GData *qdata;
1967 };
1968
1969 static void audiomanager_commandinterface_proxy_iface_init (AudiomanagerCommandinterfaceIface *iface);
1970
1971 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
1972 G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceProxy, audiomanager_commandinterface_proxy, G_TYPE_DBUS_PROXY,
1973                          G_ADD_PRIVATE (AudiomanagerCommandinterfaceProxy)
1974                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_proxy_iface_init));
1975
1976 #else
1977 G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceProxy, audiomanager_commandinterface_proxy, G_TYPE_DBUS_PROXY,
1978                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_proxy_iface_init));
1979
1980 #endif
1981 static void
1982 audiomanager_commandinterface_proxy_finalize (GObject *object)
1983 {
1984   AudiomanagerCommandinterfaceProxy *proxy = AUDIOMANAGER_COMMANDINTERFACE_PROXY (object);
1985   g_datalist_clear (&proxy->priv->qdata);
1986   G_OBJECT_CLASS (audiomanager_commandinterface_proxy_parent_class)->finalize (object);
1987 }
1988
1989 static void
1990 audiomanager_commandinterface_proxy_get_property (GObject      *object,
1991   guint         prop_id,
1992   GValue       *value,
1993   GParamSpec   *pspec G_GNUC_UNUSED)
1994 {
1995 }
1996
1997 static void
1998 audiomanager_commandinterface_proxy_set_property (GObject      *object,
1999   guint         prop_id,
2000   const GValue *value,
2001   GParamSpec   *pspec G_GNUC_UNUSED)
2002 {
2003 }
2004
2005 static void
2006 audiomanager_commandinterface_proxy_g_signal (GDBusProxy *proxy,
2007   const gchar *sender_name G_GNUC_UNUSED,
2008   const gchar *signal_name,
2009   GVariant *parameters)
2010 {
2011   _ExtendedGDBusSignalInfo *info;
2012   GVariantIter iter;
2013   GVariant *child;
2014   GValue *paramv;
2015   guint num_params;
2016   guint n;
2017   guint signal_id;
2018   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, signal_name);
2019   if (info == NULL)
2020     return;
2021   num_params = g_variant_n_children (parameters);
2022   paramv = g_new0 (GValue, num_params + 1);
2023   g_value_init (&paramv[0], TYPE_AUDIOMANAGER_COMMANDINTERFACE);
2024   g_value_set_object (&paramv[0], proxy);
2025   g_variant_iter_init (&iter, parameters);
2026   n = 1;
2027   while ((child = g_variant_iter_next_value (&iter)) != NULL)
2028     {
2029       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
2030       if (arg_info->use_gvariant)
2031         {
2032           g_value_init (&paramv[n], G_TYPE_VARIANT);
2033           g_value_set_variant (&paramv[n], child);
2034           n++;
2035         }
2036       else
2037         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
2038       g_variant_unref (child);
2039     }
2040   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_COMMANDINTERFACE);
2041   g_signal_emitv (paramv, signal_id, 0, NULL);
2042   for (n = 0; n < num_params + 1; n++)
2043     g_value_unset (&paramv[n]);
2044   g_free (paramv);
2045 }
2046
2047 static void
2048 audiomanager_commandinterface_proxy_g_properties_changed (GDBusProxy *_proxy,
2049   GVariant *changed_properties,
2050   const gchar *const *invalidated_properties)
2051 {
2052   AudiomanagerCommandinterfaceProxy *proxy = AUDIOMANAGER_COMMANDINTERFACE_PROXY (_proxy);
2053   guint n;
2054   const gchar *key;
2055   GVariantIter *iter;
2056   _ExtendedGDBusPropertyInfo *info;
2057   g_variant_get (changed_properties, "a{sv}", &iter);
2058   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
2059     {
2060       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, key);
2061       g_datalist_remove_data (&proxy->priv->qdata, key);
2062       if (info != NULL)
2063         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
2064     }
2065   g_variant_iter_free (iter);
2066   for (n = 0; invalidated_properties[n] != NULL; n++)
2067     {
2068       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, invalidated_properties[n]);
2069       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
2070       if (info != NULL)
2071         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
2072     }
2073 }
2074
2075 static void
2076 audiomanager_commandinterface_proxy_init (AudiomanagerCommandinterfaceProxy *proxy)
2077 {
2078 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2079   proxy->priv = audiomanager_commandinterface_proxy_get_instance_private (proxy);
2080 #else
2081   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyPrivate);
2082 #endif
2083
2084   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_commandinterface_interface_info ());
2085 }
2086
2087 static void
2088 audiomanager_commandinterface_proxy_class_init (AudiomanagerCommandinterfaceProxyClass *klass)
2089 {
2090   GObjectClass *gobject_class;
2091   GDBusProxyClass *proxy_class;
2092
2093   gobject_class = G_OBJECT_CLASS (klass);
2094   gobject_class->finalize     = audiomanager_commandinterface_proxy_finalize;
2095   gobject_class->get_property = audiomanager_commandinterface_proxy_get_property;
2096   gobject_class->set_property = audiomanager_commandinterface_proxy_set_property;
2097
2098   proxy_class = G_DBUS_PROXY_CLASS (klass);
2099   proxy_class->g_signal = audiomanager_commandinterface_proxy_g_signal;
2100   proxy_class->g_properties_changed = audiomanager_commandinterface_proxy_g_properties_changed;
2101
2102 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
2103   g_type_class_add_private (klass, sizeof (AudiomanagerCommandinterfaceProxyPrivate));
2104 #endif
2105 }
2106
2107 static void
2108 audiomanager_commandinterface_proxy_iface_init (AudiomanagerCommandinterfaceIface *iface)
2109 {
2110 }
2111
2112 /**
2113  * audiomanager_commandinterface_proxy_new:
2114  * @connection: A #GDBusConnection.
2115  * @flags: Flags from the #GDBusProxyFlags enumeration.
2116  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
2117  * @object_path: An object path.
2118  * @cancellable: (allow-none): A #GCancellable or %NULL.
2119  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
2120  * @user_data: User data to pass to @callback.
2121  *
2122  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>. See g_dbus_proxy_new() for more details.
2123  *
2124  * 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.
2125  * You can then call audiomanager_commandinterface_proxy_new_finish() to get the result of the operation.
2126  *
2127  * See audiomanager_commandinterface_proxy_new_sync() for the synchronous, blocking version of this constructor.
2128  */
2129 void
2130 audiomanager_commandinterface_proxy_new (
2131     GDBusConnection     *connection,
2132     GDBusProxyFlags      flags,
2133     const gchar         *name,
2134     const gchar         *object_path,
2135     GCancellable        *cancellable,
2136     GAsyncReadyCallback  callback,
2137     gpointer             user_data)
2138 {
2139   g_async_initable_new_async (TYPE_AUDIOMANAGER_COMMANDINTERFACE_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.genivi.audiomanager.commandinterface", NULL);
2140 }
2141
2142 /**
2143  * audiomanager_commandinterface_proxy_new_finish:
2144  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_proxy_new().
2145  * @error: Return location for error or %NULL
2146  *
2147  * Finishes an operation started with audiomanager_commandinterface_proxy_new().
2148  *
2149  * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set.
2150  */
2151 AudiomanagerCommandinterface *
2152 audiomanager_commandinterface_proxy_new_finish (
2153     GAsyncResult        *res,
2154     GError             **error)
2155 {
2156   GObject *ret;
2157   GObject *source_object;
2158   source_object = g_async_result_get_source_object (res);
2159   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
2160   g_object_unref (source_object);
2161   if (ret != NULL)
2162     return AUDIOMANAGER_COMMANDINTERFACE (ret);
2163   else
2164     return NULL;
2165 }
2166
2167 /**
2168  * audiomanager_commandinterface_proxy_new_sync:
2169  * @connection: A #GDBusConnection.
2170  * @flags: Flags from the #GDBusProxyFlags enumeration.
2171  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
2172  * @object_path: An object path.
2173  * @cancellable: (allow-none): A #GCancellable or %NULL.
2174  * @error: Return location for error or %NULL
2175  *
2176  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>. See g_dbus_proxy_new_sync() for more details.
2177  *
2178  * The calling thread is blocked until a reply is received.
2179  *
2180  * See audiomanager_commandinterface_proxy_new() for the asynchronous version of this constructor.
2181  *
2182  * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set.
2183  */
2184 AudiomanagerCommandinterface *
2185 audiomanager_commandinterface_proxy_new_sync (
2186     GDBusConnection     *connection,
2187     GDBusProxyFlags      flags,
2188     const gchar         *name,
2189     const gchar         *object_path,
2190     GCancellable        *cancellable,
2191     GError             **error)
2192 {
2193   GInitable *ret;
2194   ret = g_initable_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL);
2195   if (ret != NULL)
2196     return AUDIOMANAGER_COMMANDINTERFACE (ret);
2197   else
2198     return NULL;
2199 }
2200
2201
2202 /**
2203  * audiomanager_commandinterface_proxy_new_for_bus:
2204  * @bus_type: A #GBusType.
2205  * @flags: Flags from the #GDBusProxyFlags enumeration.
2206  * @name: A bus name (well-known or unique).
2207  * @object_path: An object path.
2208  * @cancellable: (allow-none): A #GCancellable or %NULL.
2209  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
2210  * @user_data: User data to pass to @callback.
2211  *
2212  * Like audiomanager_commandinterface_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
2213  *
2214  * 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.
2215  * You can then call audiomanager_commandinterface_proxy_new_for_bus_finish() to get the result of the operation.
2216  *
2217  * See audiomanager_commandinterface_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
2218  */
2219 void
2220 audiomanager_commandinterface_proxy_new_for_bus (
2221     GBusType             bus_type,
2222     GDBusProxyFlags      flags,
2223     const gchar         *name,
2224     const gchar         *object_path,
2225     GCancellable        *cancellable,
2226     GAsyncReadyCallback  callback,
2227     gpointer             user_data)
2228 {
2229   g_async_initable_new_async (TYPE_AUDIOMANAGER_COMMANDINTERFACE_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.genivi.audiomanager.commandinterface", NULL);
2230 }
2231
2232 /**
2233  * audiomanager_commandinterface_proxy_new_for_bus_finish:
2234  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_proxy_new_for_bus().
2235  * @error: Return location for error or %NULL
2236  *
2237  * Finishes an operation started with audiomanager_commandinterface_proxy_new_for_bus().
2238  *
2239  * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set.
2240  */
2241 AudiomanagerCommandinterface *
2242 audiomanager_commandinterface_proxy_new_for_bus_finish (
2243     GAsyncResult        *res,
2244     GError             **error)
2245 {
2246   GObject *ret;
2247   GObject *source_object;
2248   source_object = g_async_result_get_source_object (res);
2249   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
2250   g_object_unref (source_object);
2251   if (ret != NULL)
2252     return AUDIOMANAGER_COMMANDINTERFACE (ret);
2253   else
2254     return NULL;
2255 }
2256
2257 /**
2258  * audiomanager_commandinterface_proxy_new_for_bus_sync:
2259  * @bus_type: A #GBusType.
2260  * @flags: Flags from the #GDBusProxyFlags enumeration.
2261  * @name: A bus name (well-known or unique).
2262  * @object_path: An object path.
2263  * @cancellable: (allow-none): A #GCancellable or %NULL.
2264  * @error: Return location for error or %NULL
2265  *
2266  * Like audiomanager_commandinterface_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
2267  *
2268  * The calling thread is blocked until a reply is received.
2269  *
2270  * See audiomanager_commandinterface_proxy_new_for_bus() for the asynchronous version of this constructor.
2271  *
2272  * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set.
2273  */
2274 AudiomanagerCommandinterface *
2275 audiomanager_commandinterface_proxy_new_for_bus_sync (
2276     GBusType             bus_type,
2277     GDBusProxyFlags      flags,
2278     const gchar         *name,
2279     const gchar         *object_path,
2280     GCancellable        *cancellable,
2281     GError             **error)
2282 {
2283   GInitable *ret;
2284   ret = g_initable_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL);
2285   if (ret != NULL)
2286     return AUDIOMANAGER_COMMANDINTERFACE (ret);
2287   else
2288     return NULL;
2289 }
2290
2291
2292 /* ------------------------------------------------------------------------ */
2293
2294 /**
2295  * AudiomanagerCommandinterfaceSkeleton:
2296  *
2297  * The #AudiomanagerCommandinterfaceSkeleton structure contains only private data and should only be accessed using the provided API.
2298  */
2299
2300 /**
2301  * AudiomanagerCommandinterfaceSkeletonClass:
2302  * @parent_class: The parent class.
2303  *
2304  * Class structure for #AudiomanagerCommandinterfaceSkeleton.
2305  */
2306
2307 struct _AudiomanagerCommandinterfaceSkeletonPrivate
2308 {
2309   GValue *properties;
2310   GList *changed_properties;
2311   GSource *changed_properties_idle_source;
2312   GMainContext *context;
2313   GMutex lock;
2314 };
2315
2316 static void
2317 _audiomanager_commandinterface_skeleton_handle_method_call (
2318   GDBusConnection *connection G_GNUC_UNUSED,
2319   const gchar *sender G_GNUC_UNUSED,
2320   const gchar *object_path G_GNUC_UNUSED,
2321   const gchar *interface_name,
2322   const gchar *method_name,
2323   GVariant *parameters,
2324   GDBusMethodInvocation *invocation,
2325   gpointer user_data)
2326 {
2327   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data);
2328   _ExtendedGDBusMethodInfo *info;
2329   GVariantIter iter;
2330   GVariant *child;
2331   GValue *paramv;
2332   guint num_params;
2333   guint num_extra;
2334   guint n;
2335   guint signal_id;
2336   GValue return_value = G_VALUE_INIT;
2337   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
2338   g_assert (info != NULL);
2339   num_params = g_variant_n_children (parameters);
2340   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
2341   n = 0;
2342   g_value_init (&paramv[n], TYPE_AUDIOMANAGER_COMMANDINTERFACE);
2343   g_value_set_object (&paramv[n++], skeleton);
2344   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
2345   g_value_set_object (&paramv[n++], invocation);
2346   if (info->pass_fdlist)
2347     {
2348 #ifdef G_OS_UNIX
2349       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
2350       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
2351 #else
2352       g_assert_not_reached ();
2353 #endif
2354     }
2355   g_variant_iter_init (&iter, parameters);
2356   while ((child = g_variant_iter_next_value (&iter)) != NULL)
2357     {
2358       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
2359       if (arg_info->use_gvariant)
2360         {
2361           g_value_init (&paramv[n], G_TYPE_VARIANT);
2362           g_value_set_variant (&paramv[n], child);
2363           n++;
2364         }
2365       else
2366         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
2367       g_variant_unref (child);
2368     }
2369   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_COMMANDINTERFACE);
2370   g_value_init (&return_value, G_TYPE_BOOLEAN);
2371   g_signal_emitv (paramv, signal_id, 0, &return_value);
2372   if (!g_value_get_boolean (&return_value))
2373     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);
2374   g_value_unset (&return_value);
2375   for (n = 0; n < num_params + num_extra; n++)
2376     g_value_unset (&paramv[n]);
2377   g_free (paramv);
2378 }
2379
2380 static GVariant *
2381 _audiomanager_commandinterface_skeleton_handle_get_property (
2382   GDBusConnection *connection G_GNUC_UNUSED,
2383   const gchar *sender G_GNUC_UNUSED,
2384   const gchar *object_path G_GNUC_UNUSED,
2385   const gchar *interface_name G_GNUC_UNUSED,
2386   const gchar *property_name,
2387   GError **error,
2388   gpointer user_data)
2389 {
2390   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data);
2391   GValue value = G_VALUE_INIT;
2392   GParamSpec *pspec;
2393   _ExtendedGDBusPropertyInfo *info;
2394   GVariant *ret;
2395   ret = NULL;
2396   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, property_name);
2397   g_assert (info != NULL);
2398   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
2399   if (pspec == NULL)
2400     {
2401       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
2402     }
2403   else
2404     {
2405       g_value_init (&value, pspec->value_type);
2406       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
2407       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
2408       g_value_unset (&value);
2409     }
2410   return ret;
2411 }
2412
2413 static gboolean
2414 _audiomanager_commandinterface_skeleton_handle_set_property (
2415   GDBusConnection *connection G_GNUC_UNUSED,
2416   const gchar *sender G_GNUC_UNUSED,
2417   const gchar *object_path G_GNUC_UNUSED,
2418   const gchar *interface_name G_GNUC_UNUSED,
2419   const gchar *property_name,
2420   GVariant *variant,
2421   GError **error,
2422   gpointer user_data)
2423 {
2424   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data);
2425   GValue value = G_VALUE_INIT;
2426   GParamSpec *pspec;
2427   _ExtendedGDBusPropertyInfo *info;
2428   gboolean ret;
2429   ret = FALSE;
2430   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, property_name);
2431   g_assert (info != NULL);
2432   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
2433   if (pspec == NULL)
2434     {
2435       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
2436     }
2437   else
2438     {
2439       if (info->use_gvariant)
2440         g_value_set_variant (&value, variant);
2441       else
2442         g_dbus_gvariant_to_gvalue (variant, &value);
2443       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
2444       g_value_unset (&value);
2445       ret = TRUE;
2446     }
2447   return ret;
2448 }
2449
2450 static const GDBusInterfaceVTable _audiomanager_commandinterface_skeleton_vtable =
2451 {
2452   _audiomanager_commandinterface_skeleton_handle_method_call,
2453   _audiomanager_commandinterface_skeleton_handle_get_property,
2454   _audiomanager_commandinterface_skeleton_handle_set_property,
2455   {NULL}
2456 };
2457
2458 static GDBusInterfaceInfo *
2459 audiomanager_commandinterface_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
2460 {
2461   return audiomanager_commandinterface_interface_info ();
2462 }
2463
2464 static GDBusInterfaceVTable *
2465 audiomanager_commandinterface_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
2466 {
2467   return (GDBusInterfaceVTable *) &_audiomanager_commandinterface_skeleton_vtable;
2468 }
2469
2470 static GVariant *
2471 audiomanager_commandinterface_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
2472 {
2473   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (_skeleton);
2474
2475   GVariantBuilder builder;
2476   guint n;
2477   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
2478   if (_audiomanager_commandinterface_interface_info.parent_struct.properties == NULL)
2479     goto out;
2480   for (n = 0; _audiomanager_commandinterface_interface_info.parent_struct.properties[n] != NULL; n++)
2481     {
2482       GDBusPropertyInfo *info = _audiomanager_commandinterface_interface_info.parent_struct.properties[n];
2483       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
2484         {
2485           GVariant *value;
2486           value = _audiomanager_commandinterface_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.genivi.audiomanager.commandinterface", info->name, NULL, skeleton);
2487           if (value != NULL)
2488             {
2489               g_variant_take_ref (value);
2490               g_variant_builder_add (&builder, "{sv}", info->name, value);
2491               g_variant_unref (value);
2492             }
2493         }
2494     }
2495 out:
2496   return g_variant_builder_end (&builder);
2497 }
2498
2499 static void
2500 audiomanager_commandinterface_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
2501 {
2502 }
2503
2504 static void
2505 _audiomanager_commandinterface_on_signal_new_main_connection (
2506     AudiomanagerCommandinterface *object,
2507     GVariant *arg_mainConnection)
2508 {
2509   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2510
2511   GList      *connections, *l;
2512   GVariant   *signal_variant;
2513   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2514
2515   signal_variant = g_variant_ref_sink (g_variant_new ("(@(qqqnn))",
2516                    arg_mainConnection));
2517   for (l = connections; l != NULL; l = l->next)
2518     {
2519       GDBusConnection *connection = l->data;
2520       g_dbus_connection_emit_signal (connection,
2521         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "NewMainConnection",
2522         signal_variant, NULL);
2523     }
2524   g_variant_unref (signal_variant);
2525   g_list_free_full (connections, g_object_unref);
2526 }
2527
2528 static void
2529 _audiomanager_commandinterface_on_signal_removed_main_connection (
2530     AudiomanagerCommandinterface *object,
2531     guint16 arg_mainConnectionId)
2532 {
2533   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2534
2535   GList      *connections, *l;
2536   GVariant   *signal_variant;
2537   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2538
2539   signal_variant = g_variant_ref_sink (g_variant_new ("(q)",
2540                    arg_mainConnectionId));
2541   for (l = connections; l != NULL; l = l->next)
2542     {
2543       GDBusConnection *connection = l->data;
2544       g_dbus_connection_emit_signal (connection,
2545         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "RemovedMainConnection",
2546         signal_variant, NULL);
2547     }
2548   g_variant_unref (signal_variant);
2549   g_list_free_full (connections, g_object_unref);
2550 }
2551
2552 static void
2553 _audiomanager_commandinterface_on_signal_main_connection_state_changed (
2554     AudiomanagerCommandinterface *object,
2555     guint16 arg_connectionID,
2556     gint16 arg_connectionState)
2557 {
2558   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2559
2560   GList      *connections, *l;
2561   GVariant   *signal_variant;
2562   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2563
2564   signal_variant = g_variant_ref_sink (g_variant_new ("(qn)",
2565                    arg_connectionID,
2566                    arg_connectionState));
2567   for (l = connections; l != NULL; l = l->next)
2568     {
2569       GDBusConnection *connection = l->data;
2570       g_dbus_connection_emit_signal (connection,
2571         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "MainConnectionStateChanged",
2572         signal_variant, NULL);
2573     }
2574   g_variant_unref (signal_variant);
2575   g_list_free_full (connections, g_object_unref);
2576 }
2577
2578 static void
2579 _audiomanager_commandinterface_on_signal_volume_changed (
2580     AudiomanagerCommandinterface *object,
2581     guint16 arg_sinkID,
2582     gint16 arg_volume)
2583 {
2584   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2585
2586   GList      *connections, *l;
2587   GVariant   *signal_variant;
2588   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2589
2590   signal_variant = g_variant_ref_sink (g_variant_new ("(qn)",
2591                    arg_sinkID,
2592                    arg_volume));
2593   for (l = connections; l != NULL; l = l->next)
2594     {
2595       GDBusConnection *connection = l->data;
2596       g_dbus_connection_emit_signal (connection,
2597         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "VolumeChanged",
2598         signal_variant, NULL);
2599     }
2600   g_variant_unref (signal_variant);
2601   g_list_free_full (connections, g_object_unref);
2602 }
2603
2604 static void
2605 _audiomanager_commandinterface_on_signal_sink_mute_state_changed (
2606     AudiomanagerCommandinterface *object,
2607     guint16 arg_sinkID,
2608     gint16 arg_muteState)
2609 {
2610   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2611
2612   GList      *connections, *l;
2613   GVariant   *signal_variant;
2614   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2615
2616   signal_variant = g_variant_ref_sink (g_variant_new ("(qn)",
2617                    arg_sinkID,
2618                    arg_muteState));
2619   for (l = connections; l != NULL; l = l->next)
2620     {
2621       GDBusConnection *connection = l->data;
2622       g_dbus_connection_emit_signal (connection,
2623         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "SinkMuteStateChanged",
2624         signal_variant, NULL);
2625     }
2626   g_variant_unref (signal_variant);
2627   g_list_free_full (connections, g_object_unref);
2628 }
2629
2630 static void
2631 _audiomanager_commandinterface_on_signal_system_property_changed (
2632     AudiomanagerCommandinterface *object,
2633     GVariant *arg_SystemProperty)
2634 {
2635   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2636
2637   GList      *connections, *l;
2638   GVariant   *signal_variant;
2639   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
2640
2641   signal_variant = g_variant_ref_sink (g_variant_new ("(@(nn))",
2642                    arg_SystemProperty));
2643   for (l = connections; l != NULL; l = l->next)
2644     {
2645       GDBusConnection *connection = l->data;
2646       g_dbus_connection_emit_signal (connection,
2647         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "SystemPropertyChanged",
2648         signal_variant, NULL);
2649     }
2650   g_variant_unref (signal_variant);
2651   g_list_free_full (connections, g_object_unref);
2652 }
2653
2654 static void audiomanager_commandinterface_skeleton_iface_init (AudiomanagerCommandinterfaceIface *iface);
2655 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2656 G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceSkeleton, audiomanager_commandinterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
2657                          G_ADD_PRIVATE (AudiomanagerCommandinterfaceSkeleton)
2658                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_skeleton_iface_init));
2659
2660 #else
2661 G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceSkeleton, audiomanager_commandinterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
2662                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_skeleton_iface_init));
2663
2664 #endif
2665 static void
2666 audiomanager_commandinterface_skeleton_finalize (GObject *object)
2667 {
2668   AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object);
2669   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
2670   if (skeleton->priv->changed_properties_idle_source != NULL)
2671     g_source_destroy (skeleton->priv->changed_properties_idle_source);
2672   g_main_context_unref (skeleton->priv->context);
2673   g_mutex_clear (&skeleton->priv->lock);
2674   G_OBJECT_CLASS (audiomanager_commandinterface_skeleton_parent_class)->finalize (object);
2675 }
2676
2677 static void
2678 audiomanager_commandinterface_skeleton_init (AudiomanagerCommandinterfaceSkeleton *skeleton)
2679 {
2680 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
2681   skeleton->priv = audiomanager_commandinterface_skeleton_get_instance_private (skeleton);
2682 #else
2683   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonPrivate);
2684 #endif
2685
2686   g_mutex_init (&skeleton->priv->lock);
2687   skeleton->priv->context = g_main_context_ref_thread_default ();
2688 }
2689
2690 static void
2691 audiomanager_commandinterface_skeleton_class_init (AudiomanagerCommandinterfaceSkeletonClass *klass)
2692 {
2693   GObjectClass *gobject_class;
2694   GDBusInterfaceSkeletonClass *skeleton_class;
2695
2696   gobject_class = G_OBJECT_CLASS (klass);
2697   gobject_class->finalize = audiomanager_commandinterface_skeleton_finalize;
2698
2699   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
2700   skeleton_class->get_info = audiomanager_commandinterface_skeleton_dbus_interface_get_info;
2701   skeleton_class->get_properties = audiomanager_commandinterface_skeleton_dbus_interface_get_properties;
2702   skeleton_class->flush = audiomanager_commandinterface_skeleton_dbus_interface_flush;
2703   skeleton_class->get_vtable = audiomanager_commandinterface_skeleton_dbus_interface_get_vtable;
2704
2705 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
2706   g_type_class_add_private (klass, sizeof (AudiomanagerCommandinterfaceSkeletonPrivate));
2707 #endif
2708 }
2709
2710 static void
2711 audiomanager_commandinterface_skeleton_iface_init (AudiomanagerCommandinterfaceIface *iface)
2712 {
2713   iface->new_main_connection = _audiomanager_commandinterface_on_signal_new_main_connection;
2714   iface->removed_main_connection = _audiomanager_commandinterface_on_signal_removed_main_connection;
2715   iface->main_connection_state_changed = _audiomanager_commandinterface_on_signal_main_connection_state_changed;
2716   iface->volume_changed = _audiomanager_commandinterface_on_signal_volume_changed;
2717   iface->sink_mute_state_changed = _audiomanager_commandinterface_on_signal_sink_mute_state_changed;
2718   iface->system_property_changed = _audiomanager_commandinterface_on_signal_system_property_changed;
2719 }
2720
2721 /**
2722  * audiomanager_commandinterface_skeleton_new:
2723  *
2724  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>.
2725  *
2726  * Returns: (transfer full) (type AudiomanagerCommandinterfaceSkeleton): The skeleton object.
2727  */
2728 AudiomanagerCommandinterface *
2729 audiomanager_commandinterface_skeleton_new (void)
2730 {
2731   return AUDIOMANAGER_COMMANDINTERFACE (g_object_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, NULL));
2732 }
2733
2734 /* ------------------------------------------------------------------------
2735  * Code for interface org.genivi.audiomanager.routinginterface
2736  * ------------------------------------------------------------------------
2737  */
2738
2739 /**
2740  * SECTION:AudiomanagerRoutinginterface
2741  * @title: AudiomanagerRoutinginterface
2742  * @short_description: Generated C code for the org.genivi.audiomanager.routinginterface D-Bus interface
2743  *
2744  * This section contains code for working with the <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link> D-Bus interface in C.
2745  */
2746
2747 /* ---- Introspection data for org.genivi.audiomanager.routinginterface ---- */
2748
2749 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_handle =
2750 {
2751   {
2752     -1,
2753     (gchar *) "handle",
2754     (gchar *) "q",
2755     NULL
2756   },
2757   FALSE
2758 };
2759
2760 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_connectionID =
2761 {
2762   {
2763     -1,
2764     (gchar *) "connectionID",
2765     (gchar *) "q",
2766     NULL
2767   },
2768   FALSE
2769 };
2770
2771 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_error =
2772 {
2773   {
2774     -1,
2775     (gchar *) "error",
2776     (gchar *) "q",
2777     NULL
2778   },
2779   FALSE
2780 };
2781
2782 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_pointers[] =
2783 {
2784   &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_handle,
2785   &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_connectionID,
2786   &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_error,
2787   NULL
2788 };
2789
2790 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_connect =
2791 {
2792   {
2793     -1,
2794     (gchar *) "ackConnect",
2795     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_pointers,
2796     NULL,
2797     NULL
2798   },
2799   "handle-ack-connect",
2800   FALSE
2801 };
2802
2803 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_handle =
2804 {
2805   {
2806     -1,
2807     (gchar *) "handle",
2808     (gchar *) "q",
2809     NULL
2810   },
2811   FALSE
2812 };
2813
2814 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_connectionID =
2815 {
2816   {
2817     -1,
2818     (gchar *) "connectionID",
2819     (gchar *) "q",
2820     NULL
2821   },
2822   FALSE
2823 };
2824
2825 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_error =
2826 {
2827   {
2828     -1,
2829     (gchar *) "error",
2830     (gchar *) "q",
2831     NULL
2832   },
2833   FALSE
2834 };
2835
2836 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_pointers[] =
2837 {
2838   &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_handle,
2839   &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_connectionID,
2840   &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_error,
2841   NULL
2842 };
2843
2844 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_disconnect =
2845 {
2846   {
2847     -1,
2848     (gchar *) "ackDisconnect",
2849     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_pointers,
2850     NULL,
2851     NULL
2852   },
2853   "handle-ack-disconnect",
2854   FALSE
2855 };
2856
2857 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_handle =
2858 {
2859   {
2860     -1,
2861     (gchar *) "handle",
2862     (gchar *) "q",
2863     NULL
2864   },
2865   FALSE
2866 };
2867
2868 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_error =
2869 {
2870   {
2871     -1,
2872     (gchar *) "error",
2873     (gchar *) "q",
2874     NULL
2875   },
2876   FALSE
2877 };
2878
2879 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_pointers[] =
2880 {
2881   &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_handle,
2882   &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_error,
2883   NULL
2884 };
2885
2886 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_source_state =
2887 {
2888   {
2889     -1,
2890     (gchar *) "ackSetSourceState",
2891     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_pointers,
2892     NULL,
2893     NULL
2894   },
2895   "handle-ack-set-source-state",
2896   FALSE
2897 };
2898
2899 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_handle =
2900 {
2901   {
2902     -1,
2903     (gchar *) "handle",
2904     (gchar *) "q",
2905     NULL
2906   },
2907   FALSE
2908 };
2909
2910 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_volume =
2911 {
2912   {
2913     -1,
2914     (gchar *) "volume",
2915     (gchar *) "n",
2916     NULL
2917   },
2918   FALSE
2919 };
2920
2921 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_error =
2922 {
2923   {
2924     -1,
2925     (gchar *) "error",
2926     (gchar *) "q",
2927     NULL
2928   },
2929   FALSE
2930 };
2931
2932 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_pointers[] =
2933 {
2934   &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_handle,
2935   &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_volume,
2936   &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_error,
2937   NULL
2938 };
2939
2940 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume =
2941 {
2942   {
2943     -1,
2944     (gchar *) "ackSetSinkVolume",
2945     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_pointers,
2946     NULL,
2947     NULL
2948   },
2949   "handle-ack-set-sink-volume",
2950   FALSE
2951 };
2952
2953 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_IN_ARG_sinkData =
2954 {
2955   {
2956     -1,
2957     (gchar *) "sinkData",
2958     (gchar *) "(qsqinb(ii)nna(in)aia(in)a(iin)a(iin))",
2959     NULL
2960   },
2961   FALSE
2962 };
2963
2964 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_sink_IN_ARG_pointers[] =
2965 {
2966   &_audiomanager_routinginterface_method_info_register_sink_IN_ARG_sinkData,
2967   NULL
2968 };
2969
2970 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_sinkID =
2971 {
2972   {
2973     -1,
2974     (gchar *) "sinkID",
2975     (gchar *) "q",
2976     NULL
2977   },
2978   FALSE
2979 };
2980
2981 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_error =
2982 {
2983   {
2984     -1,
2985     (gchar *) "error",
2986     (gchar *) "q",
2987     NULL
2988   },
2989   FALSE
2990 };
2991
2992 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_pointers[] =
2993 {
2994   &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_sinkID,
2995   &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_error,
2996   NULL
2997 };
2998
2999 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_sink =
3000 {
3001   {
3002     -1,
3003     (gchar *) "registerSink",
3004     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_sink_IN_ARG_pointers,
3005     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_pointers,
3006     NULL
3007   },
3008   "handle-register-sink",
3009   FALSE
3010 };
3011
3012 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_sinkID =
3013 {
3014   {
3015     -1,
3016     (gchar *) "sinkID",
3017     (gchar *) "q",
3018     NULL
3019   },
3020   FALSE
3021 };
3022
3023 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_pointers[] =
3024 {
3025   &_audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_sinkID,
3026   NULL
3027 };
3028
3029 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_error =
3030 {
3031   {
3032     -1,
3033     (gchar *) "error",
3034     (gchar *) "i",
3035     NULL
3036   },
3037   FALSE
3038 };
3039
3040 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_pointers[] =
3041 {
3042   &_audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_error,
3043   NULL
3044 };
3045
3046 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_deregister_sink =
3047 {
3048   {
3049     -1,
3050     (gchar *) "deregisterSink",
3051     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_pointers,
3052     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_pointers,
3053     NULL
3054   },
3055   "handle-deregister-sink",
3056   FALSE
3057 };
3058
3059 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_IN_ARG_sourceData =
3060 {
3061   {
3062     -1,
3063     (gchar *) "sourceData",
3064     (gchar *) "(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin))",
3065     NULL
3066   },
3067   FALSE
3068 };
3069
3070 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_source_IN_ARG_pointers[] =
3071 {
3072   &_audiomanager_routinginterface_method_info_register_source_IN_ARG_sourceData,
3073   NULL
3074 };
3075
3076 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_OUT_ARG_sourceID =
3077 {
3078   {
3079     -1,
3080     (gchar *) "sourceID",
3081     (gchar *) "q",
3082     NULL
3083   },
3084   FALSE
3085 };
3086
3087 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_OUT_ARG_error =
3088 {
3089   {
3090     -1,
3091     (gchar *) "error",
3092     (gchar *) "q",
3093     NULL
3094   },
3095   FALSE
3096 };
3097
3098 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_source_OUT_ARG_pointers[] =
3099 {
3100   &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_sourceID,
3101   &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_error,
3102   NULL
3103 };
3104
3105 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_source =
3106 {
3107   {
3108     -1,
3109     (gchar *) "registerSource",
3110     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_source_IN_ARG_pointers,
3111     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_pointers,
3112     NULL
3113   },
3114   "handle-register-source",
3115   FALSE
3116 };
3117
3118 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_source_IN_ARG_sourceID =
3119 {
3120   {
3121     -1,
3122     (gchar *) "sourceID",
3123     (gchar *) "q",
3124     NULL
3125   },
3126   FALSE
3127 };
3128
3129 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_source_IN_ARG_pointers[] =
3130 {
3131   &_audiomanager_routinginterface_method_info_deregister_source_IN_ARG_sourceID,
3132   NULL
3133 };
3134
3135 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_error =
3136 {
3137   {
3138     -1,
3139     (gchar *) "error",
3140     (gchar *) "q",
3141     NULL
3142   },
3143   FALSE
3144 };
3145
3146 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_pointers[] =
3147 {
3148   &_audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_error,
3149   NULL
3150 };
3151
3152 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_deregister_source =
3153 {
3154   {
3155     -1,
3156     (gchar *) "deregisterSource",
3157     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_source_IN_ARG_pointers,
3158     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_pointers,
3159     NULL
3160   },
3161   "handle-deregister-source",
3162   FALSE
3163 };
3164
3165 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_sourceID =
3166 {
3167   {
3168     -1,
3169     (gchar *) "sourceID",
3170     (gchar *) "q",
3171     NULL
3172   },
3173   FALSE
3174 };
3175
3176 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_interruptState =
3177 {
3178   {
3179     -1,
3180     (gchar *) "interruptState",
3181     (gchar *) "q",
3182     NULL
3183   },
3184   FALSE
3185 };
3186
3187 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_pointers[] =
3188 {
3189   &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_sourceID,
3190   &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_interruptState,
3191   NULL
3192 };
3193
3194 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change =
3195 {
3196   {
3197     -1,
3198     (gchar *) "hookInterruptStatusChange",
3199     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_pointers,
3200     NULL,
3201     NULL
3202   },
3203   "handle-hook-interrupt-status-change",
3204   FALSE
3205 };
3206
3207 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_sourceID =
3208 {
3209   {
3210     -1,
3211     (gchar *) "sourceID",
3212     (gchar *) "q",
3213     NULL
3214   },
3215   FALSE
3216 };
3217
3218 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_availability =
3219 {
3220   {
3221     -1,
3222     (gchar *) "availability",
3223     (gchar *) "(nn)",
3224     NULL
3225   },
3226   FALSE
3227 };
3228
3229 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_pointers[] =
3230 {
3231   &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_sourceID,
3232   &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_availability,
3233   NULL
3234 };
3235
3236 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change =
3237 {
3238   {
3239     -1,
3240     (gchar *) "hookSourceAvailablityStatusChange",
3241     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_pointers,
3242     NULL,
3243     NULL
3244   },
3245   "handle-hook-source-availablity-status-change",
3246   FALSE
3247 };
3248
3249 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_domainID =
3250 {
3251   {
3252     -1,
3253     (gchar *) "domainID",
3254     (gchar *) "q",
3255     NULL
3256   },
3257   FALSE
3258 };
3259
3260 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_pointers[] =
3261 {
3262   &_audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_domainID,
3263   NULL
3264 };
3265
3266 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_confirm_routing_ready =
3267 {
3268   {
3269     -1,
3270     (gchar *) "confirmRoutingReady",
3271     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_pointers,
3272     NULL,
3273     NULL
3274   },
3275   "handle-confirm-routing-ready",
3276   FALSE
3277 };
3278
3279 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_domainID =
3280 {
3281   {
3282     -1,
3283     (gchar *) "domainID",
3284     (gchar *) "q",
3285     NULL
3286   },
3287   FALSE
3288 };
3289
3290 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_pointers[] =
3291 {
3292   &_audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_domainID,
3293   NULL
3294 };
3295
3296 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_confirm_routing_rundown =
3297 {
3298   {
3299     -1,
3300     (gchar *) "confirmRoutingRundown",
3301     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_pointers,
3302     NULL,
3303     NULL
3304   },
3305   "handle-confirm-routing-rundown",
3306   FALSE
3307 };
3308
3309 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_handle =
3310 {
3311   {
3312     -1,
3313     (gchar *) "handle",
3314     (gchar *) "q",
3315     NULL
3316   },
3317   FALSE
3318 };
3319
3320 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_listvolumes =
3321 {
3322   {
3323     -1,
3324     (gchar *) "listvolumes",
3325     (gchar *) "a(nqqnq)",
3326     NULL
3327   },
3328   FALSE
3329 };
3330
3331 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_error =
3332 {
3333   {
3334     -1,
3335     (gchar *) "error",
3336     (gchar *) "q",
3337     NULL
3338   },
3339   FALSE
3340 };
3341
3342 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_pointers[] =
3343 {
3344   &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_handle,
3345   &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_listvolumes,
3346   &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_error,
3347   NULL
3348 };
3349
3350 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_volumes =
3351 {
3352   {
3353     -1,
3354     (gchar *) "ackSetVolumes",
3355     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_pointers,
3356     NULL,
3357     NULL
3358   },
3359   "handle-ack-set-volumes",
3360   FALSE
3361 };
3362
3363 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_handle =
3364 {
3365   {
3366     -1,
3367     (gchar *) "handle",
3368     (gchar *) "q",
3369     NULL
3370   },
3371   FALSE
3372 };
3373
3374 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_error =
3375 {
3376   {
3377     -1,
3378     (gchar *) "error",
3379     (gchar *) "q",
3380     NULL
3381   },
3382   FALSE
3383 };
3384
3385 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_pointers[] =
3386 {
3387   &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_handle,
3388   &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_error,
3389   NULL
3390 };
3391
3392 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration =
3393 {
3394   {
3395     -1,
3396     (gchar *) "ackSinkNotificationConfiguration",
3397     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_pointers,
3398     NULL,
3399     NULL
3400   },
3401   "handle-ack-sink-notification-configuration",
3402   FALSE
3403 };
3404
3405 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_handle =
3406 {
3407   {
3408     -1,
3409     (gchar *) "handle",
3410     (gchar *) "q",
3411     NULL
3412   },
3413   FALSE
3414 };
3415
3416 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_error =
3417 {
3418   {
3419     -1,
3420     (gchar *) "error",
3421     (gchar *) "q",
3422     NULL
3423   },
3424   FALSE
3425 };
3426
3427 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_pointers[] =
3428 {
3429   &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_handle,
3430   &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_error,
3431   NULL
3432 };
3433
3434 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration =
3435 {
3436   {
3437     -1,
3438     (gchar *) "ackSourceNotificationConfiguration",
3439     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_pointers,
3440     NULL,
3441     NULL
3442   },
3443   "handle-ack-source-notification-configuration",
3444   FALSE
3445 };
3446
3447 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_domaindata =
3448 {
3449   {
3450     -1,
3451     (gchar *) "domaindata",
3452     (gchar *) "(qsssbbn)",
3453     NULL
3454   },
3455   FALSE
3456 };
3457
3458 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnBusname =
3459 {
3460   {
3461     -1,
3462     (gchar *) "returnBusname",
3463     (gchar *) "s",
3464     NULL
3465   },
3466   FALSE
3467 };
3468
3469 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnPath =
3470 {
3471   {
3472     -1,
3473     (gchar *) "returnPath",
3474     (gchar *) "s",
3475     NULL
3476   },
3477   FALSE
3478 };
3479
3480 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnInterface =
3481 {
3482   {
3483     -1,
3484     (gchar *) "returnInterface",
3485     (gchar *) "s",
3486     NULL
3487   },
3488   FALSE
3489 };
3490
3491 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_domain_IN_ARG_pointers[] =
3492 {
3493   &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_domaindata,
3494   &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnBusname,
3495   &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnPath,
3496   &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnInterface,
3497   NULL
3498 };
3499
3500 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_domainid =
3501 {
3502   {
3503     -1,
3504     (gchar *) "domainid",
3505     (gchar *) "q",
3506     NULL
3507   },
3508   FALSE
3509 };
3510
3511 static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_error =
3512 {
3513   {
3514     -1,
3515     (gchar *) "error",
3516     (gchar *) "q",
3517     NULL
3518   },
3519   FALSE
3520 };
3521
3522 static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_pointers[] =
3523 {
3524   &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_domainid,
3525   &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_error,
3526   NULL
3527 };
3528
3529 static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_domain =
3530 {
3531   {
3532     -1,
3533     (gchar *) "registerDomain",
3534     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_pointers,
3535     (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_pointers,
3536     NULL
3537   },
3538   "handle-register-domain",
3539   FALSE
3540 };
3541
3542 static const _ExtendedGDBusMethodInfo * const _audiomanager_routinginterface_method_info_pointers[] =
3543 {
3544   &_audiomanager_routinginterface_method_info_ack_connect,
3545   &_audiomanager_routinginterface_method_info_ack_disconnect,
3546   &_audiomanager_routinginterface_method_info_ack_set_source_state,
3547   &_audiomanager_routinginterface_method_info_ack_set_sink_volume,
3548   &_audiomanager_routinginterface_method_info_register_sink,
3549   &_audiomanager_routinginterface_method_info_deregister_sink,
3550   &_audiomanager_routinginterface_method_info_register_source,
3551   &_audiomanager_routinginterface_method_info_deregister_source,
3552   &_audiomanager_routinginterface_method_info_hook_interrupt_status_change,
3553   &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change,
3554   &_audiomanager_routinginterface_method_info_confirm_routing_ready,
3555   &_audiomanager_routinginterface_method_info_confirm_routing_rundown,
3556   &_audiomanager_routinginterface_method_info_ack_set_volumes,
3557   &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration,
3558   &_audiomanager_routinginterface_method_info_ack_source_notification_configuration,
3559   &_audiomanager_routinginterface_method_info_register_domain,
3560   NULL
3561 };
3562
3563 static const _ExtendedGDBusSignalInfo _audiomanager_routinginterface_signal_info_set_routing_ready =
3564 {
3565   {
3566     -1,
3567     (gchar *) "setRoutingReady",
3568     NULL,
3569     NULL
3570   },
3571   "set-routing-ready"
3572 };
3573
3574 static const _ExtendedGDBusSignalInfo _audiomanager_routinginterface_signal_info_set_routing_rundown =
3575 {
3576   {
3577     -1,
3578     (gchar *) "setRoutingRundown",
3579     NULL,
3580     NULL
3581   },
3582   "set-routing-rundown"
3583 };
3584
3585 static const _ExtendedGDBusSignalInfo * const _audiomanager_routinginterface_signal_info_pointers[] =
3586 {
3587   &_audiomanager_routinginterface_signal_info_set_routing_ready,
3588   &_audiomanager_routinginterface_signal_info_set_routing_rundown,
3589   NULL
3590 };
3591
3592 static const _ExtendedGDBusInterfaceInfo _audiomanager_routinginterface_interface_info =
3593 {
3594   {
3595     -1,
3596     (gchar *) "org.genivi.audiomanager.routinginterface",
3597     (GDBusMethodInfo **) &_audiomanager_routinginterface_method_info_pointers,
3598     (GDBusSignalInfo **) &_audiomanager_routinginterface_signal_info_pointers,
3599     NULL,
3600     NULL
3601   },
3602   "audiomanager-routinginterface",
3603 };
3604
3605
3606 /**
3607  * audiomanager_routinginterface_interface_info:
3608  *
3609  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link> D-Bus interface.
3610  *
3611  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
3612  */
3613 GDBusInterfaceInfo *
3614 audiomanager_routinginterface_interface_info (void)
3615 {
3616   return (GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct;
3617 }
3618
3619 /**
3620  * audiomanager_routinginterface_override_properties:
3621  * @klass: The class structure for a #GObject<!-- -->-derived class.
3622  * @property_id_begin: The property id to assign to the first overridden property.
3623  *
3624  * Overrides all #GObject properties in the #AudiomanagerRoutinginterface interface for a concrete class.
3625  * The properties are overridden in the order they are defined.
3626  *
3627  * Returns: The last property id.
3628  */
3629 guint
3630 audiomanager_routinginterface_override_properties (GObjectClass *klass, guint property_id_begin)
3631 {
3632   return property_id_begin - 1;
3633 }
3634
3635
3636
3637 /**
3638  * AudiomanagerRoutinginterface:
3639  *
3640  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>.
3641  */
3642
3643 /**
3644  * AudiomanagerRoutinginterfaceIface:
3645  * @parent_iface: The parent interface.
3646  * @handle_ack_connect: Handler for the #AudiomanagerRoutinginterface::handle-ack-connect signal.
3647  * @handle_ack_disconnect: Handler for the #AudiomanagerRoutinginterface::handle-ack-disconnect signal.
3648  * @handle_ack_set_sink_volume: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-sink-volume signal.
3649  * @handle_ack_set_source_state: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-source-state signal.
3650  * @handle_ack_set_volumes: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-volumes signal.
3651  * @handle_ack_sink_notification_configuration: Handler for the #AudiomanagerRoutinginterface::handle-ack-sink-notification-configuration signal.
3652  * @handle_ack_source_notification_configuration: Handler for the #AudiomanagerRoutinginterface::handle-ack-source-notification-configuration signal.
3653  * @handle_confirm_routing_ready: Handler for the #AudiomanagerRoutinginterface::handle-confirm-routing-ready signal.
3654  * @handle_confirm_routing_rundown: Handler for the #AudiomanagerRoutinginterface::handle-confirm-routing-rundown signal.
3655  * @handle_deregister_sink: Handler for the #AudiomanagerRoutinginterface::handle-deregister-sink signal.
3656  * @handle_deregister_source: Handler for the #AudiomanagerRoutinginterface::handle-deregister-source signal.
3657  * @handle_hook_interrupt_status_change: Handler for the #AudiomanagerRoutinginterface::handle-hook-interrupt-status-change signal.
3658  * @handle_hook_source_availablity_status_change: Handler for the #AudiomanagerRoutinginterface::handle-hook-source-availablity-status-change signal.
3659  * @handle_register_domain: Handler for the #AudiomanagerRoutinginterface::handle-register-domain signal.
3660  * @handle_register_sink: Handler for the #AudiomanagerRoutinginterface::handle-register-sink signal.
3661  * @handle_register_source: Handler for the #AudiomanagerRoutinginterface::handle-register-source signal.
3662  * @set_routing_ready: Handler for the #AudiomanagerRoutinginterface::set-routing-ready signal.
3663  * @set_routing_rundown: Handler for the #AudiomanagerRoutinginterface::set-routing-rundown signal.
3664  *
3665  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>.
3666  */
3667
3668 typedef AudiomanagerRoutinginterfaceIface AudiomanagerRoutinginterfaceInterface;
3669 G_DEFINE_INTERFACE (AudiomanagerRoutinginterface, audiomanager_routinginterface, G_TYPE_OBJECT);
3670
3671 static void
3672 audiomanager_routinginterface_default_init (AudiomanagerRoutinginterfaceIface *iface)
3673 {
3674   /* GObject signals for incoming D-Bus method calls: */
3675   /**
3676    * AudiomanagerRoutinginterface::handle-ack-connect:
3677    * @object: A #AudiomanagerRoutinginterface.
3678    * @invocation: A #GDBusMethodInvocation.
3679    * @arg_handle: Argument passed by remote caller.
3680    * @arg_connectionID: Argument passed by remote caller.
3681    * @arg_error: Argument passed by remote caller.
3682    *
3683    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackConnect">ackConnect()</link> D-Bus method.
3684    *
3685    * 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 audiomanager_routinginterface_complete_ack_connect() 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.
3686    *
3687    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3688    */
3689   g_signal_new ("handle-ack-connect",
3690     G_TYPE_FROM_INTERFACE (iface),
3691     G_SIGNAL_RUN_LAST,
3692     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_connect),
3693     g_signal_accumulator_true_handled,
3694     NULL,
3695     g_cclosure_marshal_generic,
3696     G_TYPE_BOOLEAN,
3697     4,
3698     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
3699
3700   /**
3701    * AudiomanagerRoutinginterface::handle-ack-disconnect:
3702    * @object: A #AudiomanagerRoutinginterface.
3703    * @invocation: A #GDBusMethodInvocation.
3704    * @arg_handle: Argument passed by remote caller.
3705    * @arg_connectionID: Argument passed by remote caller.
3706    * @arg_error: Argument passed by remote caller.
3707    *
3708    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackDisconnect">ackDisconnect()</link> D-Bus method.
3709    *
3710    * 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 audiomanager_routinginterface_complete_ack_disconnect() 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.
3711    *
3712    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3713    */
3714   g_signal_new ("handle-ack-disconnect",
3715     G_TYPE_FROM_INTERFACE (iface),
3716     G_SIGNAL_RUN_LAST,
3717     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_disconnect),
3718     g_signal_accumulator_true_handled,
3719     NULL,
3720     g_cclosure_marshal_generic,
3721     G_TYPE_BOOLEAN,
3722     4,
3723     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
3724
3725   /**
3726    * AudiomanagerRoutinginterface::handle-ack-set-source-state:
3727    * @object: A #AudiomanagerRoutinginterface.
3728    * @invocation: A #GDBusMethodInvocation.
3729    * @arg_handle: Argument passed by remote caller.
3730    * @arg_error: Argument passed by remote caller.
3731    *
3732    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSourceState">ackSetSourceState()</link> D-Bus method.
3733    *
3734    * 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 audiomanager_routinginterface_complete_ack_set_source_state() 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.
3735    *
3736    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3737    */
3738   g_signal_new ("handle-ack-set-source-state",
3739     G_TYPE_FROM_INTERFACE (iface),
3740     G_SIGNAL_RUN_LAST,
3741     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_source_state),
3742     g_signal_accumulator_true_handled,
3743     NULL,
3744     g_cclosure_marshal_generic,
3745     G_TYPE_BOOLEAN,
3746     3,
3747     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
3748
3749   /**
3750    * AudiomanagerRoutinginterface::handle-ack-set-sink-volume:
3751    * @object: A #AudiomanagerRoutinginterface.
3752    * @invocation: A #GDBusMethodInvocation.
3753    * @arg_handle: Argument passed by remote caller.
3754    * @arg_volume: Argument passed by remote caller.
3755    * @arg_error: Argument passed by remote caller.
3756    *
3757    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSinkVolume">ackSetSinkVolume()</link> D-Bus method.
3758    *
3759    * 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 audiomanager_routinginterface_complete_ack_set_sink_volume() 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.
3760    *
3761    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3762    */
3763   g_signal_new ("handle-ack-set-sink-volume",
3764     G_TYPE_FROM_INTERFACE (iface),
3765     G_SIGNAL_RUN_LAST,
3766     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_sink_volume),
3767     g_signal_accumulator_true_handled,
3768     NULL,
3769     g_cclosure_marshal_generic,
3770     G_TYPE_BOOLEAN,
3771     4,
3772     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT, G_TYPE_UINT);
3773
3774   /**
3775    * AudiomanagerRoutinginterface::handle-register-sink:
3776    * @object: A #AudiomanagerRoutinginterface.
3777    * @invocation: A #GDBusMethodInvocation.
3778    * @arg_sinkData: Argument passed by remote caller.
3779    *
3780    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSink">registerSink()</link> D-Bus method.
3781    *
3782    * 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 audiomanager_routinginterface_complete_register_sink() 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.
3783    *
3784    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3785    */
3786   g_signal_new ("handle-register-sink",
3787     G_TYPE_FROM_INTERFACE (iface),
3788     G_SIGNAL_RUN_LAST,
3789     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_sink),
3790     g_signal_accumulator_true_handled,
3791     NULL,
3792     g_cclosure_marshal_generic,
3793     G_TYPE_BOOLEAN,
3794     2,
3795     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);
3796
3797   /**
3798    * AudiomanagerRoutinginterface::handle-deregister-sink:
3799    * @object: A #AudiomanagerRoutinginterface.
3800    * @invocation: A #GDBusMethodInvocation.
3801    * @arg_sinkID: Argument passed by remote caller.
3802    *
3803    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSink">deregisterSink()</link> D-Bus method.
3804    *
3805    * 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 audiomanager_routinginterface_complete_deregister_sink() 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.
3806    *
3807    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3808    */
3809   g_signal_new ("handle-deregister-sink",
3810     G_TYPE_FROM_INTERFACE (iface),
3811     G_SIGNAL_RUN_LAST,
3812     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_deregister_sink),
3813     g_signal_accumulator_true_handled,
3814     NULL,
3815     g_cclosure_marshal_generic,
3816     G_TYPE_BOOLEAN,
3817     2,
3818     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
3819
3820   /**
3821    * AudiomanagerRoutinginterface::handle-register-source:
3822    * @object: A #AudiomanagerRoutinginterface.
3823    * @invocation: A #GDBusMethodInvocation.
3824    * @arg_sourceData: Argument passed by remote caller.
3825    *
3826    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSource">registerSource()</link> D-Bus method.
3827    *
3828    * 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 audiomanager_routinginterface_complete_register_source() 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.
3829    *
3830    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3831    */
3832   g_signal_new ("handle-register-source",
3833     G_TYPE_FROM_INTERFACE (iface),
3834     G_SIGNAL_RUN_LAST,
3835     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_source),
3836     g_signal_accumulator_true_handled,
3837     NULL,
3838     g_cclosure_marshal_generic,
3839     G_TYPE_BOOLEAN,
3840     2,
3841     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);
3842
3843   /**
3844    * AudiomanagerRoutinginterface::handle-deregister-source:
3845    * @object: A #AudiomanagerRoutinginterface.
3846    * @invocation: A #GDBusMethodInvocation.
3847    * @arg_sourceID: Argument passed by remote caller.
3848    *
3849    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSource">deregisterSource()</link> D-Bus method.
3850    *
3851    * 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 audiomanager_routinginterface_complete_deregister_source() 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.
3852    *
3853    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3854    */
3855   g_signal_new ("handle-deregister-source",
3856     G_TYPE_FROM_INTERFACE (iface),
3857     G_SIGNAL_RUN_LAST,
3858     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_deregister_source),
3859     g_signal_accumulator_true_handled,
3860     NULL,
3861     g_cclosure_marshal_generic,
3862     G_TYPE_BOOLEAN,
3863     2,
3864     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
3865
3866   /**
3867    * AudiomanagerRoutinginterface::handle-hook-interrupt-status-change:
3868    * @object: A #AudiomanagerRoutinginterface.
3869    * @invocation: A #GDBusMethodInvocation.
3870    * @arg_sourceID: Argument passed by remote caller.
3871    * @arg_interruptState: Argument passed by remote caller.
3872    *
3873    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookInterruptStatusChange">hookInterruptStatusChange()</link> D-Bus method.
3874    *
3875    * 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 audiomanager_routinginterface_complete_hook_interrupt_status_change() 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.
3876    *
3877    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3878    */
3879   g_signal_new ("handle-hook-interrupt-status-change",
3880     G_TYPE_FROM_INTERFACE (iface),
3881     G_SIGNAL_RUN_LAST,
3882     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_hook_interrupt_status_change),
3883     g_signal_accumulator_true_handled,
3884     NULL,
3885     g_cclosure_marshal_generic,
3886     G_TYPE_BOOLEAN,
3887     3,
3888     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
3889
3890   /**
3891    * AudiomanagerRoutinginterface::handle-hook-source-availablity-status-change:
3892    * @object: A #AudiomanagerRoutinginterface.
3893    * @invocation: A #GDBusMethodInvocation.
3894    * @arg_sourceID: Argument passed by remote caller.
3895    * @arg_availability: Argument passed by remote caller.
3896    *
3897    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookSourceAvailablityStatusChange">hookSourceAvailablityStatusChange()</link> D-Bus method.
3898    *
3899    * 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 audiomanager_routinginterface_complete_hook_source_availablity_status_change() 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.
3900    *
3901    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3902    */
3903   g_signal_new ("handle-hook-source-availablity-status-change",
3904     G_TYPE_FROM_INTERFACE (iface),
3905     G_SIGNAL_RUN_LAST,
3906     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_hook_source_availablity_status_change),
3907     g_signal_accumulator_true_handled,
3908     NULL,
3909     g_cclosure_marshal_generic,
3910     G_TYPE_BOOLEAN,
3911     3,
3912     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);
3913
3914   /**
3915    * AudiomanagerRoutinginterface::handle-confirm-routing-ready:
3916    * @object: A #AudiomanagerRoutinginterface.
3917    * @invocation: A #GDBusMethodInvocation.
3918    * @arg_domainID: Argument passed by remote caller.
3919    *
3920    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingReady">confirmRoutingReady()</link> D-Bus method.
3921    *
3922    * 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 audiomanager_routinginterface_complete_confirm_routing_ready() 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.
3923    *
3924    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3925    */
3926   g_signal_new ("handle-confirm-routing-ready",
3927     G_TYPE_FROM_INTERFACE (iface),
3928     G_SIGNAL_RUN_LAST,
3929     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_confirm_routing_ready),
3930     g_signal_accumulator_true_handled,
3931     NULL,
3932     g_cclosure_marshal_generic,
3933     G_TYPE_BOOLEAN,
3934     2,
3935     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
3936
3937   /**
3938    * AudiomanagerRoutinginterface::handle-confirm-routing-rundown:
3939    * @object: A #AudiomanagerRoutinginterface.
3940    * @invocation: A #GDBusMethodInvocation.
3941    * @arg_domainID: Argument passed by remote caller.
3942    *
3943    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingRundown">confirmRoutingRundown()</link> D-Bus method.
3944    *
3945    * 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 audiomanager_routinginterface_complete_confirm_routing_rundown() 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.
3946    *
3947    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3948    */
3949   g_signal_new ("handle-confirm-routing-rundown",
3950     G_TYPE_FROM_INTERFACE (iface),
3951     G_SIGNAL_RUN_LAST,
3952     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_confirm_routing_rundown),
3953     g_signal_accumulator_true_handled,
3954     NULL,
3955     g_cclosure_marshal_generic,
3956     G_TYPE_BOOLEAN,
3957     2,
3958     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
3959
3960   /**
3961    * AudiomanagerRoutinginterface::handle-ack-set-volumes:
3962    * @object: A #AudiomanagerRoutinginterface.
3963    * @invocation: A #GDBusMethodInvocation.
3964    * @arg_handle: Argument passed by remote caller.
3965    * @arg_listvolumes: Argument passed by remote caller.
3966    * @arg_error: Argument passed by remote caller.
3967    *
3968    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetVolumes">ackSetVolumes()</link> D-Bus method.
3969    *
3970    * 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 audiomanager_routinginterface_complete_ack_set_volumes() 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.
3971    *
3972    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3973    */
3974   g_signal_new ("handle-ack-set-volumes",
3975     G_TYPE_FROM_INTERFACE (iface),
3976     G_SIGNAL_RUN_LAST,
3977     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_volumes),
3978     g_signal_accumulator_true_handled,
3979     NULL,
3980     g_cclosure_marshal_generic,
3981     G_TYPE_BOOLEAN,
3982     4,
3983     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT, G_TYPE_UINT);
3984
3985   /**
3986    * AudiomanagerRoutinginterface::handle-ack-sink-notification-configuration:
3987    * @object: A #AudiomanagerRoutinginterface.
3988    * @invocation: A #GDBusMethodInvocation.
3989    * @arg_handle: Argument passed by remote caller.
3990    * @arg_error: Argument passed by remote caller.
3991    *
3992    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSinkNotificationConfiguration">ackSinkNotificationConfiguration()</link> D-Bus method.
3993    *
3994    * 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 audiomanager_routinginterface_complete_ack_sink_notification_configuration() 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.
3995    *
3996    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
3997    */
3998   g_signal_new ("handle-ack-sink-notification-configuration",
3999     G_TYPE_FROM_INTERFACE (iface),
4000     G_SIGNAL_RUN_LAST,
4001     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_sink_notification_configuration),
4002     g_signal_accumulator_true_handled,
4003     NULL,
4004     g_cclosure_marshal_generic,
4005     G_TYPE_BOOLEAN,
4006     3,
4007     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
4008
4009   /**
4010    * AudiomanagerRoutinginterface::handle-ack-source-notification-configuration:
4011    * @object: A #AudiomanagerRoutinginterface.
4012    * @invocation: A #GDBusMethodInvocation.
4013    * @arg_handle: Argument passed by remote caller.
4014    * @arg_error: Argument passed by remote caller.
4015    *
4016    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSourceNotificationConfiguration">ackSourceNotificationConfiguration()</link> D-Bus method.
4017    *
4018    * 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 audiomanager_routinginterface_complete_ack_source_notification_configuration() 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.
4019    *
4020    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
4021    */
4022   g_signal_new ("handle-ack-source-notification-configuration",
4023     G_TYPE_FROM_INTERFACE (iface),
4024     G_SIGNAL_RUN_LAST,
4025     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_source_notification_configuration),
4026     g_signal_accumulator_true_handled,
4027     NULL,
4028     g_cclosure_marshal_generic,
4029     G_TYPE_BOOLEAN,
4030     3,
4031     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
4032
4033   /**
4034    * AudiomanagerRoutinginterface::handle-register-domain:
4035    * @object: A #AudiomanagerRoutinginterface.
4036    * @invocation: A #GDBusMethodInvocation.
4037    * @arg_domaindata: Argument passed by remote caller.
4038    * @arg_returnBusname: Argument passed by remote caller.
4039    * @arg_returnPath: Argument passed by remote caller.
4040    * @arg_returnInterface: Argument passed by remote caller.
4041    *
4042    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerDomain">registerDomain()</link> D-Bus method.
4043    *
4044    * 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 audiomanager_routinginterface_complete_register_domain() 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.
4045    *
4046    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
4047    */
4048   g_signal_new ("handle-register-domain",
4049     G_TYPE_FROM_INTERFACE (iface),
4050     G_SIGNAL_RUN_LAST,
4051     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_domain),
4052     g_signal_accumulator_true_handled,
4053     NULL,
4054     g_cclosure_marshal_generic,
4055     G_TYPE_BOOLEAN,
4056     5,
4057     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
4058
4059   /* GObject signals for received D-Bus signals: */
4060   /**
4061    * AudiomanagerRoutinginterface::set-routing-ready:
4062    * @object: A #AudiomanagerRoutinginterface.
4063    *
4064    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-routinginterface.setRoutingReady">"setRoutingReady"</link> is received.
4065    *
4066    * 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.
4067    */
4068   g_signal_new ("set-routing-ready",
4069     G_TYPE_FROM_INTERFACE (iface),
4070     G_SIGNAL_RUN_LAST,
4071     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, set_routing_ready),
4072     NULL,
4073     NULL,
4074     g_cclosure_marshal_generic,
4075     G_TYPE_NONE,
4076     0);
4077
4078   /**
4079    * AudiomanagerRoutinginterface::set-routing-rundown:
4080    * @object: A #AudiomanagerRoutinginterface.
4081    *
4082    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-genivi-audiomanager-routinginterface.setRoutingRundown">"setRoutingRundown"</link> is received.
4083    *
4084    * 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.
4085    */
4086   g_signal_new ("set-routing-rundown",
4087     G_TYPE_FROM_INTERFACE (iface),
4088     G_SIGNAL_RUN_LAST,
4089     G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, set_routing_rundown),
4090     NULL,
4091     NULL,
4092     g_cclosure_marshal_generic,
4093     G_TYPE_NONE,
4094     0);
4095
4096 }
4097
4098 /**
4099  * audiomanager_routinginterface_emit_set_routing_ready:
4100  * @object: A #AudiomanagerRoutinginterface.
4101  *
4102  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-routinginterface.setRoutingReady">"setRoutingReady"</link> D-Bus signal.
4103  */
4104 void
4105 audiomanager_routinginterface_emit_set_routing_ready (
4106     AudiomanagerRoutinginterface *object)
4107 {
4108   g_signal_emit_by_name (object, "set-routing-ready");
4109 }
4110
4111 /**
4112  * audiomanager_routinginterface_emit_set_routing_rundown:
4113  * @object: A #AudiomanagerRoutinginterface.
4114  *
4115  * Emits the <link linkend="gdbus-signal-org-genivi-audiomanager-routinginterface.setRoutingRundown">"setRoutingRundown"</link> D-Bus signal.
4116  */
4117 void
4118 audiomanager_routinginterface_emit_set_routing_rundown (
4119     AudiomanagerRoutinginterface *object)
4120 {
4121   g_signal_emit_by_name (object, "set-routing-rundown");
4122 }
4123
4124 /**
4125  * audiomanager_routinginterface_call_ack_connect:
4126  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4127  * @arg_handle: Argument to pass with the method invocation.
4128  * @arg_connectionID: Argument to pass with the method invocation.
4129  * @arg_error: Argument to pass with the method invocation.
4130  * @cancellable: (allow-none): A #GCancellable or %NULL.
4131  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4132  * @user_data: User data to pass to @callback.
4133  *
4134  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackConnect">ackConnect()</link> D-Bus method on @proxy.
4135  * 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.
4136  * You can then call audiomanager_routinginterface_call_ack_connect_finish() to get the result of the operation.
4137  *
4138  * See audiomanager_routinginterface_call_ack_connect_sync() for the synchronous, blocking version of this method.
4139  */
4140 void
4141 audiomanager_routinginterface_call_ack_connect (
4142     AudiomanagerRoutinginterface *proxy,
4143     guint16 arg_handle,
4144     guint16 arg_connectionID,
4145     guint16 arg_error,
4146     GCancellable *cancellable,
4147     GAsyncReadyCallback callback,
4148     gpointer user_data)
4149 {
4150   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4151     "ackConnect",
4152     g_variant_new ("(qqq)",
4153                    arg_handle,
4154                    arg_connectionID,
4155                    arg_error),
4156     G_DBUS_CALL_FLAGS_NONE,
4157     -1,
4158     cancellable,
4159     callback,
4160     user_data);
4161 }
4162
4163 /**
4164  * audiomanager_routinginterface_call_ack_connect_finish:
4165  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4166  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_connect().
4167  * @error: Return location for error or %NULL.
4168  *
4169  * Finishes an operation started with audiomanager_routinginterface_call_ack_connect().
4170  *
4171  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4172  */
4173 gboolean
4174 audiomanager_routinginterface_call_ack_connect_finish (
4175     AudiomanagerRoutinginterface *proxy,
4176     GAsyncResult *res,
4177     GError **error)
4178 {
4179   GVariant *_ret;
4180   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4181   if (_ret == NULL)
4182     goto _out;
4183   g_variant_get (_ret,
4184                  "()");
4185   g_variant_unref (_ret);
4186 _out:
4187   return _ret != NULL;
4188 }
4189
4190 /**
4191  * audiomanager_routinginterface_call_ack_connect_sync:
4192  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4193  * @arg_handle: Argument to pass with the method invocation.
4194  * @arg_connectionID: Argument to pass with the method invocation.
4195  * @arg_error: Argument to pass with the method invocation.
4196  * @cancellable: (allow-none): A #GCancellable or %NULL.
4197  * @error: Return location for error or %NULL.
4198  *
4199  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackConnect">ackConnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4200  *
4201  * See audiomanager_routinginterface_call_ack_connect() for the asynchronous version of this method.
4202  *
4203  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4204  */
4205 gboolean
4206 audiomanager_routinginterface_call_ack_connect_sync (
4207     AudiomanagerRoutinginterface *proxy,
4208     guint16 arg_handle,
4209     guint16 arg_connectionID,
4210     guint16 arg_error,
4211     GCancellable *cancellable,
4212     GError **error)
4213 {
4214   GVariant *_ret;
4215   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4216     "ackConnect",
4217     g_variant_new ("(qqq)",
4218                    arg_handle,
4219                    arg_connectionID,
4220                    arg_error),
4221     G_DBUS_CALL_FLAGS_NONE,
4222     -1,
4223     cancellable,
4224     error);
4225   if (_ret == NULL)
4226     goto _out;
4227   g_variant_get (_ret,
4228                  "()");
4229   g_variant_unref (_ret);
4230 _out:
4231   return _ret != NULL;
4232 }
4233
4234 /**
4235  * audiomanager_routinginterface_call_ack_disconnect:
4236  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4237  * @arg_handle: Argument to pass with the method invocation.
4238  * @arg_connectionID: Argument to pass with the method invocation.
4239  * @arg_error: Argument to pass with the method invocation.
4240  * @cancellable: (allow-none): A #GCancellable or %NULL.
4241  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4242  * @user_data: User data to pass to @callback.
4243  *
4244  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackDisconnect">ackDisconnect()</link> D-Bus method on @proxy.
4245  * 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.
4246  * You can then call audiomanager_routinginterface_call_ack_disconnect_finish() to get the result of the operation.
4247  *
4248  * See audiomanager_routinginterface_call_ack_disconnect_sync() for the synchronous, blocking version of this method.
4249  */
4250 void
4251 audiomanager_routinginterface_call_ack_disconnect (
4252     AudiomanagerRoutinginterface *proxy,
4253     guint16 arg_handle,
4254     guint16 arg_connectionID,
4255     guint16 arg_error,
4256     GCancellable *cancellable,
4257     GAsyncReadyCallback callback,
4258     gpointer user_data)
4259 {
4260   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4261     "ackDisconnect",
4262     g_variant_new ("(qqq)",
4263                    arg_handle,
4264                    arg_connectionID,
4265                    arg_error),
4266     G_DBUS_CALL_FLAGS_NONE,
4267     -1,
4268     cancellable,
4269     callback,
4270     user_data);
4271 }
4272
4273 /**
4274  * audiomanager_routinginterface_call_ack_disconnect_finish:
4275  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4276  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_disconnect().
4277  * @error: Return location for error or %NULL.
4278  *
4279  * Finishes an operation started with audiomanager_routinginterface_call_ack_disconnect().
4280  *
4281  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4282  */
4283 gboolean
4284 audiomanager_routinginterface_call_ack_disconnect_finish (
4285     AudiomanagerRoutinginterface *proxy,
4286     GAsyncResult *res,
4287     GError **error)
4288 {
4289   GVariant *_ret;
4290   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4291   if (_ret == NULL)
4292     goto _out;
4293   g_variant_get (_ret,
4294                  "()");
4295   g_variant_unref (_ret);
4296 _out:
4297   return _ret != NULL;
4298 }
4299
4300 /**
4301  * audiomanager_routinginterface_call_ack_disconnect_sync:
4302  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4303  * @arg_handle: Argument to pass with the method invocation.
4304  * @arg_connectionID: Argument to pass with the method invocation.
4305  * @arg_error: Argument to pass with the method invocation.
4306  * @cancellable: (allow-none): A #GCancellable or %NULL.
4307  * @error: Return location for error or %NULL.
4308  *
4309  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackDisconnect">ackDisconnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4310  *
4311  * See audiomanager_routinginterface_call_ack_disconnect() for the asynchronous version of this method.
4312  *
4313  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4314  */
4315 gboolean
4316 audiomanager_routinginterface_call_ack_disconnect_sync (
4317     AudiomanagerRoutinginterface *proxy,
4318     guint16 arg_handle,
4319     guint16 arg_connectionID,
4320     guint16 arg_error,
4321     GCancellable *cancellable,
4322     GError **error)
4323 {
4324   GVariant *_ret;
4325   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4326     "ackDisconnect",
4327     g_variant_new ("(qqq)",
4328                    arg_handle,
4329                    arg_connectionID,
4330                    arg_error),
4331     G_DBUS_CALL_FLAGS_NONE,
4332     -1,
4333     cancellable,
4334     error);
4335   if (_ret == NULL)
4336     goto _out;
4337   g_variant_get (_ret,
4338                  "()");
4339   g_variant_unref (_ret);
4340 _out:
4341   return _ret != NULL;
4342 }
4343
4344 /**
4345  * audiomanager_routinginterface_call_ack_set_source_state:
4346  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4347  * @arg_handle: Argument to pass with the method invocation.
4348  * @arg_error: Argument to pass with the method invocation.
4349  * @cancellable: (allow-none): A #GCancellable or %NULL.
4350  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4351  * @user_data: User data to pass to @callback.
4352  *
4353  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSourceState">ackSetSourceState()</link> D-Bus method on @proxy.
4354  * 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.
4355  * You can then call audiomanager_routinginterface_call_ack_set_source_state_finish() to get the result of the operation.
4356  *
4357  * See audiomanager_routinginterface_call_ack_set_source_state_sync() for the synchronous, blocking version of this method.
4358  */
4359 void
4360 audiomanager_routinginterface_call_ack_set_source_state (
4361     AudiomanagerRoutinginterface *proxy,
4362     guint16 arg_handle,
4363     guint16 arg_error,
4364     GCancellable *cancellable,
4365     GAsyncReadyCallback callback,
4366     gpointer user_data)
4367 {
4368   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4369     "ackSetSourceState",
4370     g_variant_new ("(qq)",
4371                    arg_handle,
4372                    arg_error),
4373     G_DBUS_CALL_FLAGS_NONE,
4374     -1,
4375     cancellable,
4376     callback,
4377     user_data);
4378 }
4379
4380 /**
4381  * audiomanager_routinginterface_call_ack_set_source_state_finish:
4382  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4383  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_source_state().
4384  * @error: Return location for error or %NULL.
4385  *
4386  * Finishes an operation started with audiomanager_routinginterface_call_ack_set_source_state().
4387  *
4388  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4389  */
4390 gboolean
4391 audiomanager_routinginterface_call_ack_set_source_state_finish (
4392     AudiomanagerRoutinginterface *proxy,
4393     GAsyncResult *res,
4394     GError **error)
4395 {
4396   GVariant *_ret;
4397   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4398   if (_ret == NULL)
4399     goto _out;
4400   g_variant_get (_ret,
4401                  "()");
4402   g_variant_unref (_ret);
4403 _out:
4404   return _ret != NULL;
4405 }
4406
4407 /**
4408  * audiomanager_routinginterface_call_ack_set_source_state_sync:
4409  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4410  * @arg_handle: Argument to pass with the method invocation.
4411  * @arg_error: Argument to pass with the method invocation.
4412  * @cancellable: (allow-none): A #GCancellable or %NULL.
4413  * @error: Return location for error or %NULL.
4414  *
4415  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSourceState">ackSetSourceState()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4416  *
4417  * See audiomanager_routinginterface_call_ack_set_source_state() for the asynchronous version of this method.
4418  *
4419  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4420  */
4421 gboolean
4422 audiomanager_routinginterface_call_ack_set_source_state_sync (
4423     AudiomanagerRoutinginterface *proxy,
4424     guint16 arg_handle,
4425     guint16 arg_error,
4426     GCancellable *cancellable,
4427     GError **error)
4428 {
4429   GVariant *_ret;
4430   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4431     "ackSetSourceState",
4432     g_variant_new ("(qq)",
4433                    arg_handle,
4434                    arg_error),
4435     G_DBUS_CALL_FLAGS_NONE,
4436     -1,
4437     cancellable,
4438     error);
4439   if (_ret == NULL)
4440     goto _out;
4441   g_variant_get (_ret,
4442                  "()");
4443   g_variant_unref (_ret);
4444 _out:
4445   return _ret != NULL;
4446 }
4447
4448 /**
4449  * audiomanager_routinginterface_call_ack_set_sink_volume:
4450  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4451  * @arg_handle: Argument to pass with the method invocation.
4452  * @arg_volume: Argument to pass with the method invocation.
4453  * @arg_error: Argument to pass with the method invocation.
4454  * @cancellable: (allow-none): A #GCancellable or %NULL.
4455  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4456  * @user_data: User data to pass to @callback.
4457  *
4458  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSinkVolume">ackSetSinkVolume()</link> D-Bus method on @proxy.
4459  * 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.
4460  * You can then call audiomanager_routinginterface_call_ack_set_sink_volume_finish() to get the result of the operation.
4461  *
4462  * See audiomanager_routinginterface_call_ack_set_sink_volume_sync() for the synchronous, blocking version of this method.
4463  */
4464 void
4465 audiomanager_routinginterface_call_ack_set_sink_volume (
4466     AudiomanagerRoutinginterface *proxy,
4467     guint16 arg_handle,
4468     gint16 arg_volume,
4469     guint16 arg_error,
4470     GCancellable *cancellable,
4471     GAsyncReadyCallback callback,
4472     gpointer user_data)
4473 {
4474   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4475     "ackSetSinkVolume",
4476     g_variant_new ("(qnq)",
4477                    arg_handle,
4478                    arg_volume,
4479                    arg_error),
4480     G_DBUS_CALL_FLAGS_NONE,
4481     -1,
4482     cancellable,
4483     callback,
4484     user_data);
4485 }
4486
4487 /**
4488  * audiomanager_routinginterface_call_ack_set_sink_volume_finish:
4489  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4490  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_sink_volume().
4491  * @error: Return location for error or %NULL.
4492  *
4493  * Finishes an operation started with audiomanager_routinginterface_call_ack_set_sink_volume().
4494  *
4495  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4496  */
4497 gboolean
4498 audiomanager_routinginterface_call_ack_set_sink_volume_finish (
4499     AudiomanagerRoutinginterface *proxy,
4500     GAsyncResult *res,
4501     GError **error)
4502 {
4503   GVariant *_ret;
4504   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4505   if (_ret == NULL)
4506     goto _out;
4507   g_variant_get (_ret,
4508                  "()");
4509   g_variant_unref (_ret);
4510 _out:
4511   return _ret != NULL;
4512 }
4513
4514 /**
4515  * audiomanager_routinginterface_call_ack_set_sink_volume_sync:
4516  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4517  * @arg_handle: Argument to pass with the method invocation.
4518  * @arg_volume: Argument to pass with the method invocation.
4519  * @arg_error: Argument to pass with the method invocation.
4520  * @cancellable: (allow-none): A #GCancellable or %NULL.
4521  * @error: Return location for error or %NULL.
4522  *
4523  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSinkVolume">ackSetSinkVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4524  *
4525  * See audiomanager_routinginterface_call_ack_set_sink_volume() for the asynchronous version of this method.
4526  *
4527  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4528  */
4529 gboolean
4530 audiomanager_routinginterface_call_ack_set_sink_volume_sync (
4531     AudiomanagerRoutinginterface *proxy,
4532     guint16 arg_handle,
4533     gint16 arg_volume,
4534     guint16 arg_error,
4535     GCancellable *cancellable,
4536     GError **error)
4537 {
4538   GVariant *_ret;
4539   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4540     "ackSetSinkVolume",
4541     g_variant_new ("(qnq)",
4542                    arg_handle,
4543                    arg_volume,
4544                    arg_error),
4545     G_DBUS_CALL_FLAGS_NONE,
4546     -1,
4547     cancellable,
4548     error);
4549   if (_ret == NULL)
4550     goto _out;
4551   g_variant_get (_ret,
4552                  "()");
4553   g_variant_unref (_ret);
4554 _out:
4555   return _ret != NULL;
4556 }
4557
4558 /**
4559  * audiomanager_routinginterface_call_register_sink:
4560  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4561  * @arg_sinkData: Argument to pass with the method invocation.
4562  * @cancellable: (allow-none): A #GCancellable or %NULL.
4563  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4564  * @user_data: User data to pass to @callback.
4565  *
4566  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSink">registerSink()</link> D-Bus method on @proxy.
4567  * 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.
4568  * You can then call audiomanager_routinginterface_call_register_sink_finish() to get the result of the operation.
4569  *
4570  * See audiomanager_routinginterface_call_register_sink_sync() for the synchronous, blocking version of this method.
4571  */
4572 void
4573 audiomanager_routinginterface_call_register_sink (
4574     AudiomanagerRoutinginterface *proxy,
4575     GVariant *arg_sinkData,
4576     GCancellable *cancellable,
4577     GAsyncReadyCallback callback,
4578     gpointer user_data)
4579 {
4580   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4581     "registerSink",
4582     g_variant_new ("(@(qsqinb(ii)nna(in)aia(in)a(iin)a(iin)))",
4583                    arg_sinkData),
4584     G_DBUS_CALL_FLAGS_NONE,
4585     -1,
4586     cancellable,
4587     callback,
4588     user_data);
4589 }
4590
4591 /**
4592  * audiomanager_routinginterface_call_register_sink_finish:
4593  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4594  * @out_sinkID: (out): Return location for return parameter or %NULL to ignore.
4595  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4596  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_sink().
4597  * @error: Return location for error or %NULL.
4598  *
4599  * Finishes an operation started with audiomanager_routinginterface_call_register_sink().
4600  *
4601  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4602  */
4603 gboolean
4604 audiomanager_routinginterface_call_register_sink_finish (
4605     AudiomanagerRoutinginterface *proxy,
4606     guint16 *out_sinkID,
4607     guint16 *out_error,
4608     GAsyncResult *res,
4609     GError **error)
4610 {
4611   GVariant *_ret;
4612   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4613   if (_ret == NULL)
4614     goto _out;
4615   g_variant_get (_ret,
4616                  "(qq)",
4617                  out_sinkID,
4618                  out_error);
4619   g_variant_unref (_ret);
4620 _out:
4621   return _ret != NULL;
4622 }
4623
4624 /**
4625  * audiomanager_routinginterface_call_register_sink_sync:
4626  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4627  * @arg_sinkData: Argument to pass with the method invocation.
4628  * @out_sinkID: (out): Return location for return parameter or %NULL to ignore.
4629  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4630  * @cancellable: (allow-none): A #GCancellable or %NULL.
4631  * @error: Return location for error or %NULL.
4632  *
4633  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSink">registerSink()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4634  *
4635  * See audiomanager_routinginterface_call_register_sink() for the asynchronous version of this method.
4636  *
4637  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4638  */
4639 gboolean
4640 audiomanager_routinginterface_call_register_sink_sync (
4641     AudiomanagerRoutinginterface *proxy,
4642     GVariant *arg_sinkData,
4643     guint16 *out_sinkID,
4644     guint16 *out_error,
4645     GCancellable *cancellable,
4646     GError **error)
4647 {
4648   GVariant *_ret;
4649   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4650     "registerSink",
4651     g_variant_new ("(@(qsqinb(ii)nna(in)aia(in)a(iin)a(iin)))",
4652                    arg_sinkData),
4653     G_DBUS_CALL_FLAGS_NONE,
4654     -1,
4655     cancellable,
4656     error);
4657   if (_ret == NULL)
4658     goto _out;
4659   g_variant_get (_ret,
4660                  "(qq)",
4661                  out_sinkID,
4662                  out_error);
4663   g_variant_unref (_ret);
4664 _out:
4665   return _ret != NULL;
4666 }
4667
4668 /**
4669  * audiomanager_routinginterface_call_deregister_sink:
4670  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4671  * @arg_sinkID: Argument to pass with the method invocation.
4672  * @cancellable: (allow-none): A #GCancellable or %NULL.
4673  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4674  * @user_data: User data to pass to @callback.
4675  *
4676  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSink">deregisterSink()</link> D-Bus method on @proxy.
4677  * 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.
4678  * You can then call audiomanager_routinginterface_call_deregister_sink_finish() to get the result of the operation.
4679  *
4680  * See audiomanager_routinginterface_call_deregister_sink_sync() for the synchronous, blocking version of this method.
4681  */
4682 void
4683 audiomanager_routinginterface_call_deregister_sink (
4684     AudiomanagerRoutinginterface *proxy,
4685     guint16 arg_sinkID,
4686     GCancellable *cancellable,
4687     GAsyncReadyCallback callback,
4688     gpointer user_data)
4689 {
4690   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4691     "deregisterSink",
4692     g_variant_new ("(q)",
4693                    arg_sinkID),
4694     G_DBUS_CALL_FLAGS_NONE,
4695     -1,
4696     cancellable,
4697     callback,
4698     user_data);
4699 }
4700
4701 /**
4702  * audiomanager_routinginterface_call_deregister_sink_finish:
4703  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4704  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4705  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_deregister_sink().
4706  * @error: Return location for error or %NULL.
4707  *
4708  * Finishes an operation started with audiomanager_routinginterface_call_deregister_sink().
4709  *
4710  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4711  */
4712 gboolean
4713 audiomanager_routinginterface_call_deregister_sink_finish (
4714     AudiomanagerRoutinginterface *proxy,
4715     gint *out_error,
4716     GAsyncResult *res,
4717     GError **error)
4718 {
4719   GVariant *_ret;
4720   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4721   if (_ret == NULL)
4722     goto _out;
4723   g_variant_get (_ret,
4724                  "(i)",
4725                  out_error);
4726   g_variant_unref (_ret);
4727 _out:
4728   return _ret != NULL;
4729 }
4730
4731 /**
4732  * audiomanager_routinginterface_call_deregister_sink_sync:
4733  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4734  * @arg_sinkID: Argument to pass with the method invocation.
4735  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4736  * @cancellable: (allow-none): A #GCancellable or %NULL.
4737  * @error: Return location for error or %NULL.
4738  *
4739  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSink">deregisterSink()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4740  *
4741  * See audiomanager_routinginterface_call_deregister_sink() for the asynchronous version of this method.
4742  *
4743  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4744  */
4745 gboolean
4746 audiomanager_routinginterface_call_deregister_sink_sync (
4747     AudiomanagerRoutinginterface *proxy,
4748     guint16 arg_sinkID,
4749     gint *out_error,
4750     GCancellable *cancellable,
4751     GError **error)
4752 {
4753   GVariant *_ret;
4754   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4755     "deregisterSink",
4756     g_variant_new ("(q)",
4757                    arg_sinkID),
4758     G_DBUS_CALL_FLAGS_NONE,
4759     -1,
4760     cancellable,
4761     error);
4762   if (_ret == NULL)
4763     goto _out;
4764   g_variant_get (_ret,
4765                  "(i)",
4766                  out_error);
4767   g_variant_unref (_ret);
4768 _out:
4769   return _ret != NULL;
4770 }
4771
4772 /**
4773  * audiomanager_routinginterface_call_register_source:
4774  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4775  * @arg_sourceData: Argument to pass with the method invocation.
4776  * @cancellable: (allow-none): A #GCancellable or %NULL.
4777  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4778  * @user_data: User data to pass to @callback.
4779  *
4780  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSource">registerSource()</link> D-Bus method on @proxy.
4781  * 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.
4782  * You can then call audiomanager_routinginterface_call_register_source_finish() to get the result of the operation.
4783  *
4784  * See audiomanager_routinginterface_call_register_source_sync() for the synchronous, blocking version of this method.
4785  */
4786 void
4787 audiomanager_routinginterface_call_register_source (
4788     AudiomanagerRoutinginterface *proxy,
4789     GVariant *arg_sourceData,
4790     GCancellable *cancellable,
4791     GAsyncReadyCallback callback,
4792     gpointer user_data)
4793 {
4794   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4795     "registerSource",
4796     g_variant_new ("(@(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin)))",
4797                    arg_sourceData),
4798     G_DBUS_CALL_FLAGS_NONE,
4799     -1,
4800     cancellable,
4801     callback,
4802     user_data);
4803 }
4804
4805 /**
4806  * audiomanager_routinginterface_call_register_source_finish:
4807  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4808  * @out_sourceID: (out): Return location for return parameter or %NULL to ignore.
4809  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4810  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_source().
4811  * @error: Return location for error or %NULL.
4812  *
4813  * Finishes an operation started with audiomanager_routinginterface_call_register_source().
4814  *
4815  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4816  */
4817 gboolean
4818 audiomanager_routinginterface_call_register_source_finish (
4819     AudiomanagerRoutinginterface *proxy,
4820     guint16 *out_sourceID,
4821     guint16 *out_error,
4822     GAsyncResult *res,
4823     GError **error)
4824 {
4825   GVariant *_ret;
4826   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4827   if (_ret == NULL)
4828     goto _out;
4829   g_variant_get (_ret,
4830                  "(qq)",
4831                  out_sourceID,
4832                  out_error);
4833   g_variant_unref (_ret);
4834 _out:
4835   return _ret != NULL;
4836 }
4837
4838 /**
4839  * audiomanager_routinginterface_call_register_source_sync:
4840  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4841  * @arg_sourceData: Argument to pass with the method invocation.
4842  * @out_sourceID: (out): Return location for return parameter or %NULL to ignore.
4843  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4844  * @cancellable: (allow-none): A #GCancellable or %NULL.
4845  * @error: Return location for error or %NULL.
4846  *
4847  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSource">registerSource()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4848  *
4849  * See audiomanager_routinginterface_call_register_source() for the asynchronous version of this method.
4850  *
4851  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4852  */
4853 gboolean
4854 audiomanager_routinginterface_call_register_source_sync (
4855     AudiomanagerRoutinginterface *proxy,
4856     GVariant *arg_sourceData,
4857     guint16 *out_sourceID,
4858     guint16 *out_error,
4859     GCancellable *cancellable,
4860     GError **error)
4861 {
4862   GVariant *_ret;
4863   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4864     "registerSource",
4865     g_variant_new ("(@(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin)))",
4866                    arg_sourceData),
4867     G_DBUS_CALL_FLAGS_NONE,
4868     -1,
4869     cancellable,
4870     error);
4871   if (_ret == NULL)
4872     goto _out;
4873   g_variant_get (_ret,
4874                  "(qq)",
4875                  out_sourceID,
4876                  out_error);
4877   g_variant_unref (_ret);
4878 _out:
4879   return _ret != NULL;
4880 }
4881
4882 /**
4883  * audiomanager_routinginterface_call_deregister_source:
4884  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4885  * @arg_sourceID: Argument to pass with the method invocation.
4886  * @cancellable: (allow-none): A #GCancellable or %NULL.
4887  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4888  * @user_data: User data to pass to @callback.
4889  *
4890  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSource">deregisterSource()</link> D-Bus method on @proxy.
4891  * 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.
4892  * You can then call audiomanager_routinginterface_call_deregister_source_finish() to get the result of the operation.
4893  *
4894  * See audiomanager_routinginterface_call_deregister_source_sync() for the synchronous, blocking version of this method.
4895  */
4896 void
4897 audiomanager_routinginterface_call_deregister_source (
4898     AudiomanagerRoutinginterface *proxy,
4899     guint16 arg_sourceID,
4900     GCancellable *cancellable,
4901     GAsyncReadyCallback callback,
4902     gpointer user_data)
4903 {
4904   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4905     "deregisterSource",
4906     g_variant_new ("(q)",
4907                    arg_sourceID),
4908     G_DBUS_CALL_FLAGS_NONE,
4909     -1,
4910     cancellable,
4911     callback,
4912     user_data);
4913 }
4914
4915 /**
4916  * audiomanager_routinginterface_call_deregister_source_finish:
4917  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4918  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4919  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_deregister_source().
4920  * @error: Return location for error or %NULL.
4921  *
4922  * Finishes an operation started with audiomanager_routinginterface_call_deregister_source().
4923  *
4924  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4925  */
4926 gboolean
4927 audiomanager_routinginterface_call_deregister_source_finish (
4928     AudiomanagerRoutinginterface *proxy,
4929     guint16 *out_error,
4930     GAsyncResult *res,
4931     GError **error)
4932 {
4933   GVariant *_ret;
4934   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4935   if (_ret == NULL)
4936     goto _out;
4937   g_variant_get (_ret,
4938                  "(q)",
4939                  out_error);
4940   g_variant_unref (_ret);
4941 _out:
4942   return _ret != NULL;
4943 }
4944
4945 /**
4946  * audiomanager_routinginterface_call_deregister_source_sync:
4947  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4948  * @arg_sourceID: Argument to pass with the method invocation.
4949  * @out_error: (out): Return location for return parameter or %NULL to ignore.
4950  * @cancellable: (allow-none): A #GCancellable or %NULL.
4951  * @error: Return location for error or %NULL.
4952  *
4953  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSource">deregisterSource()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4954  *
4955  * See audiomanager_routinginterface_call_deregister_source() for the asynchronous version of this method.
4956  *
4957  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4958  */
4959 gboolean
4960 audiomanager_routinginterface_call_deregister_source_sync (
4961     AudiomanagerRoutinginterface *proxy,
4962     guint16 arg_sourceID,
4963     guint16 *out_error,
4964     GCancellable *cancellable,
4965     GError **error)
4966 {
4967   GVariant *_ret;
4968   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4969     "deregisterSource",
4970     g_variant_new ("(q)",
4971                    arg_sourceID),
4972     G_DBUS_CALL_FLAGS_NONE,
4973     -1,
4974     cancellable,
4975     error);
4976   if (_ret == NULL)
4977     goto _out;
4978   g_variant_get (_ret,
4979                  "(q)",
4980                  out_error);
4981   g_variant_unref (_ret);
4982 _out:
4983   return _ret != NULL;
4984 }
4985
4986 /**
4987  * audiomanager_routinginterface_call_hook_interrupt_status_change:
4988  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
4989  * @arg_sourceID: Argument to pass with the method invocation.
4990  * @arg_interruptState: Argument to pass with the method invocation.
4991  * @cancellable: (allow-none): A #GCancellable or %NULL.
4992  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4993  * @user_data: User data to pass to @callback.
4994  *
4995  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookInterruptStatusChange">hookInterruptStatusChange()</link> D-Bus method on @proxy.
4996  * 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.
4997  * You can then call audiomanager_routinginterface_call_hook_interrupt_status_change_finish() to get the result of the operation.
4998  *
4999  * See audiomanager_routinginterface_call_hook_interrupt_status_change_sync() for the synchronous, blocking version of this method.
5000  */
5001 void
5002 audiomanager_routinginterface_call_hook_interrupt_status_change (
5003     AudiomanagerRoutinginterface *proxy,
5004     guint16 arg_sourceID,
5005     guint16 arg_interruptState,
5006     GCancellable *cancellable,
5007     GAsyncReadyCallback callback,
5008     gpointer user_data)
5009 {
5010   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5011     "hookInterruptStatusChange",
5012     g_variant_new ("(qq)",
5013                    arg_sourceID,
5014                    arg_interruptState),
5015     G_DBUS_CALL_FLAGS_NONE,
5016     -1,
5017     cancellable,
5018     callback,
5019     user_data);
5020 }
5021
5022 /**
5023  * audiomanager_routinginterface_call_hook_interrupt_status_change_finish:
5024  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5025  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_hook_interrupt_status_change().
5026  * @error: Return location for error or %NULL.
5027  *
5028  * Finishes an operation started with audiomanager_routinginterface_call_hook_interrupt_status_change().
5029  *
5030  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5031  */
5032 gboolean
5033 audiomanager_routinginterface_call_hook_interrupt_status_change_finish (
5034     AudiomanagerRoutinginterface *proxy,
5035     GAsyncResult *res,
5036     GError **error)
5037 {
5038   GVariant *_ret;
5039   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5040   if (_ret == NULL)
5041     goto _out;
5042   g_variant_get (_ret,
5043                  "()");
5044   g_variant_unref (_ret);
5045 _out:
5046   return _ret != NULL;
5047 }
5048
5049 /**
5050  * audiomanager_routinginterface_call_hook_interrupt_status_change_sync:
5051  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5052  * @arg_sourceID: Argument to pass with the method invocation.
5053  * @arg_interruptState: Argument to pass with the method invocation.
5054  * @cancellable: (allow-none): A #GCancellable or %NULL.
5055  * @error: Return location for error or %NULL.
5056  *
5057  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookInterruptStatusChange">hookInterruptStatusChange()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5058  *
5059  * See audiomanager_routinginterface_call_hook_interrupt_status_change() for the asynchronous version of this method.
5060  *
5061  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5062  */
5063 gboolean
5064 audiomanager_routinginterface_call_hook_interrupt_status_change_sync (
5065     AudiomanagerRoutinginterface *proxy,
5066     guint16 arg_sourceID,
5067     guint16 arg_interruptState,
5068     GCancellable *cancellable,
5069     GError **error)
5070 {
5071   GVariant *_ret;
5072   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5073     "hookInterruptStatusChange",
5074     g_variant_new ("(qq)",
5075                    arg_sourceID,
5076                    arg_interruptState),
5077     G_DBUS_CALL_FLAGS_NONE,
5078     -1,
5079     cancellable,
5080     error);
5081   if (_ret == NULL)
5082     goto _out;
5083   g_variant_get (_ret,
5084                  "()");
5085   g_variant_unref (_ret);
5086 _out:
5087   return _ret != NULL;
5088 }
5089
5090 /**
5091  * audiomanager_routinginterface_call_hook_source_availablity_status_change:
5092  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5093  * @arg_sourceID: Argument to pass with the method invocation.
5094  * @arg_availability: Argument to pass with the method invocation.
5095  * @cancellable: (allow-none): A #GCancellable or %NULL.
5096  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5097  * @user_data: User data to pass to @callback.
5098  *
5099  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookSourceAvailablityStatusChange">hookSourceAvailablityStatusChange()</link> D-Bus method on @proxy.
5100  * 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.
5101  * You can then call audiomanager_routinginterface_call_hook_source_availablity_status_change_finish() to get the result of the operation.
5102  *
5103  * See audiomanager_routinginterface_call_hook_source_availablity_status_change_sync() for the synchronous, blocking version of this method.
5104  */
5105 void
5106 audiomanager_routinginterface_call_hook_source_availablity_status_change (
5107     AudiomanagerRoutinginterface *proxy,
5108     guint16 arg_sourceID,
5109     GVariant *arg_availability,
5110     GCancellable *cancellable,
5111     GAsyncReadyCallback callback,
5112     gpointer user_data)
5113 {
5114   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5115     "hookSourceAvailablityStatusChange",
5116     g_variant_new ("(q@(nn))",
5117                    arg_sourceID,
5118                    arg_availability),
5119     G_DBUS_CALL_FLAGS_NONE,
5120     -1,
5121     cancellable,
5122     callback,
5123     user_data);
5124 }
5125
5126 /**
5127  * audiomanager_routinginterface_call_hook_source_availablity_status_change_finish:
5128  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5129  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_hook_source_availablity_status_change().
5130  * @error: Return location for error or %NULL.
5131  *
5132  * Finishes an operation started with audiomanager_routinginterface_call_hook_source_availablity_status_change().
5133  *
5134  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5135  */
5136 gboolean
5137 audiomanager_routinginterface_call_hook_source_availablity_status_change_finish (
5138     AudiomanagerRoutinginterface *proxy,
5139     GAsyncResult *res,
5140     GError **error)
5141 {
5142   GVariant *_ret;
5143   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5144   if (_ret == NULL)
5145     goto _out;
5146   g_variant_get (_ret,
5147                  "()");
5148   g_variant_unref (_ret);
5149 _out:
5150   return _ret != NULL;
5151 }
5152
5153 /**
5154  * audiomanager_routinginterface_call_hook_source_availablity_status_change_sync:
5155  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5156  * @arg_sourceID: Argument to pass with the method invocation.
5157  * @arg_availability: Argument to pass with the method invocation.
5158  * @cancellable: (allow-none): A #GCancellable or %NULL.
5159  * @error: Return location for error or %NULL.
5160  *
5161  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookSourceAvailablityStatusChange">hookSourceAvailablityStatusChange()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5162  *
5163  * See audiomanager_routinginterface_call_hook_source_availablity_status_change() for the asynchronous version of this method.
5164  *
5165  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5166  */
5167 gboolean
5168 audiomanager_routinginterface_call_hook_source_availablity_status_change_sync (
5169     AudiomanagerRoutinginterface *proxy,
5170     guint16 arg_sourceID,
5171     GVariant *arg_availability,
5172     GCancellable *cancellable,
5173     GError **error)
5174 {
5175   GVariant *_ret;
5176   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5177     "hookSourceAvailablityStatusChange",
5178     g_variant_new ("(q@(nn))",
5179                    arg_sourceID,
5180                    arg_availability),
5181     G_DBUS_CALL_FLAGS_NONE,
5182     -1,
5183     cancellable,
5184     error);
5185   if (_ret == NULL)
5186     goto _out;
5187   g_variant_get (_ret,
5188                  "()");
5189   g_variant_unref (_ret);
5190 _out:
5191   return _ret != NULL;
5192 }
5193
5194 /**
5195  * audiomanager_routinginterface_call_confirm_routing_ready:
5196  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5197  * @arg_domainID: Argument to pass with the method invocation.
5198  * @cancellable: (allow-none): A #GCancellable or %NULL.
5199  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5200  * @user_data: User data to pass to @callback.
5201  *
5202  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingReady">confirmRoutingReady()</link> D-Bus method on @proxy.
5203  * 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.
5204  * You can then call audiomanager_routinginterface_call_confirm_routing_ready_finish() to get the result of the operation.
5205  *
5206  * See audiomanager_routinginterface_call_confirm_routing_ready_sync() for the synchronous, blocking version of this method.
5207  */
5208 void
5209 audiomanager_routinginterface_call_confirm_routing_ready (
5210     AudiomanagerRoutinginterface *proxy,
5211     guint16 arg_domainID,
5212     GCancellable *cancellable,
5213     GAsyncReadyCallback callback,
5214     gpointer user_data)
5215 {
5216   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5217     "confirmRoutingReady",
5218     g_variant_new ("(q)",
5219                    arg_domainID),
5220     G_DBUS_CALL_FLAGS_NONE,
5221     -1,
5222     cancellable,
5223     callback,
5224     user_data);
5225 }
5226
5227 /**
5228  * audiomanager_routinginterface_call_confirm_routing_ready_finish:
5229  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5230  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_confirm_routing_ready().
5231  * @error: Return location for error or %NULL.
5232  *
5233  * Finishes an operation started with audiomanager_routinginterface_call_confirm_routing_ready().
5234  *
5235  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5236  */
5237 gboolean
5238 audiomanager_routinginterface_call_confirm_routing_ready_finish (
5239     AudiomanagerRoutinginterface *proxy,
5240     GAsyncResult *res,
5241     GError **error)
5242 {
5243   GVariant *_ret;
5244   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5245   if (_ret == NULL)
5246     goto _out;
5247   g_variant_get (_ret,
5248                  "()");
5249   g_variant_unref (_ret);
5250 _out:
5251   return _ret != NULL;
5252 }
5253
5254 /**
5255  * audiomanager_routinginterface_call_confirm_routing_ready_sync:
5256  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5257  * @arg_domainID: Argument to pass with the method invocation.
5258  * @cancellable: (allow-none): A #GCancellable or %NULL.
5259  * @error: Return location for error or %NULL.
5260  *
5261  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingReady">confirmRoutingReady()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5262  *
5263  * See audiomanager_routinginterface_call_confirm_routing_ready() for the asynchronous version of this method.
5264  *
5265  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5266  */
5267 gboolean
5268 audiomanager_routinginterface_call_confirm_routing_ready_sync (
5269     AudiomanagerRoutinginterface *proxy,
5270     guint16 arg_domainID,
5271     GCancellable *cancellable,
5272     GError **error)
5273 {
5274   GVariant *_ret;
5275   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5276     "confirmRoutingReady",
5277     g_variant_new ("(q)",
5278                    arg_domainID),
5279     G_DBUS_CALL_FLAGS_NONE,
5280     -1,
5281     cancellable,
5282     error);
5283   if (_ret == NULL)
5284     goto _out;
5285   g_variant_get (_ret,
5286                  "()");
5287   g_variant_unref (_ret);
5288 _out:
5289   return _ret != NULL;
5290 }
5291
5292 /**
5293  * audiomanager_routinginterface_call_confirm_routing_rundown:
5294  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5295  * @arg_domainID: Argument to pass with the method invocation.
5296  * @cancellable: (allow-none): A #GCancellable or %NULL.
5297  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5298  * @user_data: User data to pass to @callback.
5299  *
5300  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingRundown">confirmRoutingRundown()</link> D-Bus method on @proxy.
5301  * 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.
5302  * You can then call audiomanager_routinginterface_call_confirm_routing_rundown_finish() to get the result of the operation.
5303  *
5304  * See audiomanager_routinginterface_call_confirm_routing_rundown_sync() for the synchronous, blocking version of this method.
5305  */
5306 void
5307 audiomanager_routinginterface_call_confirm_routing_rundown (
5308     AudiomanagerRoutinginterface *proxy,
5309     guint16 arg_domainID,
5310     GCancellable *cancellable,
5311     GAsyncReadyCallback callback,
5312     gpointer user_data)
5313 {
5314   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5315     "confirmRoutingRundown",
5316     g_variant_new ("(q)",
5317                    arg_domainID),
5318     G_DBUS_CALL_FLAGS_NONE,
5319     -1,
5320     cancellable,
5321     callback,
5322     user_data);
5323 }
5324
5325 /**
5326  * audiomanager_routinginterface_call_confirm_routing_rundown_finish:
5327  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5328  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_confirm_routing_rundown().
5329  * @error: Return location for error or %NULL.
5330  *
5331  * Finishes an operation started with audiomanager_routinginterface_call_confirm_routing_rundown().
5332  *
5333  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5334  */
5335 gboolean
5336 audiomanager_routinginterface_call_confirm_routing_rundown_finish (
5337     AudiomanagerRoutinginterface *proxy,
5338     GAsyncResult *res,
5339     GError **error)
5340 {
5341   GVariant *_ret;
5342   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5343   if (_ret == NULL)
5344     goto _out;
5345   g_variant_get (_ret,
5346                  "()");
5347   g_variant_unref (_ret);
5348 _out:
5349   return _ret != NULL;
5350 }
5351
5352 /**
5353  * audiomanager_routinginterface_call_confirm_routing_rundown_sync:
5354  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5355  * @arg_domainID: Argument to pass with the method invocation.
5356  * @cancellable: (allow-none): A #GCancellable or %NULL.
5357  * @error: Return location for error or %NULL.
5358  *
5359  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingRundown">confirmRoutingRundown()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5360  *
5361  * See audiomanager_routinginterface_call_confirm_routing_rundown() for the asynchronous version of this method.
5362  *
5363  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5364  */
5365 gboolean
5366 audiomanager_routinginterface_call_confirm_routing_rundown_sync (
5367     AudiomanagerRoutinginterface *proxy,
5368     guint16 arg_domainID,
5369     GCancellable *cancellable,
5370     GError **error)
5371 {
5372   GVariant *_ret;
5373   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5374     "confirmRoutingRundown",
5375     g_variant_new ("(q)",
5376                    arg_domainID),
5377     G_DBUS_CALL_FLAGS_NONE,
5378     -1,
5379     cancellable,
5380     error);
5381   if (_ret == NULL)
5382     goto _out;
5383   g_variant_get (_ret,
5384                  "()");
5385   g_variant_unref (_ret);
5386 _out:
5387   return _ret != NULL;
5388 }
5389
5390 /**
5391  * audiomanager_routinginterface_call_ack_set_volumes:
5392  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5393  * @arg_handle: Argument to pass with the method invocation.
5394  * @arg_listvolumes: Argument to pass with the method invocation.
5395  * @arg_error: Argument to pass with the method invocation.
5396  * @cancellable: (allow-none): A #GCancellable or %NULL.
5397  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5398  * @user_data: User data to pass to @callback.
5399  *
5400  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetVolumes">ackSetVolumes()</link> D-Bus method on @proxy.
5401  * 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.
5402  * You can then call audiomanager_routinginterface_call_ack_set_volumes_finish() to get the result of the operation.
5403  *
5404  * See audiomanager_routinginterface_call_ack_set_volumes_sync() for the synchronous, blocking version of this method.
5405  */
5406 void
5407 audiomanager_routinginterface_call_ack_set_volumes (
5408     AudiomanagerRoutinginterface *proxy,
5409     guint16 arg_handle,
5410     GVariant *arg_listvolumes,
5411     guint16 arg_error,
5412     GCancellable *cancellable,
5413     GAsyncReadyCallback callback,
5414     gpointer user_data)
5415 {
5416   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5417     "ackSetVolumes",
5418     g_variant_new ("(q@a(nqqnq)q)",
5419                    arg_handle,
5420                    arg_listvolumes,
5421                    arg_error),
5422     G_DBUS_CALL_FLAGS_NONE,
5423     -1,
5424     cancellable,
5425     callback,
5426     user_data);
5427 }
5428
5429 /**
5430  * audiomanager_routinginterface_call_ack_set_volumes_finish:
5431  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5432  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_volumes().
5433  * @error: Return location for error or %NULL.
5434  *
5435  * Finishes an operation started with audiomanager_routinginterface_call_ack_set_volumes().
5436  *
5437  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5438  */
5439 gboolean
5440 audiomanager_routinginterface_call_ack_set_volumes_finish (
5441     AudiomanagerRoutinginterface *proxy,
5442     GAsyncResult *res,
5443     GError **error)
5444 {
5445   GVariant *_ret;
5446   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5447   if (_ret == NULL)
5448     goto _out;
5449   g_variant_get (_ret,
5450                  "()");
5451   g_variant_unref (_ret);
5452 _out:
5453   return _ret != NULL;
5454 }
5455
5456 /**
5457  * audiomanager_routinginterface_call_ack_set_volumes_sync:
5458  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5459  * @arg_handle: Argument to pass with the method invocation.
5460  * @arg_listvolumes: Argument to pass with the method invocation.
5461  * @arg_error: Argument to pass with the method invocation.
5462  * @cancellable: (allow-none): A #GCancellable or %NULL.
5463  * @error: Return location for error or %NULL.
5464  *
5465  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetVolumes">ackSetVolumes()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5466  *
5467  * See audiomanager_routinginterface_call_ack_set_volumes() for the asynchronous version of this method.
5468  *
5469  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5470  */
5471 gboolean
5472 audiomanager_routinginterface_call_ack_set_volumes_sync (
5473     AudiomanagerRoutinginterface *proxy,
5474     guint16 arg_handle,
5475     GVariant *arg_listvolumes,
5476     guint16 arg_error,
5477     GCancellable *cancellable,
5478     GError **error)
5479 {
5480   GVariant *_ret;
5481   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5482     "ackSetVolumes",
5483     g_variant_new ("(q@a(nqqnq)q)",
5484                    arg_handle,
5485                    arg_listvolumes,
5486                    arg_error),
5487     G_DBUS_CALL_FLAGS_NONE,
5488     -1,
5489     cancellable,
5490     error);
5491   if (_ret == NULL)
5492     goto _out;
5493   g_variant_get (_ret,
5494                  "()");
5495   g_variant_unref (_ret);
5496 _out:
5497   return _ret != NULL;
5498 }
5499
5500 /**
5501  * audiomanager_routinginterface_call_ack_sink_notification_configuration:
5502  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5503  * @arg_handle: Argument to pass with the method invocation.
5504  * @arg_error: Argument to pass with the method invocation.
5505  * @cancellable: (allow-none): A #GCancellable or %NULL.
5506  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5507  * @user_data: User data to pass to @callback.
5508  *
5509  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSinkNotificationConfiguration">ackSinkNotificationConfiguration()</link> D-Bus method on @proxy.
5510  * 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.
5511  * You can then call audiomanager_routinginterface_call_ack_sink_notification_configuration_finish() to get the result of the operation.
5512  *
5513  * See audiomanager_routinginterface_call_ack_sink_notification_configuration_sync() for the synchronous, blocking version of this method.
5514  */
5515 void
5516 audiomanager_routinginterface_call_ack_sink_notification_configuration (
5517     AudiomanagerRoutinginterface *proxy,
5518     guint16 arg_handle,
5519     guint16 arg_error,
5520     GCancellable *cancellable,
5521     GAsyncReadyCallback callback,
5522     gpointer user_data)
5523 {
5524   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5525     "ackSinkNotificationConfiguration",
5526     g_variant_new ("(qq)",
5527                    arg_handle,
5528                    arg_error),
5529     G_DBUS_CALL_FLAGS_NONE,
5530     -1,
5531     cancellable,
5532     callback,
5533     user_data);
5534 }
5535
5536 /**
5537  * audiomanager_routinginterface_call_ack_sink_notification_configuration_finish:
5538  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5539  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_sink_notification_configuration().
5540  * @error: Return location for error or %NULL.
5541  *
5542  * Finishes an operation started with audiomanager_routinginterface_call_ack_sink_notification_configuration().
5543  *
5544  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5545  */
5546 gboolean
5547 audiomanager_routinginterface_call_ack_sink_notification_configuration_finish (
5548     AudiomanagerRoutinginterface *proxy,
5549     GAsyncResult *res,
5550     GError **error)
5551 {
5552   GVariant *_ret;
5553   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5554   if (_ret == NULL)
5555     goto _out;
5556   g_variant_get (_ret,
5557                  "()");
5558   g_variant_unref (_ret);
5559 _out:
5560   return _ret != NULL;
5561 }
5562
5563 /**
5564  * audiomanager_routinginterface_call_ack_sink_notification_configuration_sync:
5565  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5566  * @arg_handle: Argument to pass with the method invocation.
5567  * @arg_error: Argument to pass with the method invocation.
5568  * @cancellable: (allow-none): A #GCancellable or %NULL.
5569  * @error: Return location for error or %NULL.
5570  *
5571  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSinkNotificationConfiguration">ackSinkNotificationConfiguration()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5572  *
5573  * See audiomanager_routinginterface_call_ack_sink_notification_configuration() for the asynchronous version of this method.
5574  *
5575  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5576  */
5577 gboolean
5578 audiomanager_routinginterface_call_ack_sink_notification_configuration_sync (
5579     AudiomanagerRoutinginterface *proxy,
5580     guint16 arg_handle,
5581     guint16 arg_error,
5582     GCancellable *cancellable,
5583     GError **error)
5584 {
5585   GVariant *_ret;
5586   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5587     "ackSinkNotificationConfiguration",
5588     g_variant_new ("(qq)",
5589                    arg_handle,
5590                    arg_error),
5591     G_DBUS_CALL_FLAGS_NONE,
5592     -1,
5593     cancellable,
5594     error);
5595   if (_ret == NULL)
5596     goto _out;
5597   g_variant_get (_ret,
5598                  "()");
5599   g_variant_unref (_ret);
5600 _out:
5601   return _ret != NULL;
5602 }
5603
5604 /**
5605  * audiomanager_routinginterface_call_ack_source_notification_configuration:
5606  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5607  * @arg_handle: Argument to pass with the method invocation.
5608  * @arg_error: Argument to pass with the method invocation.
5609  * @cancellable: (allow-none): A #GCancellable or %NULL.
5610  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5611  * @user_data: User data to pass to @callback.
5612  *
5613  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSourceNotificationConfiguration">ackSourceNotificationConfiguration()</link> D-Bus method on @proxy.
5614  * 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.
5615  * You can then call audiomanager_routinginterface_call_ack_source_notification_configuration_finish() to get the result of the operation.
5616  *
5617  * See audiomanager_routinginterface_call_ack_source_notification_configuration_sync() for the synchronous, blocking version of this method.
5618  */
5619 void
5620 audiomanager_routinginterface_call_ack_source_notification_configuration (
5621     AudiomanagerRoutinginterface *proxy,
5622     guint16 arg_handle,
5623     guint16 arg_error,
5624     GCancellable *cancellable,
5625     GAsyncReadyCallback callback,
5626     gpointer user_data)
5627 {
5628   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5629     "ackSourceNotificationConfiguration",
5630     g_variant_new ("(qq)",
5631                    arg_handle,
5632                    arg_error),
5633     G_DBUS_CALL_FLAGS_NONE,
5634     -1,
5635     cancellable,
5636     callback,
5637     user_data);
5638 }
5639
5640 /**
5641  * audiomanager_routinginterface_call_ack_source_notification_configuration_finish:
5642  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5643  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_source_notification_configuration().
5644  * @error: Return location for error or %NULL.
5645  *
5646  * Finishes an operation started with audiomanager_routinginterface_call_ack_source_notification_configuration().
5647  *
5648  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5649  */
5650 gboolean
5651 audiomanager_routinginterface_call_ack_source_notification_configuration_finish (
5652     AudiomanagerRoutinginterface *proxy,
5653     GAsyncResult *res,
5654     GError **error)
5655 {
5656   GVariant *_ret;
5657   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5658   if (_ret == NULL)
5659     goto _out;
5660   g_variant_get (_ret,
5661                  "()");
5662   g_variant_unref (_ret);
5663 _out:
5664   return _ret != NULL;
5665 }
5666
5667 /**
5668  * audiomanager_routinginterface_call_ack_source_notification_configuration_sync:
5669  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5670  * @arg_handle: Argument to pass with the method invocation.
5671  * @arg_error: Argument to pass with the method invocation.
5672  * @cancellable: (allow-none): A #GCancellable or %NULL.
5673  * @error: Return location for error or %NULL.
5674  *
5675  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSourceNotificationConfiguration">ackSourceNotificationConfiguration()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5676  *
5677  * See audiomanager_routinginterface_call_ack_source_notification_configuration() for the asynchronous version of this method.
5678  *
5679  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5680  */
5681 gboolean
5682 audiomanager_routinginterface_call_ack_source_notification_configuration_sync (
5683     AudiomanagerRoutinginterface *proxy,
5684     guint16 arg_handle,
5685     guint16 arg_error,
5686     GCancellable *cancellable,
5687     GError **error)
5688 {
5689   GVariant *_ret;
5690   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5691     "ackSourceNotificationConfiguration",
5692     g_variant_new ("(qq)",
5693                    arg_handle,
5694                    arg_error),
5695     G_DBUS_CALL_FLAGS_NONE,
5696     -1,
5697     cancellable,
5698     error);
5699   if (_ret == NULL)
5700     goto _out;
5701   g_variant_get (_ret,
5702                  "()");
5703   g_variant_unref (_ret);
5704 _out:
5705   return _ret != NULL;
5706 }
5707
5708 /**
5709  * audiomanager_routinginterface_call_register_domain:
5710  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5711  * @arg_domaindata: Argument to pass with the method invocation.
5712  * @arg_returnBusname: Argument to pass with the method invocation.
5713  * @arg_returnPath: Argument to pass with the method invocation.
5714  * @arg_returnInterface: Argument to pass with the method invocation.
5715  * @cancellable: (allow-none): A #GCancellable or %NULL.
5716  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5717  * @user_data: User data to pass to @callback.
5718  *
5719  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerDomain">registerDomain()</link> D-Bus method on @proxy.
5720  * 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.
5721  * You can then call audiomanager_routinginterface_call_register_domain_finish() to get the result of the operation.
5722  *
5723  * See audiomanager_routinginterface_call_register_domain_sync() for the synchronous, blocking version of this method.
5724  */
5725 void
5726 audiomanager_routinginterface_call_register_domain (
5727     AudiomanagerRoutinginterface *proxy,
5728     GVariant *arg_domaindata,
5729     const gchar *arg_returnBusname,
5730     const gchar *arg_returnPath,
5731     const gchar *arg_returnInterface,
5732     GCancellable *cancellable,
5733     GAsyncReadyCallback callback,
5734     gpointer user_data)
5735 {
5736   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5737     "registerDomain",
5738     g_variant_new ("(@(qsssbbn)sss)",
5739                    arg_domaindata,
5740                    arg_returnBusname,
5741                    arg_returnPath,
5742                    arg_returnInterface),
5743     G_DBUS_CALL_FLAGS_NONE,
5744     -1,
5745     cancellable,
5746     callback,
5747     user_data);
5748 }
5749
5750 /**
5751  * audiomanager_routinginterface_call_register_domain_finish:
5752  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5753  * @out_domainid: (out): Return location for return parameter or %NULL to ignore.
5754  * @out_error: (out): Return location for return parameter or %NULL to ignore.
5755  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_domain().
5756  * @error: Return location for error or %NULL.
5757  *
5758  * Finishes an operation started with audiomanager_routinginterface_call_register_domain().
5759  *
5760  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5761  */
5762 gboolean
5763 audiomanager_routinginterface_call_register_domain_finish (
5764     AudiomanagerRoutinginterface *proxy,
5765     guint16 *out_domainid,
5766     guint16 *out_error,
5767     GAsyncResult *res,
5768     GError **error)
5769 {
5770   GVariant *_ret;
5771   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5772   if (_ret == NULL)
5773     goto _out;
5774   g_variant_get (_ret,
5775                  "(qq)",
5776                  out_domainid,
5777                  out_error);
5778   g_variant_unref (_ret);
5779 _out:
5780   return _ret != NULL;
5781 }
5782
5783 /**
5784  * audiomanager_routinginterface_call_register_domain_sync:
5785  * @proxy: A #AudiomanagerRoutinginterfaceProxy.
5786  * @arg_domaindata: Argument to pass with the method invocation.
5787  * @arg_returnBusname: Argument to pass with the method invocation.
5788  * @arg_returnPath: Argument to pass with the method invocation.
5789  * @arg_returnInterface: Argument to pass with the method invocation.
5790  * @out_domainid: (out): Return location for return parameter or %NULL to ignore.
5791  * @out_error: (out): Return location for return parameter or %NULL to ignore.
5792  * @cancellable: (allow-none): A #GCancellable or %NULL.
5793  * @error: Return location for error or %NULL.
5794  *
5795  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerDomain">registerDomain()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5796  *
5797  * See audiomanager_routinginterface_call_register_domain() for the asynchronous version of this method.
5798  *
5799  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5800  */
5801 gboolean
5802 audiomanager_routinginterface_call_register_domain_sync (
5803     AudiomanagerRoutinginterface *proxy,
5804     GVariant *arg_domaindata,
5805     const gchar *arg_returnBusname,
5806     const gchar *arg_returnPath,
5807     const gchar *arg_returnInterface,
5808     guint16 *out_domainid,
5809     guint16 *out_error,
5810     GCancellable *cancellable,
5811     GError **error)
5812 {
5813   GVariant *_ret;
5814   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5815     "registerDomain",
5816     g_variant_new ("(@(qsssbbn)sss)",
5817                    arg_domaindata,
5818                    arg_returnBusname,
5819                    arg_returnPath,
5820                    arg_returnInterface),
5821     G_DBUS_CALL_FLAGS_NONE,
5822     -1,
5823     cancellable,
5824     error);
5825   if (_ret == NULL)
5826     goto _out;
5827   g_variant_get (_ret,
5828                  "(qq)",
5829                  out_domainid,
5830                  out_error);
5831   g_variant_unref (_ret);
5832 _out:
5833   return _ret != NULL;
5834 }
5835
5836 /**
5837  * audiomanager_routinginterface_complete_ack_connect:
5838  * @object: A #AudiomanagerRoutinginterface.
5839  * @invocation: (transfer full): A #GDBusMethodInvocation.
5840  *
5841  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackConnect">ackConnect()</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.
5842  *
5843  * This method will free @invocation, you cannot use it afterwards.
5844  */
5845 void
5846 audiomanager_routinginterface_complete_ack_connect (
5847     AudiomanagerRoutinginterface *object,
5848     GDBusMethodInvocation *invocation)
5849 {
5850   g_dbus_method_invocation_return_value (invocation,
5851     g_variant_new ("()"));
5852 }
5853
5854 /**
5855  * audiomanager_routinginterface_complete_ack_disconnect:
5856  * @object: A #AudiomanagerRoutinginterface.
5857  * @invocation: (transfer full): A #GDBusMethodInvocation.
5858  *
5859  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackDisconnect">ackDisconnect()</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.
5860  *
5861  * This method will free @invocation, you cannot use it afterwards.
5862  */
5863 void
5864 audiomanager_routinginterface_complete_ack_disconnect (
5865     AudiomanagerRoutinginterface *object,
5866     GDBusMethodInvocation *invocation)
5867 {
5868   g_dbus_method_invocation_return_value (invocation,
5869     g_variant_new ("()"));
5870 }
5871
5872 /**
5873  * audiomanager_routinginterface_complete_ack_set_source_state:
5874  * @object: A #AudiomanagerRoutinginterface.
5875  * @invocation: (transfer full): A #GDBusMethodInvocation.
5876  *
5877  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSourceState">ackSetSourceState()</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.
5878  *
5879  * This method will free @invocation, you cannot use it afterwards.
5880  */
5881 void
5882 audiomanager_routinginterface_complete_ack_set_source_state (
5883     AudiomanagerRoutinginterface *object,
5884     GDBusMethodInvocation *invocation)
5885 {
5886   g_dbus_method_invocation_return_value (invocation,
5887     g_variant_new ("()"));
5888 }
5889
5890 /**
5891  * audiomanager_routinginterface_complete_ack_set_sink_volume:
5892  * @object: A #AudiomanagerRoutinginterface.
5893  * @invocation: (transfer full): A #GDBusMethodInvocation.
5894  *
5895  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetSinkVolume">ackSetSinkVolume()</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.
5896  *
5897  * This method will free @invocation, you cannot use it afterwards.
5898  */
5899 void
5900 audiomanager_routinginterface_complete_ack_set_sink_volume (
5901     AudiomanagerRoutinginterface *object,
5902     GDBusMethodInvocation *invocation)
5903 {
5904   g_dbus_method_invocation_return_value (invocation,
5905     g_variant_new ("()"));
5906 }
5907
5908 /**
5909  * audiomanager_routinginterface_complete_register_sink:
5910  * @object: A #AudiomanagerRoutinginterface.
5911  * @invocation: (transfer full): A #GDBusMethodInvocation.
5912  * @sinkID: Parameter to return.
5913  * @error: Parameter to return.
5914  *
5915  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSink">registerSink()</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.
5916  *
5917  * This method will free @invocation, you cannot use it afterwards.
5918  */
5919 void
5920 audiomanager_routinginterface_complete_register_sink (
5921     AudiomanagerRoutinginterface *object,
5922     GDBusMethodInvocation *invocation,
5923     guint16 sinkID,
5924     guint16 error)
5925 {
5926   g_dbus_method_invocation_return_value (invocation,
5927     g_variant_new ("(qq)",
5928                    sinkID,
5929                    error));
5930 }
5931
5932 /**
5933  * audiomanager_routinginterface_complete_deregister_sink:
5934  * @object: A #AudiomanagerRoutinginterface.
5935  * @invocation: (transfer full): A #GDBusMethodInvocation.
5936  * @error: Parameter to return.
5937  *
5938  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSink">deregisterSink()</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.
5939  *
5940  * This method will free @invocation, you cannot use it afterwards.
5941  */
5942 void
5943 audiomanager_routinginterface_complete_deregister_sink (
5944     AudiomanagerRoutinginterface *object,
5945     GDBusMethodInvocation *invocation,
5946     gint error)
5947 {
5948   g_dbus_method_invocation_return_value (invocation,
5949     g_variant_new ("(i)",
5950                    error));
5951 }
5952
5953 /**
5954  * audiomanager_routinginterface_complete_register_source:
5955  * @object: A #AudiomanagerRoutinginterface.
5956  * @invocation: (transfer full): A #GDBusMethodInvocation.
5957  * @sourceID: Parameter to return.
5958  * @error: Parameter to return.
5959  *
5960  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerSource">registerSource()</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.
5961  *
5962  * This method will free @invocation, you cannot use it afterwards.
5963  */
5964 void
5965 audiomanager_routinginterface_complete_register_source (
5966     AudiomanagerRoutinginterface *object,
5967     GDBusMethodInvocation *invocation,
5968     guint16 sourceID,
5969     guint16 error)
5970 {
5971   g_dbus_method_invocation_return_value (invocation,
5972     g_variant_new ("(qq)",
5973                    sourceID,
5974                    error));
5975 }
5976
5977 /**
5978  * audiomanager_routinginterface_complete_deregister_source:
5979  * @object: A #AudiomanagerRoutinginterface.
5980  * @invocation: (transfer full): A #GDBusMethodInvocation.
5981  * @error: Parameter to return.
5982  *
5983  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.deregisterSource">deregisterSource()</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.
5984  *
5985  * This method will free @invocation, you cannot use it afterwards.
5986  */
5987 void
5988 audiomanager_routinginterface_complete_deregister_source (
5989     AudiomanagerRoutinginterface *object,
5990     GDBusMethodInvocation *invocation,
5991     guint16 error)
5992 {
5993   g_dbus_method_invocation_return_value (invocation,
5994     g_variant_new ("(q)",
5995                    error));
5996 }
5997
5998 /**
5999  * audiomanager_routinginterface_complete_hook_interrupt_status_change:
6000  * @object: A #AudiomanagerRoutinginterface.
6001  * @invocation: (transfer full): A #GDBusMethodInvocation.
6002  *
6003  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookInterruptStatusChange">hookInterruptStatusChange()</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.
6004  *
6005  * This method will free @invocation, you cannot use it afterwards.
6006  */
6007 void
6008 audiomanager_routinginterface_complete_hook_interrupt_status_change (
6009     AudiomanagerRoutinginterface *object,
6010     GDBusMethodInvocation *invocation)
6011 {
6012   g_dbus_method_invocation_return_value (invocation,
6013     g_variant_new ("()"));
6014 }
6015
6016 /**
6017  * audiomanager_routinginterface_complete_hook_source_availablity_status_change:
6018  * @object: A #AudiomanagerRoutinginterface.
6019  * @invocation: (transfer full): A #GDBusMethodInvocation.
6020  *
6021  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.hookSourceAvailablityStatusChange">hookSourceAvailablityStatusChange()</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.
6022  *
6023  * This method will free @invocation, you cannot use it afterwards.
6024  */
6025 void
6026 audiomanager_routinginterface_complete_hook_source_availablity_status_change (
6027     AudiomanagerRoutinginterface *object,
6028     GDBusMethodInvocation *invocation)
6029 {
6030   g_dbus_method_invocation_return_value (invocation,
6031     g_variant_new ("()"));
6032 }
6033
6034 /**
6035  * audiomanager_routinginterface_complete_confirm_routing_ready:
6036  * @object: A #AudiomanagerRoutinginterface.
6037  * @invocation: (transfer full): A #GDBusMethodInvocation.
6038  *
6039  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingReady">confirmRoutingReady()</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.
6040  *
6041  * This method will free @invocation, you cannot use it afterwards.
6042  */
6043 void
6044 audiomanager_routinginterface_complete_confirm_routing_ready (
6045     AudiomanagerRoutinginterface *object,
6046     GDBusMethodInvocation *invocation)
6047 {
6048   g_dbus_method_invocation_return_value (invocation,
6049     g_variant_new ("()"));
6050 }
6051
6052 /**
6053  * audiomanager_routinginterface_complete_confirm_routing_rundown:
6054  * @object: A #AudiomanagerRoutinginterface.
6055  * @invocation: (transfer full): A #GDBusMethodInvocation.
6056  *
6057  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.confirmRoutingRundown">confirmRoutingRundown()</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.
6058  *
6059  * This method will free @invocation, you cannot use it afterwards.
6060  */
6061 void
6062 audiomanager_routinginterface_complete_confirm_routing_rundown (
6063     AudiomanagerRoutinginterface *object,
6064     GDBusMethodInvocation *invocation)
6065 {
6066   g_dbus_method_invocation_return_value (invocation,
6067     g_variant_new ("()"));
6068 }
6069
6070 /**
6071  * audiomanager_routinginterface_complete_ack_set_volumes:
6072  * @object: A #AudiomanagerRoutinginterface.
6073  * @invocation: (transfer full): A #GDBusMethodInvocation.
6074  *
6075  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSetVolumes">ackSetVolumes()</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.
6076  *
6077  * This method will free @invocation, you cannot use it afterwards.
6078  */
6079 void
6080 audiomanager_routinginterface_complete_ack_set_volumes (
6081     AudiomanagerRoutinginterface *object,
6082     GDBusMethodInvocation *invocation)
6083 {
6084   g_dbus_method_invocation_return_value (invocation,
6085     g_variant_new ("()"));
6086 }
6087
6088 /**
6089  * audiomanager_routinginterface_complete_ack_sink_notification_configuration:
6090  * @object: A #AudiomanagerRoutinginterface.
6091  * @invocation: (transfer full): A #GDBusMethodInvocation.
6092  *
6093  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSinkNotificationConfiguration">ackSinkNotificationConfiguration()</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.
6094  *
6095  * This method will free @invocation, you cannot use it afterwards.
6096  */
6097 void
6098 audiomanager_routinginterface_complete_ack_sink_notification_configuration (
6099     AudiomanagerRoutinginterface *object,
6100     GDBusMethodInvocation *invocation)
6101 {
6102   g_dbus_method_invocation_return_value (invocation,
6103     g_variant_new ("()"));
6104 }
6105
6106 /**
6107  * audiomanager_routinginterface_complete_ack_source_notification_configuration:
6108  * @object: A #AudiomanagerRoutinginterface.
6109  * @invocation: (transfer full): A #GDBusMethodInvocation.
6110  *
6111  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.ackSourceNotificationConfiguration">ackSourceNotificationConfiguration()</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.
6112  *
6113  * This method will free @invocation, you cannot use it afterwards.
6114  */
6115 void
6116 audiomanager_routinginterface_complete_ack_source_notification_configuration (
6117     AudiomanagerRoutinginterface *object,
6118     GDBusMethodInvocation *invocation)
6119 {
6120   g_dbus_method_invocation_return_value (invocation,
6121     g_variant_new ("()"));
6122 }
6123
6124 /**
6125  * audiomanager_routinginterface_complete_register_domain:
6126  * @object: A #AudiomanagerRoutinginterface.
6127  * @invocation: (transfer full): A #GDBusMethodInvocation.
6128  * @domainid: Parameter to return.
6129  * @error: Parameter to return.
6130  *
6131  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routinginterface.registerDomain">registerDomain()</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.
6132  *
6133  * This method will free @invocation, you cannot use it afterwards.
6134  */
6135 void
6136 audiomanager_routinginterface_complete_register_domain (
6137     AudiomanagerRoutinginterface *object,
6138     GDBusMethodInvocation *invocation,
6139     guint16 domainid,
6140     guint16 error)
6141 {
6142   g_dbus_method_invocation_return_value (invocation,
6143     g_variant_new ("(qq)",
6144                    domainid,
6145                    error));
6146 }
6147
6148 /* ------------------------------------------------------------------------ */
6149
6150 /**
6151  * AudiomanagerRoutinginterfaceProxy:
6152  *
6153  * The #AudiomanagerRoutinginterfaceProxy structure contains only private data and should only be accessed using the provided API.
6154  */
6155
6156 /**
6157  * AudiomanagerRoutinginterfaceProxyClass:
6158  * @parent_class: The parent class.
6159  *
6160  * Class structure for #AudiomanagerRoutinginterfaceProxy.
6161  */
6162
6163 struct _AudiomanagerRoutinginterfaceProxyPrivate
6164 {
6165   GData *qdata;
6166 };
6167
6168 static void audiomanager_routinginterface_proxy_iface_init (AudiomanagerRoutinginterfaceIface *iface);
6169
6170 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6171 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceProxy, audiomanager_routinginterface_proxy, G_TYPE_DBUS_PROXY,
6172                          G_ADD_PRIVATE (AudiomanagerRoutinginterfaceProxy)
6173                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_proxy_iface_init));
6174
6175 #else
6176 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceProxy, audiomanager_routinginterface_proxy, G_TYPE_DBUS_PROXY,
6177                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_proxy_iface_init));
6178
6179 #endif
6180 static void
6181 audiomanager_routinginterface_proxy_finalize (GObject *object)
6182 {
6183   AudiomanagerRoutinginterfaceProxy *proxy = AUDIOMANAGER_ROUTINGINTERFACE_PROXY (object);
6184   g_datalist_clear (&proxy->priv->qdata);
6185   G_OBJECT_CLASS (audiomanager_routinginterface_proxy_parent_class)->finalize (object);
6186 }
6187
6188 static void
6189 audiomanager_routinginterface_proxy_get_property (GObject      *object,
6190   guint         prop_id,
6191   GValue       *value,
6192   GParamSpec   *pspec G_GNUC_UNUSED)
6193 {
6194 }
6195
6196 static void
6197 audiomanager_routinginterface_proxy_set_property (GObject      *object,
6198   guint         prop_id,
6199   const GValue *value,
6200   GParamSpec   *pspec G_GNUC_UNUSED)
6201 {
6202 }
6203
6204 static void
6205 audiomanager_routinginterface_proxy_g_signal (GDBusProxy *proxy,
6206   const gchar *sender_name G_GNUC_UNUSED,
6207   const gchar *signal_name,
6208   GVariant *parameters)
6209 {
6210   _ExtendedGDBusSignalInfo *info;
6211   GVariantIter iter;
6212   GVariant *child;
6213   GValue *paramv;
6214   guint num_params;
6215   guint n;
6216   guint signal_id;
6217   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, signal_name);
6218   if (info == NULL)
6219     return;
6220   num_params = g_variant_n_children (parameters);
6221   paramv = g_new0 (GValue, num_params + 1);
6222   g_value_init (&paramv[0], TYPE_AUDIOMANAGER_ROUTINGINTERFACE);
6223   g_value_set_object (&paramv[0], proxy);
6224   g_variant_iter_init (&iter, parameters);
6225   n = 1;
6226   while ((child = g_variant_iter_next_value (&iter)) != NULL)
6227     {
6228       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
6229       if (arg_info->use_gvariant)
6230         {
6231           g_value_init (&paramv[n], G_TYPE_VARIANT);
6232           g_value_set_variant (&paramv[n], child);
6233           n++;
6234         }
6235       else
6236         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
6237       g_variant_unref (child);
6238     }
6239   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTINGINTERFACE);
6240   g_signal_emitv (paramv, signal_id, 0, NULL);
6241   for (n = 0; n < num_params + 1; n++)
6242     g_value_unset (&paramv[n]);
6243   g_free (paramv);
6244 }
6245
6246 static void
6247 audiomanager_routinginterface_proxy_g_properties_changed (GDBusProxy *_proxy,
6248   GVariant *changed_properties,
6249   const gchar *const *invalidated_properties)
6250 {
6251   AudiomanagerRoutinginterfaceProxy *proxy = AUDIOMANAGER_ROUTINGINTERFACE_PROXY (_proxy);
6252   guint n;
6253   const gchar *key;
6254   GVariantIter *iter;
6255   _ExtendedGDBusPropertyInfo *info;
6256   g_variant_get (changed_properties, "a{sv}", &iter);
6257   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
6258     {
6259       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, key);
6260       g_datalist_remove_data (&proxy->priv->qdata, key);
6261       if (info != NULL)
6262         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
6263     }
6264   g_variant_iter_free (iter);
6265   for (n = 0; invalidated_properties[n] != NULL; n++)
6266     {
6267       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, invalidated_properties[n]);
6268       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
6269       if (info != NULL)
6270         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
6271     }
6272 }
6273
6274 static void
6275 audiomanager_routinginterface_proxy_init (AudiomanagerRoutinginterfaceProxy *proxy)
6276 {
6277 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6278   proxy->priv = audiomanager_routinginterface_proxy_get_instance_private (proxy);
6279 #else
6280   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyPrivate);
6281 #endif
6282
6283   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_routinginterface_interface_info ());
6284 }
6285
6286 static void
6287 audiomanager_routinginterface_proxy_class_init (AudiomanagerRoutinginterfaceProxyClass *klass)
6288 {
6289   GObjectClass *gobject_class;
6290   GDBusProxyClass *proxy_class;
6291
6292   gobject_class = G_OBJECT_CLASS (klass);
6293   gobject_class->finalize     = audiomanager_routinginterface_proxy_finalize;
6294   gobject_class->get_property = audiomanager_routinginterface_proxy_get_property;
6295   gobject_class->set_property = audiomanager_routinginterface_proxy_set_property;
6296
6297   proxy_class = G_DBUS_PROXY_CLASS (klass);
6298   proxy_class->g_signal = audiomanager_routinginterface_proxy_g_signal;
6299   proxy_class->g_properties_changed = audiomanager_routinginterface_proxy_g_properties_changed;
6300
6301 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
6302   g_type_class_add_private (klass, sizeof (AudiomanagerRoutinginterfaceProxyPrivate));
6303 #endif
6304 }
6305
6306 static void
6307 audiomanager_routinginterface_proxy_iface_init (AudiomanagerRoutinginterfaceIface *iface)
6308 {
6309 }
6310
6311 /**
6312  * audiomanager_routinginterface_proxy_new:
6313  * @connection: A #GDBusConnection.
6314  * @flags: Flags from the #GDBusProxyFlags enumeration.
6315  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
6316  * @object_path: An object path.
6317  * @cancellable: (allow-none): A #GCancellable or %NULL.
6318  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
6319  * @user_data: User data to pass to @callback.
6320  *
6321  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>. See g_dbus_proxy_new() for more details.
6322  *
6323  * 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.
6324  * You can then call audiomanager_routinginterface_proxy_new_finish() to get the result of the operation.
6325  *
6326  * See audiomanager_routinginterface_proxy_new_sync() for the synchronous, blocking version of this constructor.
6327  */
6328 void
6329 audiomanager_routinginterface_proxy_new (
6330     GDBusConnection     *connection,
6331     GDBusProxyFlags      flags,
6332     const gchar         *name,
6333     const gchar         *object_path,
6334     GCancellable        *cancellable,
6335     GAsyncReadyCallback  callback,
6336     gpointer             user_data)
6337 {
6338   g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_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.genivi.audiomanager.routinginterface", NULL);
6339 }
6340
6341 /**
6342  * audiomanager_routinginterface_proxy_new_finish:
6343  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_proxy_new().
6344  * @error: Return location for error or %NULL
6345  *
6346  * Finishes an operation started with audiomanager_routinginterface_proxy_new().
6347  *
6348  * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set.
6349  */
6350 AudiomanagerRoutinginterface *
6351 audiomanager_routinginterface_proxy_new_finish (
6352     GAsyncResult        *res,
6353     GError             **error)
6354 {
6355   GObject *ret;
6356   GObject *source_object;
6357   source_object = g_async_result_get_source_object (res);
6358   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
6359   g_object_unref (source_object);
6360   if (ret != NULL)
6361     return AUDIOMANAGER_ROUTINGINTERFACE (ret);
6362   else
6363     return NULL;
6364 }
6365
6366 /**
6367  * audiomanager_routinginterface_proxy_new_sync:
6368  * @connection: A #GDBusConnection.
6369  * @flags: Flags from the #GDBusProxyFlags enumeration.
6370  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
6371  * @object_path: An object path.
6372  * @cancellable: (allow-none): A #GCancellable or %NULL.
6373  * @error: Return location for error or %NULL
6374  *
6375  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>. See g_dbus_proxy_new_sync() for more details.
6376  *
6377  * The calling thread is blocked until a reply is received.
6378  *
6379  * See audiomanager_routinginterface_proxy_new() for the asynchronous version of this constructor.
6380  *
6381  * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set.
6382  */
6383 AudiomanagerRoutinginterface *
6384 audiomanager_routinginterface_proxy_new_sync (
6385     GDBusConnection     *connection,
6386     GDBusProxyFlags      flags,
6387     const gchar         *name,
6388     const gchar         *object_path,
6389     GCancellable        *cancellable,
6390     GError             **error)
6391 {
6392   GInitable *ret;
6393   ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL);
6394   if (ret != NULL)
6395     return AUDIOMANAGER_ROUTINGINTERFACE (ret);
6396   else
6397     return NULL;
6398 }
6399
6400
6401 /**
6402  * audiomanager_routinginterface_proxy_new_for_bus:
6403  * @bus_type: A #GBusType.
6404  * @flags: Flags from the #GDBusProxyFlags enumeration.
6405  * @name: A bus name (well-known or unique).
6406  * @object_path: An object path.
6407  * @cancellable: (allow-none): A #GCancellable or %NULL.
6408  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
6409  * @user_data: User data to pass to @callback.
6410  *
6411  * Like audiomanager_routinginterface_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
6412  *
6413  * 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.
6414  * You can then call audiomanager_routinginterface_proxy_new_for_bus_finish() to get the result of the operation.
6415  *
6416  * See audiomanager_routinginterface_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
6417  */
6418 void
6419 audiomanager_routinginterface_proxy_new_for_bus (
6420     GBusType             bus_type,
6421     GDBusProxyFlags      flags,
6422     const gchar         *name,
6423     const gchar         *object_path,
6424     GCancellable        *cancellable,
6425     GAsyncReadyCallback  callback,
6426     gpointer             user_data)
6427 {
6428   g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_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.genivi.audiomanager.routinginterface", NULL);
6429 }
6430
6431 /**
6432  * audiomanager_routinginterface_proxy_new_for_bus_finish:
6433  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_proxy_new_for_bus().
6434  * @error: Return location for error or %NULL
6435  *
6436  * Finishes an operation started with audiomanager_routinginterface_proxy_new_for_bus().
6437  *
6438  * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set.
6439  */
6440 AudiomanagerRoutinginterface *
6441 audiomanager_routinginterface_proxy_new_for_bus_finish (
6442     GAsyncResult        *res,
6443     GError             **error)
6444 {
6445   GObject *ret;
6446   GObject *source_object;
6447   source_object = g_async_result_get_source_object (res);
6448   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
6449   g_object_unref (source_object);
6450   if (ret != NULL)
6451     return AUDIOMANAGER_ROUTINGINTERFACE (ret);
6452   else
6453     return NULL;
6454 }
6455
6456 /**
6457  * audiomanager_routinginterface_proxy_new_for_bus_sync:
6458  * @bus_type: A #GBusType.
6459  * @flags: Flags from the #GDBusProxyFlags enumeration.
6460  * @name: A bus name (well-known or unique).
6461  * @object_path: An object path.
6462  * @cancellable: (allow-none): A #GCancellable or %NULL.
6463  * @error: Return location for error or %NULL
6464  *
6465  * Like audiomanager_routinginterface_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
6466  *
6467  * The calling thread is blocked until a reply is received.
6468  *
6469  * See audiomanager_routinginterface_proxy_new_for_bus() for the asynchronous version of this constructor.
6470  *
6471  * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set.
6472  */
6473 AudiomanagerRoutinginterface *
6474 audiomanager_routinginterface_proxy_new_for_bus_sync (
6475     GBusType             bus_type,
6476     GDBusProxyFlags      flags,
6477     const gchar         *name,
6478     const gchar         *object_path,
6479     GCancellable        *cancellable,
6480     GError             **error)
6481 {
6482   GInitable *ret;
6483   ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL);
6484   if (ret != NULL)
6485     return AUDIOMANAGER_ROUTINGINTERFACE (ret);
6486   else
6487     return NULL;
6488 }
6489
6490
6491 /* ------------------------------------------------------------------------ */
6492
6493 /**
6494  * AudiomanagerRoutinginterfaceSkeleton:
6495  *
6496  * The #AudiomanagerRoutinginterfaceSkeleton structure contains only private data and should only be accessed using the provided API.
6497  */
6498
6499 /**
6500  * AudiomanagerRoutinginterfaceSkeletonClass:
6501  * @parent_class: The parent class.
6502  *
6503  * Class structure for #AudiomanagerRoutinginterfaceSkeleton.
6504  */
6505
6506 struct _AudiomanagerRoutinginterfaceSkeletonPrivate
6507 {
6508   GValue *properties;
6509   GList *changed_properties;
6510   GSource *changed_properties_idle_source;
6511   GMainContext *context;
6512   GMutex lock;
6513 };
6514
6515 static void
6516 _audiomanager_routinginterface_skeleton_handle_method_call (
6517   GDBusConnection *connection G_GNUC_UNUSED,
6518   const gchar *sender G_GNUC_UNUSED,
6519   const gchar *object_path G_GNUC_UNUSED,
6520   const gchar *interface_name,
6521   const gchar *method_name,
6522   GVariant *parameters,
6523   GDBusMethodInvocation *invocation,
6524   gpointer user_data)
6525 {
6526   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data);
6527   _ExtendedGDBusMethodInfo *info;
6528   GVariantIter iter;
6529   GVariant *child;
6530   GValue *paramv;
6531   guint num_params;
6532   guint num_extra;
6533   guint n;
6534   guint signal_id;
6535   GValue return_value = G_VALUE_INIT;
6536   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
6537   g_assert (info != NULL);
6538   num_params = g_variant_n_children (parameters);
6539   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
6540   n = 0;
6541   g_value_init (&paramv[n], TYPE_AUDIOMANAGER_ROUTINGINTERFACE);
6542   g_value_set_object (&paramv[n++], skeleton);
6543   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
6544   g_value_set_object (&paramv[n++], invocation);
6545   if (info->pass_fdlist)
6546     {
6547 #ifdef G_OS_UNIX
6548       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
6549       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
6550 #else
6551       g_assert_not_reached ();
6552 #endif
6553     }
6554   g_variant_iter_init (&iter, parameters);
6555   while ((child = g_variant_iter_next_value (&iter)) != NULL)
6556     {
6557       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
6558       if (arg_info->use_gvariant)
6559         {
6560           g_value_init (&paramv[n], G_TYPE_VARIANT);
6561           g_value_set_variant (&paramv[n], child);
6562           n++;
6563         }
6564       else
6565         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
6566       g_variant_unref (child);
6567     }
6568   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTINGINTERFACE);
6569   g_value_init (&return_value, G_TYPE_BOOLEAN);
6570   g_signal_emitv (paramv, signal_id, 0, &return_value);
6571   if (!g_value_get_boolean (&return_value))
6572     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);
6573   g_value_unset (&return_value);
6574   for (n = 0; n < num_params + num_extra; n++)
6575     g_value_unset (&paramv[n]);
6576   g_free (paramv);
6577 }
6578
6579 static GVariant *
6580 _audiomanager_routinginterface_skeleton_handle_get_property (
6581   GDBusConnection *connection G_GNUC_UNUSED,
6582   const gchar *sender G_GNUC_UNUSED,
6583   const gchar *object_path G_GNUC_UNUSED,
6584   const gchar *interface_name G_GNUC_UNUSED,
6585   const gchar *property_name,
6586   GError **error,
6587   gpointer user_data)
6588 {
6589   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data);
6590   GValue value = G_VALUE_INIT;
6591   GParamSpec *pspec;
6592   _ExtendedGDBusPropertyInfo *info;
6593   GVariant *ret;
6594   ret = NULL;
6595   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, property_name);
6596   g_assert (info != NULL);
6597   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
6598   if (pspec == NULL)
6599     {
6600       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
6601     }
6602   else
6603     {
6604       g_value_init (&value, pspec->value_type);
6605       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
6606       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
6607       g_value_unset (&value);
6608     }
6609   return ret;
6610 }
6611
6612 static gboolean
6613 _audiomanager_routinginterface_skeleton_handle_set_property (
6614   GDBusConnection *connection G_GNUC_UNUSED,
6615   const gchar *sender G_GNUC_UNUSED,
6616   const gchar *object_path G_GNUC_UNUSED,
6617   const gchar *interface_name G_GNUC_UNUSED,
6618   const gchar *property_name,
6619   GVariant *variant,
6620   GError **error,
6621   gpointer user_data)
6622 {
6623   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data);
6624   GValue value = G_VALUE_INIT;
6625   GParamSpec *pspec;
6626   _ExtendedGDBusPropertyInfo *info;
6627   gboolean ret;
6628   ret = FALSE;
6629   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, property_name);
6630   g_assert (info != NULL);
6631   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
6632   if (pspec == NULL)
6633     {
6634       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
6635     }
6636   else
6637     {
6638       if (info->use_gvariant)
6639         g_value_set_variant (&value, variant);
6640       else
6641         g_dbus_gvariant_to_gvalue (variant, &value);
6642       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
6643       g_value_unset (&value);
6644       ret = TRUE;
6645     }
6646   return ret;
6647 }
6648
6649 static const GDBusInterfaceVTable _audiomanager_routinginterface_skeleton_vtable =
6650 {
6651   _audiomanager_routinginterface_skeleton_handle_method_call,
6652   _audiomanager_routinginterface_skeleton_handle_get_property,
6653   _audiomanager_routinginterface_skeleton_handle_set_property,
6654   {NULL}
6655 };
6656
6657 static GDBusInterfaceInfo *
6658 audiomanager_routinginterface_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
6659 {
6660   return audiomanager_routinginterface_interface_info ();
6661 }
6662
6663 static GDBusInterfaceVTable *
6664 audiomanager_routinginterface_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
6665 {
6666   return (GDBusInterfaceVTable *) &_audiomanager_routinginterface_skeleton_vtable;
6667 }
6668
6669 static GVariant *
6670 audiomanager_routinginterface_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
6671 {
6672   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (_skeleton);
6673
6674   GVariantBuilder builder;
6675   guint n;
6676   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
6677   if (_audiomanager_routinginterface_interface_info.parent_struct.properties == NULL)
6678     goto out;
6679   for (n = 0; _audiomanager_routinginterface_interface_info.parent_struct.properties[n] != NULL; n++)
6680     {
6681       GDBusPropertyInfo *info = _audiomanager_routinginterface_interface_info.parent_struct.properties[n];
6682       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
6683         {
6684           GVariant *value;
6685           value = _audiomanager_routinginterface_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.genivi.audiomanager.routinginterface", info->name, NULL, skeleton);
6686           if (value != NULL)
6687             {
6688               g_variant_take_ref (value);
6689               g_variant_builder_add (&builder, "{sv}", info->name, value);
6690               g_variant_unref (value);
6691             }
6692         }
6693     }
6694 out:
6695   return g_variant_builder_end (&builder);
6696 }
6697
6698 static void
6699 audiomanager_routinginterface_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
6700 {
6701 }
6702
6703 static void
6704 _audiomanager_routinginterface_on_signal_set_routing_ready (
6705     AudiomanagerRoutinginterface *object)
6706 {
6707   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object);
6708
6709   GList      *connections, *l;
6710   GVariant   *signal_variant;
6711   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
6712
6713   signal_variant = g_variant_ref_sink (g_variant_new ("()"));
6714   for (l = connections; l != NULL; l = l->next)
6715     {
6716       GDBusConnection *connection = l->data;
6717       g_dbus_connection_emit_signal (connection,
6718         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routinginterface", "setRoutingReady",
6719         signal_variant, NULL);
6720     }
6721   g_variant_unref (signal_variant);
6722   g_list_free_full (connections, g_object_unref);
6723 }
6724
6725 static void
6726 _audiomanager_routinginterface_on_signal_set_routing_rundown (
6727     AudiomanagerRoutinginterface *object)
6728 {
6729   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object);
6730
6731   GList      *connections, *l;
6732   GVariant   *signal_variant;
6733   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
6734
6735   signal_variant = g_variant_ref_sink (g_variant_new ("()"));
6736   for (l = connections; l != NULL; l = l->next)
6737     {
6738       GDBusConnection *connection = l->data;
6739       g_dbus_connection_emit_signal (connection,
6740         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routinginterface", "setRoutingRundown",
6741         signal_variant, NULL);
6742     }
6743   g_variant_unref (signal_variant);
6744   g_list_free_full (connections, g_object_unref);
6745 }
6746
6747 static void audiomanager_routinginterface_skeleton_iface_init (AudiomanagerRoutinginterfaceIface *iface);
6748 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6749 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceSkeleton, audiomanager_routinginterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
6750                          G_ADD_PRIVATE (AudiomanagerRoutinginterfaceSkeleton)
6751                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_skeleton_iface_init));
6752
6753 #else
6754 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceSkeleton, audiomanager_routinginterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
6755                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_skeleton_iface_init));
6756
6757 #endif
6758 static void
6759 audiomanager_routinginterface_skeleton_finalize (GObject *object)
6760 {
6761   AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object);
6762   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
6763   if (skeleton->priv->changed_properties_idle_source != NULL)
6764     g_source_destroy (skeleton->priv->changed_properties_idle_source);
6765   g_main_context_unref (skeleton->priv->context);
6766   g_mutex_clear (&skeleton->priv->lock);
6767   G_OBJECT_CLASS (audiomanager_routinginterface_skeleton_parent_class)->finalize (object);
6768 }
6769
6770 static void
6771 audiomanager_routinginterface_skeleton_init (AudiomanagerRoutinginterfaceSkeleton *skeleton)
6772 {
6773 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6774   skeleton->priv = audiomanager_routinginterface_skeleton_get_instance_private (skeleton);
6775 #else
6776   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonPrivate);
6777 #endif
6778
6779   g_mutex_init (&skeleton->priv->lock);
6780   skeleton->priv->context = g_main_context_ref_thread_default ();
6781 }
6782
6783 static void
6784 audiomanager_routinginterface_skeleton_class_init (AudiomanagerRoutinginterfaceSkeletonClass *klass)
6785 {
6786   GObjectClass *gobject_class;
6787   GDBusInterfaceSkeletonClass *skeleton_class;
6788
6789   gobject_class = G_OBJECT_CLASS (klass);
6790   gobject_class->finalize = audiomanager_routinginterface_skeleton_finalize;
6791
6792   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
6793   skeleton_class->get_info = audiomanager_routinginterface_skeleton_dbus_interface_get_info;
6794   skeleton_class->get_properties = audiomanager_routinginterface_skeleton_dbus_interface_get_properties;
6795   skeleton_class->flush = audiomanager_routinginterface_skeleton_dbus_interface_flush;
6796   skeleton_class->get_vtable = audiomanager_routinginterface_skeleton_dbus_interface_get_vtable;
6797
6798 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
6799   g_type_class_add_private (klass, sizeof (AudiomanagerRoutinginterfaceSkeletonPrivate));
6800 #endif
6801 }
6802
6803 static void
6804 audiomanager_routinginterface_skeleton_iface_init (AudiomanagerRoutinginterfaceIface *iface)
6805 {
6806   iface->set_routing_ready = _audiomanager_routinginterface_on_signal_set_routing_ready;
6807   iface->set_routing_rundown = _audiomanager_routinginterface_on_signal_set_routing_rundown;
6808 }
6809
6810 /**
6811  * audiomanager_routinginterface_skeleton_new:
6812  *
6813  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>.
6814  *
6815  * Returns: (transfer full) (type AudiomanagerRoutinginterfaceSkeleton): The skeleton object.
6816  */
6817 AudiomanagerRoutinginterface *
6818 audiomanager_routinginterface_skeleton_new (void)
6819 {
6820   return AUDIOMANAGER_ROUTINGINTERFACE (g_object_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, NULL));
6821 }
6822
6823 /* ------------------------------------------------------------------------
6824  * Code for interface org.genivi.audiomanager.routing.soundmanager
6825  * ------------------------------------------------------------------------
6826  */
6827
6828 /**
6829  * SECTION:AudiomanagerRoutingSoundmanager
6830  * @title: AudiomanagerRoutingSoundmanager
6831  * @short_description: Generated C code for the org.genivi.audiomanager.routing.soundmanager D-Bus interface
6832  *
6833  * This section contains code for working with the <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link> D-Bus interface in C.
6834  */
6835
6836 /* ---- Introspection data for org.genivi.audiomanager.routing.soundmanager ---- */
6837
6838 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_handle =
6839 {
6840   {
6841     -1,
6842     (gchar *) "handle",
6843     (gchar *) "q",
6844     NULL
6845   },
6846   FALSE
6847 };
6848
6849 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_pointers[] =
6850 {
6851   &_audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_handle,
6852   NULL
6853 };
6854
6855 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_error =
6856 {
6857   {
6858     -1,
6859     (gchar *) "error",
6860     (gchar *) "n",
6861     NULL
6862   },
6863   FALSE
6864 };
6865
6866 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_pointers[] =
6867 {
6868   &_audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_error,
6869   NULL
6870 };
6871
6872 static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_abort =
6873 {
6874   {
6875     -1,
6876     (gchar *) "asyncAbort",
6877     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_pointers,
6878     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_pointers,
6879     NULL
6880   },
6881   "handle-async-abort",
6882   FALSE
6883 };
6884
6885 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_handle =
6886 {
6887   {
6888     -1,
6889     (gchar *) "handle",
6890     (gchar *) "q",
6891     NULL
6892   },
6893   FALSE
6894 };
6895
6896 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionID =
6897 {
6898   {
6899     -1,
6900     (gchar *) "connectionID",
6901     (gchar *) "q",
6902     NULL
6903   },
6904   FALSE
6905 };
6906
6907 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sourceID =
6908 {
6909   {
6910     -1,
6911     (gchar *) "sourceID",
6912     (gchar *) "q",
6913     NULL
6914   },
6915   FALSE
6916 };
6917
6918 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sinkID =
6919 {
6920   {
6921     -1,
6922     (gchar *) "sinkID",
6923     (gchar *) "q",
6924     NULL
6925   },
6926   FALSE
6927 };
6928
6929 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionFormat =
6930 {
6931   {
6932     -1,
6933     (gchar *) "connectionFormat",
6934     (gchar *) "i",
6935     NULL
6936   },
6937   FALSE
6938 };
6939
6940 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_pointers[] =
6941 {
6942   &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_handle,
6943   &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionID,
6944   &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sourceID,
6945   &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sinkID,
6946   &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionFormat,
6947   NULL
6948 };
6949
6950 static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_connect =
6951 {
6952   {
6953     -1,
6954     (gchar *) "asyncConnect",
6955     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_pointers,
6956     NULL,
6957     NULL
6958   },
6959   "handle-async-connect",
6960   FALSE
6961 };
6962
6963 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_handle =
6964 {
6965   {
6966     -1,
6967     (gchar *) "handle",
6968     (gchar *) "q",
6969     NULL
6970   },
6971   FALSE
6972 };
6973
6974 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_connectionID =
6975 {
6976   {
6977     -1,
6978     (gchar *) "connectionID",
6979     (gchar *) "q",
6980     NULL
6981   },
6982   FALSE
6983 };
6984
6985 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_pointers[] =
6986 {
6987   &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_handle,
6988   &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_connectionID,
6989   NULL
6990 };
6991
6992 static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_disconnect =
6993 {
6994   {
6995     -1,
6996     (gchar *) "asyncDisconnect",
6997     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_pointers,
6998     NULL,
6999     NULL
7000   },
7001   "handle-async-disconnect",
7002   FALSE
7003 };
7004
7005 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_handle =
7006 {
7007   {
7008     -1,
7009     (gchar *) "handle",
7010     (gchar *) "q",
7011     NULL
7012   },
7013   FALSE
7014 };
7015
7016 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_sinkID =
7017 {
7018   {
7019     -1,
7020     (gchar *) "sinkID",
7021     (gchar *) "q",
7022     NULL
7023   },
7024   FALSE
7025 };
7026
7027 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_volume =
7028 {
7029   {
7030     -1,
7031     (gchar *) "volume",
7032     (gchar *) "n",
7033     NULL
7034   },
7035   FALSE
7036 };
7037
7038 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_ramp =
7039 {
7040   {
7041     -1,
7042     (gchar *) "ramp",
7043     (gchar *) "n",
7044     NULL
7045   },
7046   FALSE
7047 };
7048
7049 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_time =
7050 {
7051   {
7052     -1,
7053     (gchar *) "time",
7054     (gchar *) "q",
7055     NULL
7056   },
7057   FALSE
7058 };
7059
7060 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_pointers[] =
7061 {
7062   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_handle,
7063   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_sinkID,
7064   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_volume,
7065   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_ramp,
7066   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_time,
7067   NULL
7068 };
7069
7070 static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume =
7071 {
7072   {
7073     -1,
7074     (gchar *) "asyncSetSinkVolume",
7075     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_pointers,
7076     NULL,
7077     NULL
7078   },
7079   "handle-async-set-sink-volume",
7080   FALSE
7081 };
7082
7083 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_handle =
7084 {
7085   {
7086     -1,
7087     (gchar *) "handle",
7088     (gchar *) "q",
7089     NULL
7090   },
7091   FALSE
7092 };
7093
7094 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceID =
7095 {
7096   {
7097     -1,
7098     (gchar *) "sourceID",
7099     (gchar *) "q",
7100     NULL
7101   },
7102   FALSE
7103 };
7104
7105 static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceState =
7106 {
7107   {
7108     -1,
7109     (gchar *) "sourceState",
7110     (gchar *) "i",
7111     NULL
7112   },
7113   FALSE
7114 };
7115
7116 static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_pointers[] =
7117 {
7118   &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_handle,
7119   &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceID,
7120   &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceState,
7121   NULL
7122 };
7123
7124 static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state =
7125 {
7126   {
7127     -1,
7128     (gchar *) "asyncSetSourceState",
7129     (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_pointers,
7130     NULL,
7131     NULL
7132   },
7133   "handle-async-set-source-state",
7134   FALSE
7135 };
7136
7137 static const _ExtendedGDBusMethodInfo * const _audiomanager_routing_soundmanager_method_info_pointers[] =
7138 {
7139   &_audiomanager_routing_soundmanager_method_info_async_abort,
7140   &_audiomanager_routing_soundmanager_method_info_async_connect,
7141   &_audiomanager_routing_soundmanager_method_info_async_disconnect,
7142   &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume,
7143   &_audiomanager_routing_soundmanager_method_info_async_set_source_state,
7144   NULL
7145 };
7146
7147 static const _ExtendedGDBusInterfaceInfo _audiomanager_routing_soundmanager_interface_info =
7148 {
7149   {
7150     -1,
7151     (gchar *) "org.genivi.audiomanager.routing.soundmanager",
7152     (GDBusMethodInfo **) &_audiomanager_routing_soundmanager_method_info_pointers,
7153     NULL,
7154     NULL,
7155     NULL
7156   },
7157   "audiomanager-routing-soundmanager",
7158 };
7159
7160
7161 /**
7162  * audiomanager_routing_soundmanager_interface_info:
7163  *
7164  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link> D-Bus interface.
7165  *
7166  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
7167  */
7168 GDBusInterfaceInfo *
7169 audiomanager_routing_soundmanager_interface_info (void)
7170 {
7171   return (GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct;
7172 }
7173
7174 /**
7175  * audiomanager_routing_soundmanager_override_properties:
7176  * @klass: The class structure for a #GObject<!-- -->-derived class.
7177  * @property_id_begin: The property id to assign to the first overridden property.
7178  *
7179  * Overrides all #GObject properties in the #AudiomanagerRoutingSoundmanager interface for a concrete class.
7180  * The properties are overridden in the order they are defined.
7181  *
7182  * Returns: The last property id.
7183  */
7184 guint
7185 audiomanager_routing_soundmanager_override_properties (GObjectClass *klass, guint property_id_begin)
7186 {
7187   return property_id_begin - 1;
7188 }
7189
7190
7191
7192 /**
7193  * AudiomanagerRoutingSoundmanager:
7194  *
7195  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>.
7196  */
7197
7198 /**
7199  * AudiomanagerRoutingSoundmanagerIface:
7200  * @parent_iface: The parent interface.
7201  * @handle_async_abort: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-abort signal.
7202  * @handle_async_connect: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-connect signal.
7203  * @handle_async_disconnect: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-disconnect signal.
7204  * @handle_async_set_sink_volume: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-set-sink-volume signal.
7205  * @handle_async_set_source_state: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-set-source-state signal.
7206  *
7207  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>.
7208  */
7209
7210 typedef AudiomanagerRoutingSoundmanagerIface AudiomanagerRoutingSoundmanagerInterface;
7211 G_DEFINE_INTERFACE (AudiomanagerRoutingSoundmanager, audiomanager_routing_soundmanager, G_TYPE_OBJECT);
7212
7213 static void
7214 audiomanager_routing_soundmanager_default_init (AudiomanagerRoutingSoundmanagerIface *iface)
7215 {
7216   /* GObject signals for incoming D-Bus method calls: */
7217   /**
7218    * AudiomanagerRoutingSoundmanager::handle-async-abort:
7219    * @object: A #AudiomanagerRoutingSoundmanager.
7220    * @invocation: A #GDBusMethodInvocation.
7221    * @arg_handle: Argument passed by remote caller.
7222    *
7223    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncAbort">asyncAbort()</link> D-Bus method.
7224    *
7225    * 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 audiomanager_routing_soundmanager_complete_async_abort() 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.
7226    *
7227    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
7228    */
7229   g_signal_new ("handle-async-abort",
7230     G_TYPE_FROM_INTERFACE (iface),
7231     G_SIGNAL_RUN_LAST,
7232     G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_abort),
7233     g_signal_accumulator_true_handled,
7234     NULL,
7235     g_cclosure_marshal_generic,
7236     G_TYPE_BOOLEAN,
7237     2,
7238     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
7239
7240   /**
7241    * AudiomanagerRoutingSoundmanager::handle-async-connect:
7242    * @object: A #AudiomanagerRoutingSoundmanager.
7243    * @invocation: A #GDBusMethodInvocation.
7244    * @arg_handle: Argument passed by remote caller.
7245    * @arg_connectionID: Argument passed by remote caller.
7246    * @arg_sourceID: Argument passed by remote caller.
7247    * @arg_sinkID: Argument passed by remote caller.
7248    * @arg_connectionFormat: Argument passed by remote caller.
7249    *
7250    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncConnect">asyncConnect()</link> D-Bus method.
7251    *
7252    * 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 audiomanager_routing_soundmanager_complete_async_connect() 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.
7253    *
7254    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
7255    */
7256   g_signal_new ("handle-async-connect",
7257     G_TYPE_FROM_INTERFACE (iface),
7258     G_SIGNAL_RUN_LAST,
7259     G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_connect),
7260     g_signal_accumulator_true_handled,
7261     NULL,
7262     g_cclosure_marshal_generic,
7263     G_TYPE_BOOLEAN,
7264     6,
7265     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT);
7266
7267   /**
7268    * AudiomanagerRoutingSoundmanager::handle-async-disconnect:
7269    * @object: A #AudiomanagerRoutingSoundmanager.
7270    * @invocation: A #GDBusMethodInvocation.
7271    * @arg_handle: Argument passed by remote caller.
7272    * @arg_connectionID: Argument passed by remote caller.
7273    *
7274    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncDisconnect">asyncDisconnect()</link> D-Bus method.
7275    *
7276    * 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 audiomanager_routing_soundmanager_complete_async_disconnect() 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.
7277    *
7278    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
7279    */
7280   g_signal_new ("handle-async-disconnect",
7281     G_TYPE_FROM_INTERFACE (iface),
7282     G_SIGNAL_RUN_LAST,
7283     G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_disconnect),
7284     g_signal_accumulator_true_handled,
7285     NULL,
7286     g_cclosure_marshal_generic,
7287     G_TYPE_BOOLEAN,
7288     3,
7289     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
7290
7291   /**
7292    * AudiomanagerRoutingSoundmanager::handle-async-set-sink-volume:
7293    * @object: A #AudiomanagerRoutingSoundmanager.
7294    * @invocation: A #GDBusMethodInvocation.
7295    * @arg_handle: Argument passed by remote caller.
7296    * @arg_sinkID: Argument passed by remote caller.
7297    * @arg_volume: Argument passed by remote caller.
7298    * @arg_ramp: Argument passed by remote caller.
7299    * @arg_time: Argument passed by remote caller.
7300    *
7301    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSinkVolume">asyncSetSinkVolume()</link> D-Bus method.
7302    *
7303    * 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 audiomanager_routing_soundmanager_complete_async_set_sink_volume() 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.
7304    *
7305    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
7306    */
7307   g_signal_new ("handle-async-set-sink-volume",
7308     G_TYPE_FROM_INTERFACE (iface),
7309     G_SIGNAL_RUN_LAST,
7310     G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_set_sink_volume),
7311     g_signal_accumulator_true_handled,
7312     NULL,
7313     g_cclosure_marshal_generic,
7314     G_TYPE_BOOLEAN,
7315     6,
7316     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT, G_TYPE_INT, G_TYPE_UINT);
7317
7318   /**
7319    * AudiomanagerRoutingSoundmanager::handle-async-set-source-state:
7320    * @object: A #AudiomanagerRoutingSoundmanager.
7321    * @invocation: A #GDBusMethodInvocation.
7322    * @arg_handle: Argument passed by remote caller.
7323    * @arg_sourceID: Argument passed by remote caller.
7324    * @arg_sourceState: Argument passed by remote caller.
7325    *
7326    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSourceState">asyncSetSourceState()</link> D-Bus method.
7327    *
7328    * 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 audiomanager_routing_soundmanager_complete_async_set_source_state() 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.
7329    *
7330    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
7331    */
7332   g_signal_new ("handle-async-set-source-state",
7333     G_TYPE_FROM_INTERFACE (iface),
7334     G_SIGNAL_RUN_LAST,
7335     G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_set_source_state),
7336     g_signal_accumulator_true_handled,
7337     NULL,
7338     g_cclosure_marshal_generic,
7339     G_TYPE_BOOLEAN,
7340     4,
7341     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT);
7342
7343 }
7344
7345 /**
7346  * audiomanager_routing_soundmanager_call_async_abort:
7347  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7348  * @arg_handle: Argument to pass with the method invocation.
7349  * @cancellable: (allow-none): A #GCancellable or %NULL.
7350  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
7351  * @user_data: User data to pass to @callback.
7352  *
7353  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncAbort">asyncAbort()</link> D-Bus method on @proxy.
7354  * 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.
7355  * You can then call audiomanager_routing_soundmanager_call_async_abort_finish() to get the result of the operation.
7356  *
7357  * See audiomanager_routing_soundmanager_call_async_abort_sync() for the synchronous, blocking version of this method.
7358  */
7359 void
7360 audiomanager_routing_soundmanager_call_async_abort (
7361     AudiomanagerRoutingSoundmanager *proxy,
7362     guint16 arg_handle,
7363     GCancellable *cancellable,
7364     GAsyncReadyCallback callback,
7365     gpointer user_data)
7366 {
7367   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
7368     "asyncAbort",
7369     g_variant_new ("(q)",
7370                    arg_handle),
7371     G_DBUS_CALL_FLAGS_NONE,
7372     -1,
7373     cancellable,
7374     callback,
7375     user_data);
7376 }
7377
7378 /**
7379  * audiomanager_routing_soundmanager_call_async_abort_finish:
7380  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7381  * @out_error: (out): Return location for return parameter or %NULL to ignore.
7382  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_abort().
7383  * @error: Return location for error or %NULL.
7384  *
7385  * Finishes an operation started with audiomanager_routing_soundmanager_call_async_abort().
7386  *
7387  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7388  */
7389 gboolean
7390 audiomanager_routing_soundmanager_call_async_abort_finish (
7391     AudiomanagerRoutingSoundmanager *proxy,
7392     gint16 *out_error,
7393     GAsyncResult *res,
7394     GError **error)
7395 {
7396   GVariant *_ret;
7397   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
7398   if (_ret == NULL)
7399     goto _out;
7400   g_variant_get (_ret,
7401                  "(n)",
7402                  out_error);
7403   g_variant_unref (_ret);
7404 _out:
7405   return _ret != NULL;
7406 }
7407
7408 /**
7409  * audiomanager_routing_soundmanager_call_async_abort_sync:
7410  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7411  * @arg_handle: Argument to pass with the method invocation.
7412  * @out_error: (out): Return location for return parameter or %NULL to ignore.
7413  * @cancellable: (allow-none): A #GCancellable or %NULL.
7414  * @error: Return location for error or %NULL.
7415  *
7416  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncAbort">asyncAbort()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
7417  *
7418  * See audiomanager_routing_soundmanager_call_async_abort() for the asynchronous version of this method.
7419  *
7420  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7421  */
7422 gboolean
7423 audiomanager_routing_soundmanager_call_async_abort_sync (
7424     AudiomanagerRoutingSoundmanager *proxy,
7425     guint16 arg_handle,
7426     gint16 *out_error,
7427     GCancellable *cancellable,
7428     GError **error)
7429 {
7430   GVariant *_ret;
7431   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
7432     "asyncAbort",
7433     g_variant_new ("(q)",
7434                    arg_handle),
7435     G_DBUS_CALL_FLAGS_NONE,
7436     -1,
7437     cancellable,
7438     error);
7439   if (_ret == NULL)
7440     goto _out;
7441   g_variant_get (_ret,
7442                  "(n)",
7443                  out_error);
7444   g_variant_unref (_ret);
7445 _out:
7446   return _ret != NULL;
7447 }
7448
7449 /**
7450  * audiomanager_routing_soundmanager_call_async_connect:
7451  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7452  * @arg_handle: Argument to pass with the method invocation.
7453  * @arg_connectionID: Argument to pass with the method invocation.
7454  * @arg_sourceID: Argument to pass with the method invocation.
7455  * @arg_sinkID: Argument to pass with the method invocation.
7456  * @arg_connectionFormat: Argument to pass with the method invocation.
7457  * @cancellable: (allow-none): A #GCancellable or %NULL.
7458  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
7459  * @user_data: User data to pass to @callback.
7460  *
7461  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncConnect">asyncConnect()</link> D-Bus method on @proxy.
7462  * 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.
7463  * You can then call audiomanager_routing_soundmanager_call_async_connect_finish() to get the result of the operation.
7464  *
7465  * See audiomanager_routing_soundmanager_call_async_connect_sync() for the synchronous, blocking version of this method.
7466  */
7467 void
7468 audiomanager_routing_soundmanager_call_async_connect (
7469     AudiomanagerRoutingSoundmanager *proxy,
7470     guint16 arg_handle,
7471     guint16 arg_connectionID,
7472     guint16 arg_sourceID,
7473     guint16 arg_sinkID,
7474     gint arg_connectionFormat,
7475     GCancellable *cancellable,
7476     GAsyncReadyCallback callback,
7477     gpointer user_data)
7478 {
7479   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
7480     "asyncConnect",
7481     g_variant_new ("(qqqqi)",
7482                    arg_handle,
7483                    arg_connectionID,
7484                    arg_sourceID,
7485                    arg_sinkID,
7486                    arg_connectionFormat),
7487     G_DBUS_CALL_FLAGS_NONE,
7488     -1,
7489     cancellable,
7490     callback,
7491     user_data);
7492 }
7493
7494 /**
7495  * audiomanager_routing_soundmanager_call_async_connect_finish:
7496  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7497  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_connect().
7498  * @error: Return location for error or %NULL.
7499  *
7500  * Finishes an operation started with audiomanager_routing_soundmanager_call_async_connect().
7501  *
7502  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7503  */
7504 gboolean
7505 audiomanager_routing_soundmanager_call_async_connect_finish (
7506     AudiomanagerRoutingSoundmanager *proxy,
7507     GAsyncResult *res,
7508     GError **error)
7509 {
7510   GVariant *_ret;
7511   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
7512   if (_ret == NULL)
7513     goto _out;
7514   g_variant_get (_ret,
7515                  "()");
7516   g_variant_unref (_ret);
7517 _out:
7518   return _ret != NULL;
7519 }
7520
7521 /**
7522  * audiomanager_routing_soundmanager_call_async_connect_sync:
7523  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7524  * @arg_handle: Argument to pass with the method invocation.
7525  * @arg_connectionID: Argument to pass with the method invocation.
7526  * @arg_sourceID: Argument to pass with the method invocation.
7527  * @arg_sinkID: Argument to pass with the method invocation.
7528  * @arg_connectionFormat: Argument to pass with the method invocation.
7529  * @cancellable: (allow-none): A #GCancellable or %NULL.
7530  * @error: Return location for error or %NULL.
7531  *
7532  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncConnect">asyncConnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
7533  *
7534  * See audiomanager_routing_soundmanager_call_async_connect() for the asynchronous version of this method.
7535  *
7536  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7537  */
7538 gboolean
7539 audiomanager_routing_soundmanager_call_async_connect_sync (
7540     AudiomanagerRoutingSoundmanager *proxy,
7541     guint16 arg_handle,
7542     guint16 arg_connectionID,
7543     guint16 arg_sourceID,
7544     guint16 arg_sinkID,
7545     gint arg_connectionFormat,
7546     GCancellable *cancellable,
7547     GError **error)
7548 {
7549   GVariant *_ret;
7550   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
7551     "asyncConnect",
7552     g_variant_new ("(qqqqi)",
7553                    arg_handle,
7554                    arg_connectionID,
7555                    arg_sourceID,
7556                    arg_sinkID,
7557                    arg_connectionFormat),
7558     G_DBUS_CALL_FLAGS_NONE,
7559     -1,
7560     cancellable,
7561     error);
7562   if (_ret == NULL)
7563     goto _out;
7564   g_variant_get (_ret,
7565                  "()");
7566   g_variant_unref (_ret);
7567 _out:
7568   return _ret != NULL;
7569 }
7570
7571 /**
7572  * audiomanager_routing_soundmanager_call_async_disconnect:
7573  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7574  * @arg_handle: Argument to pass with the method invocation.
7575  * @arg_connectionID: Argument to pass with the method invocation.
7576  * @cancellable: (allow-none): A #GCancellable or %NULL.
7577  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
7578  * @user_data: User data to pass to @callback.
7579  *
7580  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncDisconnect">asyncDisconnect()</link> D-Bus method on @proxy.
7581  * 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.
7582  * You can then call audiomanager_routing_soundmanager_call_async_disconnect_finish() to get the result of the operation.
7583  *
7584  * See audiomanager_routing_soundmanager_call_async_disconnect_sync() for the synchronous, blocking version of this method.
7585  */
7586 void
7587 audiomanager_routing_soundmanager_call_async_disconnect (
7588     AudiomanagerRoutingSoundmanager *proxy,
7589     guint16 arg_handle,
7590     guint16 arg_connectionID,
7591     GCancellable *cancellable,
7592     GAsyncReadyCallback callback,
7593     gpointer user_data)
7594 {
7595   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
7596     "asyncDisconnect",
7597     g_variant_new ("(qq)",
7598                    arg_handle,
7599                    arg_connectionID),
7600     G_DBUS_CALL_FLAGS_NONE,
7601     -1,
7602     cancellable,
7603     callback,
7604     user_data);
7605 }
7606
7607 /**
7608  * audiomanager_routing_soundmanager_call_async_disconnect_finish:
7609  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7610  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_disconnect().
7611  * @error: Return location for error or %NULL.
7612  *
7613  * Finishes an operation started with audiomanager_routing_soundmanager_call_async_disconnect().
7614  *
7615  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7616  */
7617 gboolean
7618 audiomanager_routing_soundmanager_call_async_disconnect_finish (
7619     AudiomanagerRoutingSoundmanager *proxy,
7620     GAsyncResult *res,
7621     GError **error)
7622 {
7623   GVariant *_ret;
7624   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
7625   if (_ret == NULL)
7626     goto _out;
7627   g_variant_get (_ret,
7628                  "()");
7629   g_variant_unref (_ret);
7630 _out:
7631   return _ret != NULL;
7632 }
7633
7634 /**
7635  * audiomanager_routing_soundmanager_call_async_disconnect_sync:
7636  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7637  * @arg_handle: Argument to pass with the method invocation.
7638  * @arg_connectionID: Argument to pass with the method invocation.
7639  * @cancellable: (allow-none): A #GCancellable or %NULL.
7640  * @error: Return location for error or %NULL.
7641  *
7642  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncDisconnect">asyncDisconnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
7643  *
7644  * See audiomanager_routing_soundmanager_call_async_disconnect() for the asynchronous version of this method.
7645  *
7646  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7647  */
7648 gboolean
7649 audiomanager_routing_soundmanager_call_async_disconnect_sync (
7650     AudiomanagerRoutingSoundmanager *proxy,
7651     guint16 arg_handle,
7652     guint16 arg_connectionID,
7653     GCancellable *cancellable,
7654     GError **error)
7655 {
7656   GVariant *_ret;
7657   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
7658     "asyncDisconnect",
7659     g_variant_new ("(qq)",
7660                    arg_handle,
7661                    arg_connectionID),
7662     G_DBUS_CALL_FLAGS_NONE,
7663     -1,
7664     cancellable,
7665     error);
7666   if (_ret == NULL)
7667     goto _out;
7668   g_variant_get (_ret,
7669                  "()");
7670   g_variant_unref (_ret);
7671 _out:
7672   return _ret != NULL;
7673 }
7674
7675 /**
7676  * audiomanager_routing_soundmanager_call_async_set_sink_volume:
7677  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7678  * @arg_handle: Argument to pass with the method invocation.
7679  * @arg_sinkID: Argument to pass with the method invocation.
7680  * @arg_volume: Argument to pass with the method invocation.
7681  * @arg_ramp: Argument to pass with the method invocation.
7682  * @arg_time: Argument to pass with the method invocation.
7683  * @cancellable: (allow-none): A #GCancellable or %NULL.
7684  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
7685  * @user_data: User data to pass to @callback.
7686  *
7687  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSinkVolume">asyncSetSinkVolume()</link> D-Bus method on @proxy.
7688  * 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.
7689  * You can then call audiomanager_routing_soundmanager_call_async_set_sink_volume_finish() to get the result of the operation.
7690  *
7691  * See audiomanager_routing_soundmanager_call_async_set_sink_volume_sync() for the synchronous, blocking version of this method.
7692  */
7693 void
7694 audiomanager_routing_soundmanager_call_async_set_sink_volume (
7695     AudiomanagerRoutingSoundmanager *proxy,
7696     guint16 arg_handle,
7697     guint16 arg_sinkID,
7698     gint16 arg_volume,
7699     gint16 arg_ramp,
7700     guint16 arg_time,
7701     GCancellable *cancellable,
7702     GAsyncReadyCallback callback,
7703     gpointer user_data)
7704 {
7705   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
7706     "asyncSetSinkVolume",
7707     g_variant_new ("(qqnnq)",
7708                    arg_handle,
7709                    arg_sinkID,
7710                    arg_volume,
7711                    arg_ramp,
7712                    arg_time),
7713     G_DBUS_CALL_FLAGS_NONE,
7714     -1,
7715     cancellable,
7716     callback,
7717     user_data);
7718 }
7719
7720 /**
7721  * audiomanager_routing_soundmanager_call_async_set_sink_volume_finish:
7722  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7723  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_set_sink_volume().
7724  * @error: Return location for error or %NULL.
7725  *
7726  * Finishes an operation started with audiomanager_routing_soundmanager_call_async_set_sink_volume().
7727  *
7728  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7729  */
7730 gboolean
7731 audiomanager_routing_soundmanager_call_async_set_sink_volume_finish (
7732     AudiomanagerRoutingSoundmanager *proxy,
7733     GAsyncResult *res,
7734     GError **error)
7735 {
7736   GVariant *_ret;
7737   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
7738   if (_ret == NULL)
7739     goto _out;
7740   g_variant_get (_ret,
7741                  "()");
7742   g_variant_unref (_ret);
7743 _out:
7744   return _ret != NULL;
7745 }
7746
7747 /**
7748  * audiomanager_routing_soundmanager_call_async_set_sink_volume_sync:
7749  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7750  * @arg_handle: Argument to pass with the method invocation.
7751  * @arg_sinkID: Argument to pass with the method invocation.
7752  * @arg_volume: Argument to pass with the method invocation.
7753  * @arg_ramp: Argument to pass with the method invocation.
7754  * @arg_time: Argument to pass with the method invocation.
7755  * @cancellable: (allow-none): A #GCancellable or %NULL.
7756  * @error: Return location for error or %NULL.
7757  *
7758  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSinkVolume">asyncSetSinkVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
7759  *
7760  * See audiomanager_routing_soundmanager_call_async_set_sink_volume() for the asynchronous version of this method.
7761  *
7762  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7763  */
7764 gboolean
7765 audiomanager_routing_soundmanager_call_async_set_sink_volume_sync (
7766     AudiomanagerRoutingSoundmanager *proxy,
7767     guint16 arg_handle,
7768     guint16 arg_sinkID,
7769     gint16 arg_volume,
7770     gint16 arg_ramp,
7771     guint16 arg_time,
7772     GCancellable *cancellable,
7773     GError **error)
7774 {
7775   GVariant *_ret;
7776   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
7777     "asyncSetSinkVolume",
7778     g_variant_new ("(qqnnq)",
7779                    arg_handle,
7780                    arg_sinkID,
7781                    arg_volume,
7782                    arg_ramp,
7783                    arg_time),
7784     G_DBUS_CALL_FLAGS_NONE,
7785     -1,
7786     cancellable,
7787     error);
7788   if (_ret == NULL)
7789     goto _out;
7790   g_variant_get (_ret,
7791                  "()");
7792   g_variant_unref (_ret);
7793 _out:
7794   return _ret != NULL;
7795 }
7796
7797 /**
7798  * audiomanager_routing_soundmanager_call_async_set_source_state:
7799  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7800  * @arg_handle: Argument to pass with the method invocation.
7801  * @arg_sourceID: Argument to pass with the method invocation.
7802  * @arg_sourceState: Argument to pass with the method invocation.
7803  * @cancellable: (allow-none): A #GCancellable or %NULL.
7804  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
7805  * @user_data: User data to pass to @callback.
7806  *
7807  * Asynchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSourceState">asyncSetSourceState()</link> D-Bus method on @proxy.
7808  * 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.
7809  * You can then call audiomanager_routing_soundmanager_call_async_set_source_state_finish() to get the result of the operation.
7810  *
7811  * See audiomanager_routing_soundmanager_call_async_set_source_state_sync() for the synchronous, blocking version of this method.
7812  */
7813 void
7814 audiomanager_routing_soundmanager_call_async_set_source_state (
7815     AudiomanagerRoutingSoundmanager *proxy,
7816     guint16 arg_handle,
7817     guint16 arg_sourceID,
7818     gint arg_sourceState,
7819     GCancellable *cancellable,
7820     GAsyncReadyCallback callback,
7821     gpointer user_data)
7822 {
7823   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
7824     "asyncSetSourceState",
7825     g_variant_new ("(qqi)",
7826                    arg_handle,
7827                    arg_sourceID,
7828                    arg_sourceState),
7829     G_DBUS_CALL_FLAGS_NONE,
7830     -1,
7831     cancellable,
7832     callback,
7833     user_data);
7834 }
7835
7836 /**
7837  * audiomanager_routing_soundmanager_call_async_set_source_state_finish:
7838  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7839  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_set_source_state().
7840  * @error: Return location for error or %NULL.
7841  *
7842  * Finishes an operation started with audiomanager_routing_soundmanager_call_async_set_source_state().
7843  *
7844  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7845  */
7846 gboolean
7847 audiomanager_routing_soundmanager_call_async_set_source_state_finish (
7848     AudiomanagerRoutingSoundmanager *proxy,
7849     GAsyncResult *res,
7850     GError **error)
7851 {
7852   GVariant *_ret;
7853   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
7854   if (_ret == NULL)
7855     goto _out;
7856   g_variant_get (_ret,
7857                  "()");
7858   g_variant_unref (_ret);
7859 _out:
7860   return _ret != NULL;
7861 }
7862
7863 /**
7864  * audiomanager_routing_soundmanager_call_async_set_source_state_sync:
7865  * @proxy: A #AudiomanagerRoutingSoundmanagerProxy.
7866  * @arg_handle: Argument to pass with the method invocation.
7867  * @arg_sourceID: Argument to pass with the method invocation.
7868  * @arg_sourceState: Argument to pass with the method invocation.
7869  * @cancellable: (allow-none): A #GCancellable or %NULL.
7870  * @error: Return location for error or %NULL.
7871  *
7872  * Synchronously invokes the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSourceState">asyncSetSourceState()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
7873  *
7874  * See audiomanager_routing_soundmanager_call_async_set_source_state() for the asynchronous version of this method.
7875  *
7876  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
7877  */
7878 gboolean
7879 audiomanager_routing_soundmanager_call_async_set_source_state_sync (
7880     AudiomanagerRoutingSoundmanager *proxy,
7881     guint16 arg_handle,
7882     guint16 arg_sourceID,
7883     gint arg_sourceState,
7884     GCancellable *cancellable,
7885     GError **error)
7886 {
7887   GVariant *_ret;
7888   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
7889     "asyncSetSourceState",
7890     g_variant_new ("(qqi)",
7891                    arg_handle,
7892                    arg_sourceID,
7893                    arg_sourceState),
7894     G_DBUS_CALL_FLAGS_NONE,
7895     -1,
7896     cancellable,
7897     error);
7898   if (_ret == NULL)
7899     goto _out;
7900   g_variant_get (_ret,
7901                  "()");
7902   g_variant_unref (_ret);
7903 _out:
7904   return _ret != NULL;
7905 }
7906
7907 /**
7908  * audiomanager_routing_soundmanager_complete_async_abort:
7909  * @object: A #AudiomanagerRoutingSoundmanager.
7910  * @invocation: (transfer full): A #GDBusMethodInvocation.
7911  * @error: Parameter to return.
7912  *
7913  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncAbort">asyncAbort()</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.
7914  *
7915  * This method will free @invocation, you cannot use it afterwards.
7916  */
7917 void
7918 audiomanager_routing_soundmanager_complete_async_abort (
7919     AudiomanagerRoutingSoundmanager *object,
7920     GDBusMethodInvocation *invocation,
7921     gint16 error)
7922 {
7923   g_dbus_method_invocation_return_value (invocation,
7924     g_variant_new ("(n)",
7925                    error));
7926 }
7927
7928 /**
7929  * audiomanager_routing_soundmanager_complete_async_connect:
7930  * @object: A #AudiomanagerRoutingSoundmanager.
7931  * @invocation: (transfer full): A #GDBusMethodInvocation.
7932  *
7933  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncConnect">asyncConnect()</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.
7934  *
7935  * This method will free @invocation, you cannot use it afterwards.
7936  */
7937 void
7938 audiomanager_routing_soundmanager_complete_async_connect (
7939     AudiomanagerRoutingSoundmanager *object,
7940     GDBusMethodInvocation *invocation)
7941 {
7942   g_dbus_method_invocation_return_value (invocation,
7943     g_variant_new ("()"));
7944 }
7945
7946 /**
7947  * audiomanager_routing_soundmanager_complete_async_disconnect:
7948  * @object: A #AudiomanagerRoutingSoundmanager.
7949  * @invocation: (transfer full): A #GDBusMethodInvocation.
7950  *
7951  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncDisconnect">asyncDisconnect()</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.
7952  *
7953  * This method will free @invocation, you cannot use it afterwards.
7954  */
7955 void
7956 audiomanager_routing_soundmanager_complete_async_disconnect (
7957     AudiomanagerRoutingSoundmanager *object,
7958     GDBusMethodInvocation *invocation)
7959 {
7960   g_dbus_method_invocation_return_value (invocation,
7961     g_variant_new ("()"));
7962 }
7963
7964 /**
7965  * audiomanager_routing_soundmanager_complete_async_set_sink_volume:
7966  * @object: A #AudiomanagerRoutingSoundmanager.
7967  * @invocation: (transfer full): A #GDBusMethodInvocation.
7968  *
7969  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSinkVolume">asyncSetSinkVolume()</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.
7970  *
7971  * This method will free @invocation, you cannot use it afterwards.
7972  */
7973 void
7974 audiomanager_routing_soundmanager_complete_async_set_sink_volume (
7975     AudiomanagerRoutingSoundmanager *object,
7976     GDBusMethodInvocation *invocation)
7977 {
7978   g_dbus_method_invocation_return_value (invocation,
7979     g_variant_new ("()"));
7980 }
7981
7982 /**
7983  * audiomanager_routing_soundmanager_complete_async_set_source_state:
7984  * @object: A #AudiomanagerRoutingSoundmanager.
7985  * @invocation: (transfer full): A #GDBusMethodInvocation.
7986  *
7987  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-genivi-audiomanager-routing-soundmanager.asyncSetSourceState">asyncSetSourceState()</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.
7988  *
7989  * This method will free @invocation, you cannot use it afterwards.
7990  */
7991 void
7992 audiomanager_routing_soundmanager_complete_async_set_source_state (
7993     AudiomanagerRoutingSoundmanager *object,
7994     GDBusMethodInvocation *invocation)
7995 {
7996   g_dbus_method_invocation_return_value (invocation,
7997     g_variant_new ("()"));
7998 }
7999
8000 /* ------------------------------------------------------------------------ */
8001
8002 /**
8003  * AudiomanagerRoutingSoundmanagerProxy:
8004  *
8005  * The #AudiomanagerRoutingSoundmanagerProxy structure contains only private data and should only be accessed using the provided API.
8006  */
8007
8008 /**
8009  * AudiomanagerRoutingSoundmanagerProxyClass:
8010  * @parent_class: The parent class.
8011  *
8012  * Class structure for #AudiomanagerRoutingSoundmanagerProxy.
8013  */
8014
8015 struct _AudiomanagerRoutingSoundmanagerProxyPrivate
8016 {
8017   GData *qdata;
8018 };
8019
8020 static void audiomanager_routing_soundmanager_proxy_iface_init (AudiomanagerRoutingSoundmanagerIface *iface);
8021
8022 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
8023 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerProxy, audiomanager_routing_soundmanager_proxy, G_TYPE_DBUS_PROXY,
8024                          G_ADD_PRIVATE (AudiomanagerRoutingSoundmanagerProxy)
8025                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_proxy_iface_init));
8026
8027 #else
8028 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerProxy, audiomanager_routing_soundmanager_proxy, G_TYPE_DBUS_PROXY,
8029                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_proxy_iface_init));
8030
8031 #endif
8032 static void
8033 audiomanager_routing_soundmanager_proxy_finalize (GObject *object)
8034 {
8035   AudiomanagerRoutingSoundmanagerProxy *proxy = AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (object);
8036   g_datalist_clear (&proxy->priv->qdata);
8037   G_OBJECT_CLASS (audiomanager_routing_soundmanager_proxy_parent_class)->finalize (object);
8038 }
8039
8040 static void
8041 audiomanager_routing_soundmanager_proxy_get_property (GObject      *object,
8042   guint         prop_id,
8043   GValue       *value,
8044   GParamSpec   *pspec G_GNUC_UNUSED)
8045 {
8046 }
8047
8048 static void
8049 audiomanager_routing_soundmanager_proxy_set_property (GObject      *object,
8050   guint         prop_id,
8051   const GValue *value,
8052   GParamSpec   *pspec G_GNUC_UNUSED)
8053 {
8054 }
8055
8056 static void
8057 audiomanager_routing_soundmanager_proxy_g_signal (GDBusProxy *proxy,
8058   const gchar *sender_name G_GNUC_UNUSED,
8059   const gchar *signal_name,
8060   GVariant *parameters)
8061 {
8062   _ExtendedGDBusSignalInfo *info;
8063   GVariantIter iter;
8064   GVariant *child;
8065   GValue *paramv;
8066   guint num_params;
8067   guint n;
8068   guint signal_id;
8069   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, signal_name);
8070   if (info == NULL)
8071     return;
8072   num_params = g_variant_n_children (parameters);
8073   paramv = g_new0 (GValue, num_params + 1);
8074   g_value_init (&paramv[0], TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER);
8075   g_value_set_object (&paramv[0], proxy);
8076   g_variant_iter_init (&iter, parameters);
8077   n = 1;
8078   while ((child = g_variant_iter_next_value (&iter)) != NULL)
8079     {
8080       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
8081       if (arg_info->use_gvariant)
8082         {
8083           g_value_init (&paramv[n], G_TYPE_VARIANT);
8084           g_value_set_variant (&paramv[n], child);
8085           n++;
8086         }
8087       else
8088         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
8089       g_variant_unref (child);
8090     }
8091   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER);
8092   g_signal_emitv (paramv, signal_id, 0, NULL);
8093   for (n = 0; n < num_params + 1; n++)
8094     g_value_unset (&paramv[n]);
8095   g_free (paramv);
8096 }
8097
8098 static void
8099 audiomanager_routing_soundmanager_proxy_g_properties_changed (GDBusProxy *_proxy,
8100   GVariant *changed_properties,
8101   const gchar *const *invalidated_properties)
8102 {
8103   AudiomanagerRoutingSoundmanagerProxy *proxy = AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (_proxy);
8104   guint n;
8105   const gchar *key;
8106   GVariantIter *iter;
8107   _ExtendedGDBusPropertyInfo *info;
8108   g_variant_get (changed_properties, "a{sv}", &iter);
8109   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
8110     {
8111       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, key);
8112       g_datalist_remove_data (&proxy->priv->qdata, key);
8113       if (info != NULL)
8114         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
8115     }
8116   g_variant_iter_free (iter);
8117   for (n = 0; invalidated_properties[n] != NULL; n++)
8118     {
8119       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, invalidated_properties[n]);
8120       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
8121       if (info != NULL)
8122         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
8123     }
8124 }
8125
8126 static void
8127 audiomanager_routing_soundmanager_proxy_init (AudiomanagerRoutingSoundmanagerProxy *proxy)
8128 {
8129 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
8130   proxy->priv = audiomanager_routing_soundmanager_proxy_get_instance_private (proxy);
8131 #else
8132   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyPrivate);
8133 #endif
8134
8135   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_routing_soundmanager_interface_info ());
8136 }
8137
8138 static void
8139 audiomanager_routing_soundmanager_proxy_class_init (AudiomanagerRoutingSoundmanagerProxyClass *klass)
8140 {
8141   GObjectClass *gobject_class;
8142   GDBusProxyClass *proxy_class;
8143
8144   gobject_class = G_OBJECT_CLASS (klass);
8145   gobject_class->finalize     = audiomanager_routing_soundmanager_proxy_finalize;
8146   gobject_class->get_property = audiomanager_routing_soundmanager_proxy_get_property;
8147   gobject_class->set_property = audiomanager_routing_soundmanager_proxy_set_property;
8148
8149   proxy_class = G_DBUS_PROXY_CLASS (klass);
8150   proxy_class->g_signal = audiomanager_routing_soundmanager_proxy_g_signal;
8151   proxy_class->g_properties_changed = audiomanager_routing_soundmanager_proxy_g_properties_changed;
8152
8153 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
8154   g_type_class_add_private (klass, sizeof (AudiomanagerRoutingSoundmanagerProxyPrivate));
8155 #endif
8156 }
8157
8158 static void
8159 audiomanager_routing_soundmanager_proxy_iface_init (AudiomanagerRoutingSoundmanagerIface *iface)
8160 {
8161 }
8162
8163 /**
8164  * audiomanager_routing_soundmanager_proxy_new:
8165  * @connection: A #GDBusConnection.
8166  * @flags: Flags from the #GDBusProxyFlags enumeration.
8167  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
8168  * @object_path: An object path.
8169  * @cancellable: (allow-none): A #GCancellable or %NULL.
8170  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
8171  * @user_data: User data to pass to @callback.
8172  *
8173  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>. See g_dbus_proxy_new() for more details.
8174  *
8175  * 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.
8176  * You can then call audiomanager_routing_soundmanager_proxy_new_finish() to get the result of the operation.
8177  *
8178  * See audiomanager_routing_soundmanager_proxy_new_sync() for the synchronous, blocking version of this constructor.
8179  */
8180 void
8181 audiomanager_routing_soundmanager_proxy_new (
8182     GDBusConnection     *connection,
8183     GDBusProxyFlags      flags,
8184     const gchar         *name,
8185     const gchar         *object_path,
8186     GCancellable        *cancellable,
8187     GAsyncReadyCallback  callback,
8188     gpointer             user_data)
8189 {
8190   g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_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.genivi.audiomanager.routing.soundmanager", NULL);
8191 }
8192
8193 /**
8194  * audiomanager_routing_soundmanager_proxy_new_finish:
8195  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_proxy_new().
8196  * @error: Return location for error or %NULL
8197  *
8198  * Finishes an operation started with audiomanager_routing_soundmanager_proxy_new().
8199  *
8200  * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set.
8201  */
8202 AudiomanagerRoutingSoundmanager *
8203 audiomanager_routing_soundmanager_proxy_new_finish (
8204     GAsyncResult        *res,
8205     GError             **error)
8206 {
8207   GObject *ret;
8208   GObject *source_object;
8209   source_object = g_async_result_get_source_object (res);
8210   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
8211   g_object_unref (source_object);
8212   if (ret != NULL)
8213     return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8214   else
8215     return NULL;
8216 }
8217
8218 /**
8219  * audiomanager_routing_soundmanager_proxy_new_sync:
8220  * @connection: A #GDBusConnection.
8221  * @flags: Flags from the #GDBusProxyFlags enumeration.
8222  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
8223  * @object_path: An object path.
8224  * @cancellable: (allow-none): A #GCancellable or %NULL.
8225  * @error: Return location for error or %NULL
8226  *
8227  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>. See g_dbus_proxy_new_sync() for more details.
8228  *
8229  * The calling thread is blocked until a reply is received.
8230  *
8231  * See audiomanager_routing_soundmanager_proxy_new() for the asynchronous version of this constructor.
8232  *
8233  * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set.
8234  */
8235 AudiomanagerRoutingSoundmanager *
8236 audiomanager_routing_soundmanager_proxy_new_sync (
8237     GDBusConnection     *connection,
8238     GDBusProxyFlags      flags,
8239     const gchar         *name,
8240     const gchar         *object_path,
8241     GCancellable        *cancellable,
8242     GError             **error)
8243 {
8244   GInitable *ret;
8245   ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL);
8246   if (ret != NULL)
8247     return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8248   else
8249     return NULL;
8250 }
8251
8252
8253 /**
8254  * audiomanager_routing_soundmanager_proxy_new_for_bus:
8255  * @bus_type: A #GBusType.
8256  * @flags: Flags from the #GDBusProxyFlags enumeration.
8257  * @name: A bus name (well-known or unique).
8258  * @object_path: An object path.
8259  * @cancellable: (allow-none): A #GCancellable or %NULL.
8260  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
8261  * @user_data: User data to pass to @callback.
8262  *
8263  * Like audiomanager_routing_soundmanager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
8264  *
8265  * 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.
8266  * You can then call audiomanager_routing_soundmanager_proxy_new_for_bus_finish() to get the result of the operation.
8267  *
8268  * See audiomanager_routing_soundmanager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
8269  */
8270 void
8271 audiomanager_routing_soundmanager_proxy_new_for_bus (
8272     GBusType             bus_type,
8273     GDBusProxyFlags      flags,
8274     const gchar         *name,
8275     const gchar         *object_path,
8276     GCancellable        *cancellable,
8277     GAsyncReadyCallback  callback,
8278     gpointer             user_data)
8279 {
8280   g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_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.genivi.audiomanager.routing.soundmanager", NULL);
8281 }
8282
8283 /**
8284  * audiomanager_routing_soundmanager_proxy_new_for_bus_finish:
8285  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_proxy_new_for_bus().
8286  * @error: Return location for error or %NULL
8287  *
8288  * Finishes an operation started with audiomanager_routing_soundmanager_proxy_new_for_bus().
8289  *
8290  * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set.
8291  */
8292 AudiomanagerRoutingSoundmanager *
8293 audiomanager_routing_soundmanager_proxy_new_for_bus_finish (
8294     GAsyncResult        *res,
8295     GError             **error)
8296 {
8297   GObject *ret;
8298   GObject *source_object;
8299   source_object = g_async_result_get_source_object (res);
8300   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
8301   g_object_unref (source_object);
8302   if (ret != NULL)
8303     return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8304   else
8305     return NULL;
8306 }
8307
8308 /**
8309  * audiomanager_routing_soundmanager_proxy_new_for_bus_sync:
8310  * @bus_type: A #GBusType.
8311  * @flags: Flags from the #GDBusProxyFlags enumeration.
8312  * @name: A bus name (well-known or unique).
8313  * @object_path: An object path.
8314  * @cancellable: (allow-none): A #GCancellable or %NULL.
8315  * @error: Return location for error or %NULL
8316  *
8317  * Like audiomanager_routing_soundmanager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
8318  *
8319  * The calling thread is blocked until a reply is received.
8320  *
8321  * See audiomanager_routing_soundmanager_proxy_new_for_bus() for the asynchronous version of this constructor.
8322  *
8323  * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set.
8324  */
8325 AudiomanagerRoutingSoundmanager *
8326 audiomanager_routing_soundmanager_proxy_new_for_bus_sync (
8327     GBusType             bus_type,
8328     GDBusProxyFlags      flags,
8329     const gchar         *name,
8330     const gchar         *object_path,
8331     GCancellable        *cancellable,
8332     GError             **error)
8333 {
8334   GInitable *ret;
8335   ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL);
8336   if (ret != NULL)
8337     return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8338   else
8339     return NULL;
8340 }
8341
8342
8343 /* ------------------------------------------------------------------------ */
8344
8345 /**
8346  * AudiomanagerRoutingSoundmanagerSkeleton:
8347  *
8348  * The #AudiomanagerRoutingSoundmanagerSkeleton structure contains only private data and should only be accessed using the provided API.
8349  */
8350
8351 /**
8352  * AudiomanagerRoutingSoundmanagerSkeletonClass:
8353  * @parent_class: The parent class.
8354  *
8355  * Class structure for #AudiomanagerRoutingSoundmanagerSkeleton.
8356  */
8357
8358 struct _AudiomanagerRoutingSoundmanagerSkeletonPrivate
8359 {
8360   GValue *properties;
8361   GList *changed_properties;
8362   GSource *changed_properties_idle_source;
8363   GMainContext *context;
8364   GMutex lock;
8365 };
8366
8367 static void
8368 _audiomanager_routing_soundmanager_skeleton_handle_method_call (
8369   GDBusConnection *connection G_GNUC_UNUSED,
8370   const gchar *sender G_GNUC_UNUSED,
8371   const gchar *object_path G_GNUC_UNUSED,
8372   const gchar *interface_name,
8373   const gchar *method_name,
8374   GVariant *parameters,
8375   GDBusMethodInvocation *invocation,
8376   gpointer user_data)
8377 {
8378   AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data);
8379   _ExtendedGDBusMethodInfo *info;
8380   GVariantIter iter;
8381   GVariant *child;
8382   GValue *paramv;
8383   guint num_params;
8384   guint num_extra;
8385   guint n;
8386   guint signal_id;
8387   GValue return_value = G_VALUE_INIT;
8388   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
8389   g_assert (info != NULL);
8390   num_params = g_variant_n_children (parameters);
8391   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
8392   n = 0;
8393   g_value_init (&paramv[n], TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER);
8394   g_value_set_object (&paramv[n++], skeleton);
8395   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
8396   g_value_set_object (&paramv[n++], invocation);
8397   if (info->pass_fdlist)
8398     {
8399 #ifdef G_OS_UNIX
8400       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
8401       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
8402 #else
8403       g_assert_not_reached ();
8404 #endif
8405     }
8406   g_variant_iter_init (&iter, parameters);
8407   while ((child = g_variant_iter_next_value (&iter)) != NULL)
8408     {
8409       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
8410       if (arg_info->use_gvariant)
8411         {
8412           g_value_init (&paramv[n], G_TYPE_VARIANT);
8413           g_value_set_variant (&paramv[n], child);
8414           n++;
8415         }
8416       else
8417         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
8418       g_variant_unref (child);
8419     }
8420   signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER);
8421   g_value_init (&return_value, G_TYPE_BOOLEAN);
8422   g_signal_emitv (paramv, signal_id, 0, &return_value);
8423   if (!g_value_get_boolean (&return_value))
8424     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);
8425   g_value_unset (&return_value);
8426   for (n = 0; n < num_params + num_extra; n++)
8427     g_value_unset (&paramv[n]);
8428   g_free (paramv);
8429 }
8430
8431 static GVariant *
8432 _audiomanager_routing_soundmanager_skeleton_handle_get_property (
8433   GDBusConnection *connection G_GNUC_UNUSED,
8434   const gchar *sender G_GNUC_UNUSED,
8435   const gchar *object_path G_GNUC_UNUSED,
8436   const gchar *interface_name G_GNUC_UNUSED,
8437   const gchar *property_name,
8438   GError **error,
8439   gpointer user_data)
8440 {
8441   AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data);
8442   GValue value = G_VALUE_INIT;
8443   GParamSpec *pspec;
8444   _ExtendedGDBusPropertyInfo *info;
8445   GVariant *ret;
8446   ret = NULL;
8447   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, property_name);
8448   g_assert (info != NULL);
8449   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
8450   if (pspec == NULL)
8451     {
8452       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
8453     }
8454   else
8455     {
8456       g_value_init (&value, pspec->value_type);
8457       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
8458       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
8459       g_value_unset (&value);
8460     }
8461   return ret;
8462 }
8463
8464 static gboolean
8465 _audiomanager_routing_soundmanager_skeleton_handle_set_property (
8466   GDBusConnection *connection G_GNUC_UNUSED,
8467   const gchar *sender G_GNUC_UNUSED,
8468   const gchar *object_path G_GNUC_UNUSED,
8469   const gchar *interface_name G_GNUC_UNUSED,
8470   const gchar *property_name,
8471   GVariant *variant,
8472   GError **error,
8473   gpointer user_data)
8474 {
8475   AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data);
8476   GValue value = G_VALUE_INIT;
8477   GParamSpec *pspec;
8478   _ExtendedGDBusPropertyInfo *info;
8479   gboolean ret;
8480   ret = FALSE;
8481   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, property_name);
8482   g_assert (info != NULL);
8483   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
8484   if (pspec == NULL)
8485     {
8486       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
8487     }
8488   else
8489     {
8490       if (info->use_gvariant)
8491         g_value_set_variant (&value, variant);
8492       else
8493         g_dbus_gvariant_to_gvalue (variant, &value);
8494       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
8495       g_value_unset (&value);
8496       ret = TRUE;
8497     }
8498   return ret;
8499 }
8500
8501 static const GDBusInterfaceVTable _audiomanager_routing_soundmanager_skeleton_vtable =
8502 {
8503   _audiomanager_routing_soundmanager_skeleton_handle_method_call,
8504   _audiomanager_routing_soundmanager_skeleton_handle_get_property,
8505   _audiomanager_routing_soundmanager_skeleton_handle_set_property,
8506   {NULL}
8507 };
8508
8509 static GDBusInterfaceInfo *
8510 audiomanager_routing_soundmanager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
8511 {
8512   return audiomanager_routing_soundmanager_interface_info ();
8513 }
8514
8515 static GDBusInterfaceVTable *
8516 audiomanager_routing_soundmanager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
8517 {
8518   return (GDBusInterfaceVTable *) &_audiomanager_routing_soundmanager_skeleton_vtable;
8519 }
8520
8521 static GVariant *
8522 audiomanager_routing_soundmanager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
8523 {
8524   AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (_skeleton);
8525
8526   GVariantBuilder builder;
8527   guint n;
8528   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
8529   if (_audiomanager_routing_soundmanager_interface_info.parent_struct.properties == NULL)
8530     goto out;
8531   for (n = 0; _audiomanager_routing_soundmanager_interface_info.parent_struct.properties[n] != NULL; n++)
8532     {
8533       GDBusPropertyInfo *info = _audiomanager_routing_soundmanager_interface_info.parent_struct.properties[n];
8534       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
8535         {
8536           GVariant *value;
8537           value = _audiomanager_routing_soundmanager_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.genivi.audiomanager.routing.soundmanager", info->name, NULL, skeleton);
8538           if (value != NULL)
8539             {
8540               g_variant_take_ref (value);
8541               g_variant_builder_add (&builder, "{sv}", info->name, value);
8542               g_variant_unref (value);
8543             }
8544         }
8545     }
8546 out:
8547   return g_variant_builder_end (&builder);
8548 }
8549
8550 static void
8551 audiomanager_routing_soundmanager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
8552 {
8553 }
8554
8555 static void audiomanager_routing_soundmanager_skeleton_iface_init (AudiomanagerRoutingSoundmanagerIface *iface);
8556 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
8557 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerSkeleton, audiomanager_routing_soundmanager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
8558                          G_ADD_PRIVATE (AudiomanagerRoutingSoundmanagerSkeleton)
8559                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_skeleton_iface_init));
8560
8561 #else
8562 G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerSkeleton, audiomanager_routing_soundmanager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
8563                          G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_skeleton_iface_init));
8564
8565 #endif
8566 static void
8567 audiomanager_routing_soundmanager_skeleton_finalize (GObject *object)
8568 {
8569   AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (object);
8570   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
8571   if (skeleton->priv->changed_properties_idle_source != NULL)
8572     g_source_destroy (skeleton->priv->changed_properties_idle_source);
8573   g_main_context_unref (skeleton->priv->context);
8574   g_mutex_clear (&skeleton->priv->lock);
8575   G_OBJECT_CLASS (audiomanager_routing_soundmanager_skeleton_parent_class)->finalize (object);
8576 }
8577
8578 static void
8579 audiomanager_routing_soundmanager_skeleton_init (AudiomanagerRoutingSoundmanagerSkeleton *skeleton)
8580 {
8581 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
8582   skeleton->priv = audiomanager_routing_soundmanager_skeleton_get_instance_private (skeleton);
8583 #else
8584   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonPrivate);
8585 #endif
8586
8587   g_mutex_init (&skeleton->priv->lock);
8588   skeleton->priv->context = g_main_context_ref_thread_default ();
8589 }
8590
8591 static void
8592 audiomanager_routing_soundmanager_skeleton_class_init (AudiomanagerRoutingSoundmanagerSkeletonClass *klass)
8593 {
8594   GObjectClass *gobject_class;
8595   GDBusInterfaceSkeletonClass *skeleton_class;
8596
8597   gobject_class = G_OBJECT_CLASS (klass);
8598   gobject_class->finalize = audiomanager_routing_soundmanager_skeleton_finalize;
8599
8600   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
8601   skeleton_class->get_info = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_info;
8602   skeleton_class->get_properties = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_properties;
8603   skeleton_class->flush = audiomanager_routing_soundmanager_skeleton_dbus_interface_flush;
8604   skeleton_class->get_vtable = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_vtable;
8605
8606 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
8607   g_type_class_add_private (klass, sizeof (AudiomanagerRoutingSoundmanagerSkeletonPrivate));
8608 #endif
8609 }
8610
8611 static void
8612 audiomanager_routing_soundmanager_skeleton_iface_init (AudiomanagerRoutingSoundmanagerIface *iface)
8613 {
8614 }
8615
8616 /**
8617  * audiomanager_routing_soundmanager_skeleton_new:
8618  *
8619  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>.
8620  *
8621  * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerSkeleton): The skeleton object.
8622  */
8623 AudiomanagerRoutingSoundmanager *
8624 audiomanager_routing_soundmanager_skeleton_new (void)
8625 {
8626   return AUDIOMANAGER_ROUTING_SOUNDMANAGER (g_object_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, NULL));
8627 }
8628
8629 /* ------------------------------------------------------------------------
8630  * Code for Object, ObjectProxy and ObjectSkeleton
8631  * ------------------------------------------------------------------------
8632  */
8633
8634 /**
8635  * SECTION:Object
8636  * @title: Object
8637  * @short_description: Specialized GDBusObject types
8638  *
8639  * This section contains the #Object, #ObjectProxy, and #ObjectSkeleton types which make it easier to work with objects implementing generated types for D-Bus interfaces.
8640  */
8641
8642 /**
8643  * Object:
8644  *
8645  * The #Object type is a specialized container of interfaces.
8646  */
8647
8648 /**
8649  * ObjectIface:
8650  * @parent_iface: The parent interface.
8651  *
8652  * Virtual table for the #Object interface.
8653  */
8654
8655 typedef ObjectIface ObjectInterface;
8656 G_DEFINE_INTERFACE_WITH_CODE (Object, object, G_TYPE_OBJECT, g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_DBUS_OBJECT));
8657
8658 static void
8659 object_default_init (ObjectIface *iface)
8660 {
8661   /**
8662    * Object:audiomanager-commandinterface:
8663    *
8664    * The #AudiomanagerCommandinterface instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link>, if any.
8665    *
8666    * Connect to the #GObject::notify signal to get informed of property changes.
8667    */
8668   g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-commandinterface", "audiomanager-commandinterface", "audiomanager-commandinterface", TYPE_AUDIOMANAGER_COMMANDINTERFACE, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS));
8669
8670   /**
8671    * Object:audiomanager-routinginterface:
8672    *
8673    * The #AudiomanagerRoutinginterface instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link>, if any.
8674    *
8675    * Connect to the #GObject::notify signal to get informed of property changes.
8676    */
8677   g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-routinginterface", "audiomanager-routinginterface", "audiomanager-routinginterface", TYPE_AUDIOMANAGER_ROUTINGINTERFACE, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS));
8678
8679   /**
8680    * Object:audiomanager-routing-soundmanager:
8681    *
8682    * The #AudiomanagerRoutingSoundmanager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link>, if any.
8683    *
8684    * Connect to the #GObject::notify signal to get informed of property changes.
8685    */
8686   g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-routing-soundmanager", "audiomanager-routing-soundmanager", "audiomanager-routing-soundmanager", TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS));
8687
8688 }
8689
8690 /**
8691  * object_get_audiomanager_commandinterface:
8692  * @object: A #Object.
8693  *
8694  * Gets the #AudiomanagerCommandinterface instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link> on @object, if any.
8695  *
8696  * Returns: (transfer full): A #AudiomanagerCommandinterface that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
8697  */
8698 AudiomanagerCommandinterface *object_get_audiomanager_commandinterface (Object *object)
8699 {
8700   GDBusInterface *ret;
8701   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface");
8702   if (ret == NULL)
8703     return NULL;
8704   return AUDIOMANAGER_COMMANDINTERFACE (ret);
8705 }
8706
8707 /**
8708  * object_get_audiomanager_routinginterface:
8709  * @object: A #Object.
8710  *
8711  * Gets the #AudiomanagerRoutinginterface instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link> on @object, if any.
8712  *
8713  * Returns: (transfer full): A #AudiomanagerRoutinginterface that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
8714  */
8715 AudiomanagerRoutinginterface *object_get_audiomanager_routinginterface (Object *object)
8716 {
8717   GDBusInterface *ret;
8718   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface");
8719   if (ret == NULL)
8720     return NULL;
8721   return AUDIOMANAGER_ROUTINGINTERFACE (ret);
8722 }
8723
8724 /**
8725  * object_get_audiomanager_routing_soundmanager:
8726  * @object: A #Object.
8727  *
8728  * Gets the #AudiomanagerRoutingSoundmanager instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link> on @object, if any.
8729  *
8730  * Returns: (transfer full): A #AudiomanagerRoutingSoundmanager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
8731  */
8732 AudiomanagerRoutingSoundmanager *object_get_audiomanager_routing_soundmanager (Object *object)
8733 {
8734   GDBusInterface *ret;
8735   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager");
8736   if (ret == NULL)
8737     return NULL;
8738   return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8739 }
8740
8741
8742 /**
8743  * object_peek_audiomanager_commandinterface: (skip)
8744  * @object: A #Object.
8745  *
8746  * Like object_get_audiomanager_commandinterface() but doesn't increase the reference count on the returned object.
8747  *
8748  * <warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
8749  *
8750  * Returns: (transfer none): A #AudiomanagerCommandinterface or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
8751  */
8752 AudiomanagerCommandinterface *object_peek_audiomanager_commandinterface (Object *object)
8753 {
8754   GDBusInterface *ret;
8755   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface");
8756   if (ret == NULL)
8757     return NULL;
8758   g_object_unref (ret);
8759   return AUDIOMANAGER_COMMANDINTERFACE (ret);
8760 }
8761
8762 /**
8763  * object_peek_audiomanager_routinginterface: (skip)
8764  * @object: A #Object.
8765  *
8766  * Like object_get_audiomanager_routinginterface() but doesn't increase the reference count on the returned object.
8767  *
8768  * <warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
8769  *
8770  * Returns: (transfer none): A #AudiomanagerRoutinginterface or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
8771  */
8772 AudiomanagerRoutinginterface *object_peek_audiomanager_routinginterface (Object *object)
8773 {
8774   GDBusInterface *ret;
8775   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface");
8776   if (ret == NULL)
8777     return NULL;
8778   g_object_unref (ret);
8779   return AUDIOMANAGER_ROUTINGINTERFACE (ret);
8780 }
8781
8782 /**
8783  * object_peek_audiomanager_routing_soundmanager: (skip)
8784  * @object: A #Object.
8785  *
8786  * Like object_get_audiomanager_routing_soundmanager() but doesn't increase the reference count on the returned object.
8787  *
8788  * <warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
8789  *
8790  * Returns: (transfer none): A #AudiomanagerRoutingSoundmanager or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
8791  */
8792 AudiomanagerRoutingSoundmanager *object_peek_audiomanager_routing_soundmanager (Object *object)
8793 {
8794   GDBusInterface *ret;
8795   ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager");
8796   if (ret == NULL)
8797     return NULL;
8798   g_object_unref (ret);
8799   return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret);
8800 }
8801
8802
8803 static void
8804 object_notify (GDBusObject *object, GDBusInterface *interface)
8805 {
8806   _ExtendedGDBusInterfaceInfo *info = (_ExtendedGDBusInterfaceInfo *) g_dbus_interface_get_info (interface);
8807   /* info can be NULL if the other end is using a D-Bus interface we don't know
8808    * anything about, for example old generated code in this process talking to
8809    * newer generated code in the other process. */
8810   if (info != NULL)
8811     g_object_notify (G_OBJECT (object), info->hyphen_name);
8812 }
8813
8814 /**
8815  * ObjectProxy:
8816  *
8817  * The #ObjectProxy structure contains only private data and should only be accessed using the provided API.
8818  */
8819
8820 /**
8821  * ObjectProxyClass:
8822  * @parent_class: The parent class.
8823  *
8824  * Class structure for #ObjectProxy.
8825  */
8826
8827 static void
8828 object_proxy__object_iface_init (ObjectIface *iface G_GNUC_UNUSED)
8829 {
8830 }
8831
8832 static void
8833 object_proxy__g_dbus_object_iface_init (GDBusObjectIface *iface)
8834 {
8835   iface->interface_added = object_notify;
8836   iface->interface_removed = object_notify;
8837 }
8838
8839
8840 G_DEFINE_TYPE_WITH_CODE (ObjectProxy, object_proxy, G_TYPE_DBUS_OBJECT_PROXY,
8841                          G_IMPLEMENT_INTERFACE (TYPE_OBJECT, object_proxy__object_iface_init)
8842                          G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, object_proxy__g_dbus_object_iface_init));
8843
8844 static void
8845 object_proxy_init (ObjectProxy *object G_GNUC_UNUSED)
8846 {
8847 }
8848
8849 static void
8850 object_proxy_set_property (GObject      *gobject,
8851   guint         prop_id,
8852   const GValue *value G_GNUC_UNUSED,
8853   GParamSpec   *pspec)
8854 {
8855   G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
8856 }
8857
8858 static void
8859 object_proxy_get_property (GObject      *gobject,
8860   guint         prop_id,
8861   GValue       *value,
8862   GParamSpec   *pspec)
8863 {
8864   ObjectProxy *object = OBJECT_PROXY (gobject);
8865   GDBusInterface *interface;
8866
8867   switch (prop_id)
8868     {
8869     case 1:
8870       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface");
8871       g_value_take_object (value, interface);
8872       break;
8873
8874     case 2:
8875       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface");
8876       g_value_take_object (value, interface);
8877       break;
8878
8879     case 3:
8880       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager");
8881       g_value_take_object (value, interface);
8882       break;
8883
8884     default:
8885       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
8886       break;
8887   }
8888 }
8889
8890 static void
8891 object_proxy_class_init (ObjectProxyClass *klass)
8892 {
8893   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
8894
8895   gobject_class->set_property = object_proxy_set_property;
8896   gobject_class->get_property = object_proxy_get_property;
8897
8898   g_object_class_override_property (gobject_class, 1, "audiomanager-commandinterface");
8899   g_object_class_override_property (gobject_class, 2, "audiomanager-routinginterface");
8900   g_object_class_override_property (gobject_class, 3, "audiomanager-routing-soundmanager");
8901 }
8902
8903 /**
8904  * object_proxy_new:
8905  * @connection: A #GDBusConnection.
8906  * @object_path: An object path.
8907  *
8908  * Creates a new proxy object.
8909  *
8910  * Returns: (transfer full): The proxy object.
8911  */
8912 ObjectProxy *
8913 object_proxy_new (GDBusConnection *connection,
8914   const gchar *object_path)
8915 {
8916   g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
8917   g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
8918   return OBJECT_PROXY (g_object_new (TYPE_OBJECT_PROXY, "g-connection", connection, "g-object-path", object_path, NULL));
8919 }
8920
8921 /**
8922  * ObjectSkeleton:
8923  *
8924  * The #ObjectSkeleton structure contains only private data and should only be accessed using the provided API.
8925  */
8926
8927 /**
8928  * ObjectSkeletonClass:
8929  * @parent_class: The parent class.
8930  *
8931  * Class structure for #ObjectSkeleton.
8932  */
8933
8934 static void
8935 object_skeleton__object_iface_init (ObjectIface *iface G_GNUC_UNUSED)
8936 {
8937 }
8938
8939
8940 static void
8941 object_skeleton__g_dbus_object_iface_init (GDBusObjectIface *iface)
8942 {
8943   iface->interface_added = object_notify;
8944   iface->interface_removed = object_notify;
8945 }
8946
8947 G_DEFINE_TYPE_WITH_CODE (ObjectSkeleton, object_skeleton, G_TYPE_DBUS_OBJECT_SKELETON,
8948                          G_IMPLEMENT_INTERFACE (TYPE_OBJECT, object_skeleton__object_iface_init)
8949                          G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, object_skeleton__g_dbus_object_iface_init));
8950
8951 static void
8952 object_skeleton_init (ObjectSkeleton *object G_GNUC_UNUSED)
8953 {
8954 }
8955
8956 static void
8957 object_skeleton_set_property (GObject      *gobject,
8958   guint         prop_id,
8959   const GValue *value,
8960   GParamSpec   *pspec)
8961 {
8962   ObjectSkeleton *object = OBJECT_SKELETON (gobject);
8963   GDBusInterfaceSkeleton *interface;
8964
8965   switch (prop_id)
8966     {
8967     case 1:
8968       interface = g_value_get_object (value);
8969       if (interface != NULL)
8970         {
8971           g_warn_if_fail (IS_AUDIOMANAGER_COMMANDINTERFACE (interface));
8972           g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
8973         }
8974       else
8975         {
8976           g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.commandinterface");
8977         }
8978       break;
8979
8980     case 2:
8981       interface = g_value_get_object (value);
8982       if (interface != NULL)
8983         {
8984           g_warn_if_fail (IS_AUDIOMANAGER_ROUTINGINTERFACE (interface));
8985           g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
8986         }
8987       else
8988         {
8989           g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.routinginterface");
8990         }
8991       break;
8992
8993     case 3:
8994       interface = g_value_get_object (value);
8995       if (interface != NULL)
8996         {
8997           g_warn_if_fail (IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER (interface));
8998           g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
8999         }
9000       else
9001         {
9002           g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.routing.soundmanager");
9003         }
9004       break;
9005
9006     default:
9007       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
9008       break;
9009   }
9010 }
9011
9012 static void
9013 object_skeleton_get_property (GObject      *gobject,
9014   guint         prop_id,
9015   GValue       *value,
9016   GParamSpec   *pspec)
9017 {
9018   ObjectSkeleton *object = OBJECT_SKELETON (gobject);
9019   GDBusInterface *interface;
9020
9021   switch (prop_id)
9022     {
9023     case 1:
9024       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface");
9025       g_value_take_object (value, interface);
9026       break;
9027
9028     case 2:
9029       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface");
9030       g_value_take_object (value, interface);
9031       break;
9032
9033     case 3:
9034       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager");
9035       g_value_take_object (value, interface);
9036       break;
9037
9038     default:
9039       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
9040       break;
9041   }
9042 }
9043
9044 static void
9045 object_skeleton_class_init (ObjectSkeletonClass *klass)
9046 {
9047   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
9048
9049   gobject_class->set_property = object_skeleton_set_property;
9050   gobject_class->get_property = object_skeleton_get_property;
9051
9052   g_object_class_override_property (gobject_class, 1, "audiomanager-commandinterface");
9053   g_object_class_override_property (gobject_class, 2, "audiomanager-routinginterface");
9054   g_object_class_override_property (gobject_class, 3, "audiomanager-routing-soundmanager");
9055 }
9056
9057 /**
9058  * object_skeleton_new:
9059  * @object_path: An object path.
9060  *
9061  * Creates a new skeleton object.
9062  *
9063  * Returns: (transfer full): The skeleton object.
9064  */
9065 ObjectSkeleton *
9066 object_skeleton_new (const gchar *object_path)
9067 {
9068   g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
9069   return OBJECT_SKELETON (g_object_new (TYPE_OBJECT_SKELETON, "g-object-path", object_path, NULL));
9070 }
9071
9072 /**
9073  * object_skeleton_set_audiomanager_commandinterface:
9074  * @object: A #ObjectSkeleton.
9075  * @interface_: (allow-none): A #AudiomanagerCommandinterface or %NULL to clear the interface.
9076  *
9077  * Sets the #AudiomanagerCommandinterface instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-commandinterface.top_of_page">org.genivi.audiomanager.commandinterface</link> on @object.
9078  */
9079 void object_skeleton_set_audiomanager_commandinterface (ObjectSkeleton *object, AudiomanagerCommandinterface *interface_)
9080 {
9081   g_object_set (G_OBJECT (object), "audiomanager-commandinterface", interface_, NULL);
9082 }
9083
9084 /**
9085  * object_skeleton_set_audiomanager_routinginterface:
9086  * @object: A #ObjectSkeleton.
9087  * @interface_: (allow-none): A #AudiomanagerRoutinginterface or %NULL to clear the interface.
9088  *
9089  * Sets the #AudiomanagerRoutinginterface instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routinginterface.top_of_page">org.genivi.audiomanager.routinginterface</link> on @object.
9090  */
9091 void object_skeleton_set_audiomanager_routinginterface (ObjectSkeleton *object, AudiomanagerRoutinginterface *interface_)
9092 {
9093   g_object_set (G_OBJECT (object), "audiomanager-routinginterface", interface_, NULL);
9094 }
9095
9096 /**
9097  * object_skeleton_set_audiomanager_routing_soundmanager:
9098  * @object: A #ObjectSkeleton.
9099  * @interface_: (allow-none): A #AudiomanagerRoutingSoundmanager or %NULL to clear the interface.
9100  *
9101  * Sets the #AudiomanagerRoutingSoundmanager instance for the D-Bus interface <link linkend="gdbus-interface-org-genivi-audiomanager-routing-soundmanager.top_of_page">org.genivi.audiomanager.routing.soundmanager</link> on @object.
9102  */
9103 void object_skeleton_set_audiomanager_routing_soundmanager (ObjectSkeleton *object, AudiomanagerRoutingSoundmanager *interface_)
9104 {
9105   g_object_set (G_OBJECT (object), "audiomanager-routing-soundmanager", interface_, NULL);
9106 }
9107
9108
9109 /* ------------------------------------------------------------------------
9110  * Code for ObjectManager client
9111  * ------------------------------------------------------------------------
9112  */
9113
9114 /**
9115  * SECTION:ObjectManagerClient
9116  * @title: ObjectManagerClient
9117  * @short_description: Generated GDBusObjectManagerClient type
9118  *
9119  * This section contains a #GDBusObjectManagerClient that uses object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc.
9120  */
9121
9122 /**
9123  * ObjectManagerClient:
9124  *
9125  * The #ObjectManagerClient structure contains only private data and should only be accessed using the provided API.
9126  */
9127
9128 /**
9129  * ObjectManagerClientClass:
9130  * @parent_class: The parent class.
9131  *
9132  * Class structure for #ObjectManagerClient.
9133  */
9134
9135 G_DEFINE_TYPE (ObjectManagerClient, object_manager_client, G_TYPE_DBUS_OBJECT_MANAGER_CLIENT);
9136
9137 static void
9138 object_manager_client_init (ObjectManagerClient *manager G_GNUC_UNUSED)
9139 {
9140 }
9141
9142 static void
9143 object_manager_client_class_init (ObjectManagerClientClass *klass G_GNUC_UNUSED)
9144 {
9145 }
9146
9147 /**
9148  * object_manager_client_get_proxy_type:
9149  * @manager: A #GDBusObjectManagerClient.
9150  * @object_path: The object path of the remote object (unused).
9151  * @interface_name: (allow-none): Interface name of the remote object or %NULL to get the object proxy #GType.
9152  * @user_data: User data (unused).
9153  *
9154  * A #GDBusProxyTypeFunc that maps @interface_name to the generated #GDBusObjectProxy<!-- -->- and #GDBusProxy<!-- -->-derived types.
9155  *
9156  * Returns: A #GDBusProxy<!-- -->-derived #GType if @interface_name is not %NULL, otherwise the #GType for #ObjectProxy.
9157  */
9158 GType
9159 object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager G_GNUC_UNUSED, const gchar *object_path G_GNUC_UNUSED, const gchar *interface_name, gpointer user_data G_GNUC_UNUSED)
9160 {
9161   static gsize once_init_value = 0;
9162   static GHashTable *lookup_hash;
9163   GType ret;
9164
9165   if (interface_name == NULL)
9166     return TYPE_OBJECT_PROXY;
9167   if (g_once_init_enter (&once_init_value))
9168     {
9169       lookup_hash = g_hash_table_new (g_str_hash, g_str_equal);
9170       g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.commandinterface", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY));
9171       g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.routinginterface", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY));
9172       g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.routing.soundmanager", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY));
9173       g_once_init_leave (&once_init_value, 1);
9174     }
9175   ret = (GType) GPOINTER_TO_SIZE (g_hash_table_lookup (lookup_hash, interface_name));
9176   if (ret == (GType) 0)
9177     ret = G_TYPE_DBUS_PROXY;
9178   return ret;
9179 }
9180
9181 /**
9182  * object_manager_client_new:
9183  * @connection: A #GDBusConnection.
9184  * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
9185  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
9186  * @object_path: An object path.
9187  * @cancellable: (allow-none): A #GCancellable or %NULL.
9188  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
9189  * @user_data: User data to pass to @callback.
9190  *
9191  * Asynchronously creates #GDBusObjectManagerClient using object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new() for more details.
9192  *
9193  * 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.
9194  * You can then call object_manager_client_new_finish() to get the result of the operation.
9195  *
9196  * See object_manager_client_new_sync() for the synchronous, blocking version of this constructor.
9197  */
9198 void
9199 object_manager_client_new (
9200     GDBusConnection        *connection,
9201     GDBusObjectManagerClientFlags  flags,
9202     const gchar            *name,
9203     const gchar            *object_path,
9204     GCancellable           *cancellable,
9205     GAsyncReadyCallback     callback,
9206     gpointer                user_data)
9207 {
9208   g_async_initable_new_async (TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL);
9209 }
9210
9211 /**
9212  * object_manager_client_new_finish:
9213  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to object_manager_client_new().
9214  * @error: Return location for error or %NULL
9215  *
9216  * Finishes an operation started with object_manager_client_new().
9217  *
9218  * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set.
9219  */
9220 GDBusObjectManager *
9221 object_manager_client_new_finish (
9222     GAsyncResult        *res,
9223     GError             **error)
9224 {
9225   GObject *ret;
9226   GObject *source_object;
9227   source_object = g_async_result_get_source_object (res);
9228   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
9229   g_object_unref (source_object);
9230   if (ret != NULL)
9231     return G_DBUS_OBJECT_MANAGER (ret);
9232   else
9233     return NULL;
9234 }
9235
9236 /**
9237  * object_manager_client_new_sync:
9238  * @connection: A #GDBusConnection.
9239  * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
9240  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
9241  * @object_path: An object path.
9242  * @cancellable: (allow-none): A #GCancellable or %NULL.
9243  * @error: Return location for error or %NULL
9244  *
9245  * Synchronously creates #GDBusObjectManagerClient using object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new_sync() for more details.
9246  *
9247  * The calling thread is blocked until a reply is received.
9248  *
9249  * See object_manager_client_new() for the asynchronous version of this constructor.
9250  *
9251  * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set.
9252  */
9253 GDBusObjectManager *
9254 object_manager_client_new_sync (
9255     GDBusConnection        *connection,
9256     GDBusObjectManagerClientFlags  flags,
9257     const gchar            *name,
9258     const gchar            *object_path,
9259     GCancellable           *cancellable,
9260     GError                **error)
9261 {
9262   GInitable *ret;
9263   ret = g_initable_new (TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL);
9264   if (ret != NULL)
9265     return G_DBUS_OBJECT_MANAGER (ret);
9266   else
9267     return NULL;
9268 }
9269
9270
9271 /**
9272  * object_manager_client_new_for_bus:
9273  * @bus_type: A #GBusType.
9274  * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
9275  * @name: A bus name (well-known or unique).
9276  * @object_path: An object path.
9277  * @cancellable: (allow-none): A #GCancellable or %NULL.
9278  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
9279  * @user_data: User data to pass to @callback.
9280  *
9281  * Like object_manager_client_new() but takes a #GBusType instead of a #GDBusConnection.
9282  *
9283  * 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.
9284  * You can then call object_manager_client_new_for_bus_finish() to get the result of the operation.
9285  *
9286  * See object_manager_client_new_for_bus_sync() for the synchronous, blocking version of this constructor.
9287  */
9288 void
9289 object_manager_client_new_for_bus (
9290     GBusType                bus_type,
9291     GDBusObjectManagerClientFlags  flags,
9292     const gchar            *name,
9293     const gchar            *object_path,
9294     GCancellable           *cancellable,
9295     GAsyncReadyCallback     callback,
9296     gpointer                user_data)
9297 {
9298   g_async_initable_new_async (TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL);
9299 }
9300
9301 /**
9302  * object_manager_client_new_for_bus_finish:
9303  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to object_manager_client_new_for_bus().
9304  * @error: Return location for error or %NULL
9305  *
9306  * Finishes an operation started with object_manager_client_new_for_bus().
9307  *
9308  * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set.
9309  */
9310 GDBusObjectManager *
9311 object_manager_client_new_for_bus_finish (
9312     GAsyncResult        *res,
9313     GError             **error)
9314 {
9315   GObject *ret;
9316   GObject *source_object;
9317   source_object = g_async_result_get_source_object (res);
9318   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
9319   g_object_unref (source_object);
9320   if (ret != NULL)
9321     return G_DBUS_OBJECT_MANAGER (ret);
9322   else
9323     return NULL;
9324 }
9325
9326 /**
9327  * object_manager_client_new_for_bus_sync:
9328  * @bus_type: A #GBusType.
9329  * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
9330  * @name: A bus name (well-known or unique).
9331  * @object_path: An object path.
9332  * @cancellable: (allow-none): A #GCancellable or %NULL.
9333  * @error: Return location for error or %NULL
9334  *
9335  * Like object_manager_client_new_sync() but takes a #GBusType instead of a #GDBusConnection.
9336  *
9337  * The calling thread is blocked until a reply is received.
9338  *
9339  * See object_manager_client_new_for_bus() for the asynchronous version of this constructor.
9340  *
9341  * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set.
9342  */
9343 GDBusObjectManager *
9344 object_manager_client_new_for_bus_sync (
9345     GBusType                bus_type,
9346     GDBusObjectManagerClientFlags  flags,
9347     const gchar            *name,
9348     const gchar            *object_path,
9349     GCancellable           *cancellable,
9350     GError                **error)
9351 {
9352   GInitable *ret;
9353   ret = g_initable_new (TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL);
9354   if (ret != NULL)
9355     return G_DBUS_OBJECT_MANAGER (ret);
9356   else
9357     return NULL;
9358 }
9359
9360