soundmanager_binging/dbus/audio_manager_interface.h

   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 #ifndef __AUDIO_MANAGER_INTERFACE_H__
   8 #define __AUDIO_MANAGER_INTERFACE_H__
   9
  10 #include <gio/gio.h>
  11
  12 G_BEGIN_DECLS
  13
  14
  15 /* ------------------------------------------------------------------------ */
  16 /* Declarations for org.genivi.audiomanager.commandinterface */
  17
  18 #define TYPE_AUDIOMANAGER_COMMANDINTERFACE (audiomanager_commandinterface_get_type ())
  19 #define AUDIOMANAGER_COMMANDINTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE, AudiomanagerCommandinterface))
  20 #define IS_AUDIOMANAGER_COMMANDINTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE))
  21 #define AUDIOMANAGER_COMMANDINTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE, AudiomanagerCommandinterfaceIface))
  22
  23 struct _AudiomanagerCommandinterface;
  24 typedef struct _AudiomanagerCommandinterface AudiomanagerCommandinterface;
  25 typedef struct _AudiomanagerCommandinterfaceIface AudiomanagerCommandinterfaceIface;
  26
  27 struct _AudiomanagerCommandinterfaceIface
  28 {
  29   GTypeInterface parent_iface;
  30
  31
  32   gboolean (*handle_connect) (
  33     AudiomanagerCommandinterface *object,
  34     GDBusMethodInvocation *invocation,
  35     guint16 arg_sourceID,
  36     guint16 arg_sinkID);
  37
  38   gboolean (*handle_disconnect) (
  39     AudiomanagerCommandinterface *object,
  40     GDBusMethodInvocation *invocation,
  41     guint16 arg_mainConnectionID);
  42
  43   gboolean (*handle_get_list_main_connections) (
  44     AudiomanagerCommandinterface *object,
  45     GDBusMethodInvocation *invocation);
  46
  47   gboolean (*handle_set_sink_mute_state) (
  48     AudiomanagerCommandinterface *object,
  49     GDBusMethodInvocation *invocation,
  50     guint16 arg_sinkID,
  51     gint16 arg_muteState);
  52
  53   gboolean (*handle_set_volume) (
  54     AudiomanagerCommandinterface *object,
  55     GDBusMethodInvocation *invocation,
  56     guint16 arg_sinkID,
  57     gint16 arg_volume);
  58
  59   gboolean (*handle_volume_step) (
  60     AudiomanagerCommandinterface *object,
  61     GDBusMethodInvocation *invocation,
  62     guint16 arg_sinkID,
  63     gint16 arg_volumeStep);
  64
  65   void (*main_connection_state_changed) (
  66     AudiomanagerCommandinterface *object,
  67     guint16 arg_connectionID,
  68     gint16 arg_connectionState);
  69
  70   void (*new_main_connection) (
  71     AudiomanagerCommandinterface *object,
  72     GVariant *arg_mainConnection);
  73
  74   void (*removed_main_connection) (
  75     AudiomanagerCommandinterface *object,
  76     guint16 arg_mainConnectionId);
  77
  78   void (*sink_mute_state_changed) (
  79     AudiomanagerCommandinterface *object,
  80     guint16 arg_sinkID,
  81     gint16 arg_muteState);
  82
  83   void (*system_property_changed) (
  84     AudiomanagerCommandinterface *object,
  85     GVariant *arg_SystemProperty);
  86
  87   void (*volume_changed) (
  88     AudiomanagerCommandinterface *object,
  89     guint16 arg_sinkID,
  90     gint16 arg_volume);
  91
  92 };
  93
  94 GType audiomanager_commandinterface_get_type (void) G_GNUC_CONST;
  95
  96 GDBusInterfaceInfo *audiomanager_commandinterface_interface_info (void);
  97 guint audiomanager_commandinterface_override_properties (GObjectClass *klass, guint property_id_begin);
  98
  99
 100 /* D-Bus method call completion functions: */
 101 void audiomanager_commandinterface_complete_connect (
 102     AudiomanagerCommandinterface *object,
 103     GDBusMethodInvocation *invocation,
 104     gint16 result,
 105     guint16 mainConnectionID);
 106
 107 void audiomanager_commandinterface_complete_disconnect (
 108     AudiomanagerCommandinterface *object,
 109     GDBusMethodInvocation *invocation,
 110     gint16 result);
 111
 112 void audiomanager_commandinterface_complete_set_volume (
 113     AudiomanagerCommandinterface *object,
 114     GDBusMethodInvocation *invocation,
 115     gint16 result);
 116
 117 void audiomanager_commandinterface_complete_volume_step (
 118     AudiomanagerCommandinterface *object,
 119     GDBusMethodInvocation *invocation,
 120     gint16 result);
 121
 122 void audiomanager_commandinterface_complete_set_sink_mute_state (
 123     AudiomanagerCommandinterface *object,
 124     GDBusMethodInvocation *invocation,
 125     gint16 result);
 126
 127 void audiomanager_commandinterface_complete_get_list_main_connections (
 128     AudiomanagerCommandinterface *object,
 129     GDBusMethodInvocation *invocation,
 130     gint16 result,
 131     GVariant *listConnections);
 132
 133
 134
 135 /* D-Bus signal emissions functions: */
 136 void audiomanager_commandinterface_emit_new_main_connection (
 137     AudiomanagerCommandinterface *object,
 138     GVariant *arg_mainConnection);
 139
 140 void audiomanager_commandinterface_emit_removed_main_connection (
 141     AudiomanagerCommandinterface *object,
 142     guint16 arg_mainConnectionId);
 143
 144 void audiomanager_commandinterface_emit_main_connection_state_changed (
 145     AudiomanagerCommandinterface *object,
 146     guint16 arg_connectionID,
 147     gint16 arg_connectionState);
 148
 149 void audiomanager_commandinterface_emit_volume_changed (
 150     AudiomanagerCommandinterface *object,
 151     guint16 arg_sinkID,
 152     gint16 arg_volume);
 153
 154 void audiomanager_commandinterface_emit_sink_mute_state_changed (
 155     AudiomanagerCommandinterface *object,
 156     guint16 arg_sinkID,
 157     gint16 arg_muteState);
 158
 159 void audiomanager_commandinterface_emit_system_property_changed (
 160     AudiomanagerCommandinterface *object,
 161     GVariant *arg_SystemProperty);
 162
 163
 164
 165 /* D-Bus method calls: */
 166 void audiomanager_commandinterface_call_connect (
 167     AudiomanagerCommandinterface *proxy,
 168     guint16 arg_sourceID,
 169     guint16 arg_sinkID,
 170     GCancellable *cancellable,
 171     GAsyncReadyCallback callback,
 172     gpointer user_data);
 173
 174 gboolean audiomanager_commandinterface_call_connect_finish (
 175     AudiomanagerCommandinterface *proxy,
 176     gint16 *out_result,
 177     guint16 *out_mainConnectionID,
 178     GAsyncResult *res,
 179     GError **error);
 180
 181 gboolean audiomanager_commandinterface_call_connect_sync (
 182     AudiomanagerCommandinterface *proxy,
 183     guint16 arg_sourceID,
 184     guint16 arg_sinkID,
 185     gint16 *out_result,
 186     guint16 *out_mainConnectionID,
 187     GCancellable *cancellable,
 188     GError **error);
 189
 190 void audiomanager_commandinterface_call_disconnect (
 191     AudiomanagerCommandinterface *proxy,
 192     guint16 arg_mainConnectionID,
 193     GCancellable *cancellable,
 194     GAsyncReadyCallback callback,
 195     gpointer user_data);
 196
 197 gboolean audiomanager_commandinterface_call_disconnect_finish (
 198     AudiomanagerCommandinterface *proxy,
 199     gint16 *out_result,
 200     GAsyncResult *res,
 201     GError **error);
 202
 203 gboolean audiomanager_commandinterface_call_disconnect_sync (
 204     AudiomanagerCommandinterface *proxy,
 205     guint16 arg_mainConnectionID,
 206     gint16 *out_result,
 207     GCancellable *cancellable,
 208     GError **error);
 209
 210 void audiomanager_commandinterface_call_set_volume (
 211     AudiomanagerCommandinterface *proxy,
 212     guint16 arg_sinkID,
 213     gint16 arg_volume,
 214     GCancellable *cancellable,
 215     GAsyncReadyCallback callback,
 216     gpointer user_data);
 217
 218 gboolean audiomanager_commandinterface_call_set_volume_finish (
 219     AudiomanagerCommandinterface *proxy,
 220     gint16 *out_result,
 221     GAsyncResult *res,
 222     GError **error);
 223
 224 gboolean audiomanager_commandinterface_call_set_volume_sync (
 225     AudiomanagerCommandinterface *proxy,
 226     guint16 arg_sinkID,
 227     gint16 arg_volume,
 228     gint16 *out_result,
 229     GCancellable *cancellable,
 230     GError **error);
 231
 232 void audiomanager_commandinterface_call_volume_step (
 233     AudiomanagerCommandinterface *proxy,
 234     guint16 arg_sinkID,
 235     gint16 arg_volumeStep,
 236     GCancellable *cancellable,
 237     GAsyncReadyCallback callback,
 238     gpointer user_data);
 239
 240 gboolean audiomanager_commandinterface_call_volume_step_finish (
 241     AudiomanagerCommandinterface *proxy,
 242     gint16 *out_result,
 243     GAsyncResult *res,
 244     GError **error);
 245
 246 gboolean audiomanager_commandinterface_call_volume_step_sync (
 247     AudiomanagerCommandinterface *proxy,
 248     guint16 arg_sinkID,
 249     gint16 arg_volumeStep,
 250     gint16 *out_result,
 251     GCancellable *cancellable,
 252     GError **error);
 253
 254 void audiomanager_commandinterface_call_set_sink_mute_state (
 255     AudiomanagerCommandinterface *proxy,
 256     guint16 arg_sinkID,
 257     gint16 arg_muteState,
 258     GCancellable *cancellable,
 259     GAsyncReadyCallback callback,
 260     gpointer user_data);
 261
 262 gboolean audiomanager_commandinterface_call_set_sink_mute_state_finish (
 263     AudiomanagerCommandinterface *proxy,
 264     gint16 *out_result,
 265     GAsyncResult *res,
 266     GError **error);
 267
 268 gboolean audiomanager_commandinterface_call_set_sink_mute_state_sync (
 269     AudiomanagerCommandinterface *proxy,
 270     guint16 arg_sinkID,
 271     gint16 arg_muteState,
 272     gint16 *out_result,
 273     GCancellable *cancellable,
 274     GError **error);
 275
 276 void audiomanager_commandinterface_call_get_list_main_connections (
 277     AudiomanagerCommandinterface *proxy,
 278     GCancellable *cancellable,
 279     GAsyncReadyCallback callback,
 280     gpointer user_data);
 281
 282 gboolean audiomanager_commandinterface_call_get_list_main_connections_finish (
 283     AudiomanagerCommandinterface *proxy,
 284     gint16 *out_result,
 285     GVariant **out_listConnections,
 286     GAsyncResult *res,
 287     GError **error);
 288
 289 gboolean audiomanager_commandinterface_call_get_list_main_connections_sync (
 290     AudiomanagerCommandinterface *proxy,
 291     gint16 *out_result,
 292     GVariant **out_listConnections,
 293     GCancellable *cancellable,
 294     GError **error);
 295
 296
 297
 298 /* ---- */
 299
 300 #define TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY (audiomanager_commandinterface_proxy_get_type ())
 301 #define AUDIOMANAGER_COMMANDINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxy))
 302 #define AUDIOMANAGER_COMMANDINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyClass))
 303 #define AUDIOMANAGER_COMMANDINTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyClass))
 304 #define IS_AUDIOMANAGER_COMMANDINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY))
 305 #define IS_AUDIOMANAGER_COMMANDINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY))
 306
 307 typedef struct _AudiomanagerCommandinterfaceProxy AudiomanagerCommandinterfaceProxy;
 308 typedef struct _AudiomanagerCommandinterfaceProxyClass AudiomanagerCommandinterfaceProxyClass;
 309 typedef struct _AudiomanagerCommandinterfaceProxyPrivate AudiomanagerCommandinterfaceProxyPrivate;
 310
 311 struct _AudiomanagerCommandinterfaceProxy
 312 {
 313   /*< private >*/
 314   GDBusProxy parent_instance;
 315   AudiomanagerCommandinterfaceProxyPrivate *priv;
 316 };
 317
 318 struct _AudiomanagerCommandinterfaceProxyClass
 319 {
 320   GDBusProxyClass parent_class;
 321 };
 322
 323 GType audiomanager_commandinterface_proxy_get_type (void) G_GNUC_CONST;
 324
 325 #if GLIB_CHECK_VERSION(2, 44, 0)
 326 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerCommandinterfaceProxy, g_object_unref)
 327 #endif
 328
 329 void audiomanager_commandinterface_proxy_new (
 330     GDBusConnection     *connection,
 331     GDBusProxyFlags      flags,
 332     const gchar         *name,
 333     const gchar         *object_path,
 334     GCancellable        *cancellable,
 335     GAsyncReadyCallback  callback,
 336     gpointer             user_data);
 337 AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_finish (
 338     GAsyncResult        *res,
 339     GError             **error);
 340 AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_sync (
 341     GDBusConnection     *connection,
 342     GDBusProxyFlags      flags,
 343     const gchar         *name,
 344     const gchar         *object_path,
 345     GCancellable        *cancellable,
 346     GError             **error);
 347
 348 void audiomanager_commandinterface_proxy_new_for_bus (
 349     GBusType             bus_type,
 350     GDBusProxyFlags      flags,
 351     const gchar         *name,
 352     const gchar         *object_path,
 353     GCancellable        *cancellable,
 354     GAsyncReadyCallback  callback,
 355     gpointer             user_data);
 356 AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_for_bus_finish (
 357     GAsyncResult        *res,
 358     GError             **error);
 359 AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_for_bus_sync (
 360     GBusType             bus_type,
 361     GDBusProxyFlags      flags,
 362     const gchar         *name,
 363     const gchar         *object_path,
 364     GCancellable        *cancellable,
 365     GError             **error);
 366
 367
 368 /* ---- */
 369
 370 #define TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON (audiomanager_commandinterface_skeleton_get_type ())
 371 #define AUDIOMANAGER_COMMANDINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeleton))
 372 #define AUDIOMANAGER_COMMANDINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonClass))
 373 #define AUDIOMANAGER_COMMANDINTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonClass))
 374 #define IS_AUDIOMANAGER_COMMANDINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON))
 375 #define IS_AUDIOMANAGER_COMMANDINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON))
 376
 377 typedef struct _AudiomanagerCommandinterfaceSkeleton AudiomanagerCommandinterfaceSkeleton;
 378 typedef struct _AudiomanagerCommandinterfaceSkeletonClass AudiomanagerCommandinterfaceSkeletonClass;
 379 typedef struct _AudiomanagerCommandinterfaceSkeletonPrivate AudiomanagerCommandinterfaceSkeletonPrivate;
 380
 381 struct _AudiomanagerCommandinterfaceSkeleton
 382 {
 383   /*< private >*/
 384   GDBusInterfaceSkeleton parent_instance;
 385   AudiomanagerCommandinterfaceSkeletonPrivate *priv;
 386 };
 387
 388 struct _AudiomanagerCommandinterfaceSkeletonClass
 389 {
 390   GDBusInterfaceSkeletonClass parent_class;
 391 };
 392
 393 GType audiomanager_commandinterface_skeleton_get_type (void) G_GNUC_CONST;
 394
 395 #if GLIB_CHECK_VERSION(2, 44, 0)
 396 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerCommandinterfaceSkeleton, g_object_unref)
 397 #endif
 398
 399 AudiomanagerCommandinterface *audiomanager_commandinterface_skeleton_new (void);
 400
 401
 402 /* ------------------------------------------------------------------------ */
 403 /* Declarations for org.genivi.audiomanager.routinginterface */
 404
 405 #define TYPE_AUDIOMANAGER_ROUTINGINTERFACE (audiomanager_routinginterface_get_type ())
 406 #define AUDIOMANAGER_ROUTINGINTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE, AudiomanagerRoutinginterface))
 407 #define IS_AUDIOMANAGER_ROUTINGINTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE))
 408 #define AUDIOMANAGER_ROUTINGINTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE, AudiomanagerRoutinginterfaceIface))
 409
 410 struct _AudiomanagerRoutinginterface;
 411 typedef struct _AudiomanagerRoutinginterface AudiomanagerRoutinginterface;
 412 typedef struct _AudiomanagerRoutinginterfaceIface AudiomanagerRoutinginterfaceIface;
 413
 414 struct _AudiomanagerRoutinginterfaceIface
 415 {
 416   GTypeInterface parent_iface;
 417
 418
 419   gboolean (*handle_ack_connect) (
 420     AudiomanagerRoutinginterface *object,
 421     GDBusMethodInvocation *invocation,
 422     guint16 arg_handle,
 423     guint16 arg_connectionID,
 424     guint16 arg_error);
 425
 426   gboolean (*handle_ack_disconnect) (
 427     AudiomanagerRoutinginterface *object,
 428     GDBusMethodInvocation *invocation,
 429     guint16 arg_handle,
 430     guint16 arg_connectionID,
 431     guint16 arg_error);
 432
 433   gboolean (*handle_ack_set_sink_volume) (
 434     AudiomanagerRoutinginterface *object,
 435     GDBusMethodInvocation *invocation,
 436     guint16 arg_handle,
 437     gint16 arg_volume,
 438     guint16 arg_error);
 439
 440   gboolean (*handle_ack_set_source_state) (
 441     AudiomanagerRoutinginterface *object,
 442     GDBusMethodInvocation *invocation,
 443     guint16 arg_handle,
 444     guint16 arg_error);
 445
 446   gboolean (*handle_ack_set_volumes) (
 447     AudiomanagerRoutinginterface *object,
 448     GDBusMethodInvocation *invocation,
 449     guint16 arg_handle,
 450     GVariant *arg_listvolumes,
 451     guint16 arg_error);
 452
 453   gboolean (*handle_ack_sink_notification_configuration) (
 454     AudiomanagerRoutinginterface *object,
 455     GDBusMethodInvocation *invocation,
 456     guint16 arg_handle,
 457     guint16 arg_error);
 458
 459   gboolean (*handle_ack_source_notification_configuration) (
 460     AudiomanagerRoutinginterface *object,
 461     GDBusMethodInvocation *invocation,
 462     guint16 arg_handle,
 463     guint16 arg_error);
 464
 465   gboolean (*handle_confirm_routing_ready) (
 466     AudiomanagerRoutinginterface *object,
 467     GDBusMethodInvocation *invocation,
 468     guint16 arg_domainID);
 469
 470   gboolean (*handle_confirm_routing_rundown) (
 471     AudiomanagerRoutinginterface *object,
 472     GDBusMethodInvocation *invocation,
 473     guint16 arg_domainID);
 474
 475   gboolean (*handle_deregister_sink) (
 476     AudiomanagerRoutinginterface *object,
 477     GDBusMethodInvocation *invocation,
 478     guint16 arg_sinkID);
 479
 480   gboolean (*handle_deregister_source) (
 481     AudiomanagerRoutinginterface *object,
 482     GDBusMethodInvocation *invocation,
 483     guint16 arg_sourceID);
 484
 485   gboolean (*handle_hook_interrupt_status_change) (
 486     AudiomanagerRoutinginterface *object,
 487     GDBusMethodInvocation *invocation,
 488     guint16 arg_sourceID,
 489     guint16 arg_interruptState);
 490
 491   gboolean (*handle_hook_source_availablity_status_change) (
 492     AudiomanagerRoutinginterface *object,
 493     GDBusMethodInvocation *invocation,
 494     guint16 arg_sourceID,
 495     GVariant *arg_availability);
 496
 497   gboolean (*handle_register_domain) (
 498     AudiomanagerRoutinginterface *object,
 499     GDBusMethodInvocation *invocation,
 500     GVariant *arg_domaindata,
 501     const gchar *arg_returnBusname,
 502     const gchar *arg_returnPath,
 503     const gchar *arg_returnInterface);
 504
 505   gboolean (*handle_register_sink) (
 506     AudiomanagerRoutinginterface *object,
 507     GDBusMethodInvocation *invocation,
 508     GVariant *arg_sinkData);
 509
 510   gboolean (*handle_register_source) (
 511     AudiomanagerRoutinginterface *object,
 512     GDBusMethodInvocation *invocation,
 513     GVariant *arg_sourceData);
 514
 515   void (*set_routing_ready) (
 516     AudiomanagerRoutinginterface *object);
 517
 518   void (*set_routing_rundown) (
 519     AudiomanagerRoutinginterface *object);
 520
 521 };
 522
 523 GType audiomanager_routinginterface_get_type (void) G_GNUC_CONST;
 524
 525 GDBusInterfaceInfo *audiomanager_routinginterface_interface_info (void);
 526 guint audiomanager_routinginterface_override_properties (GObjectClass *klass, guint property_id_begin);
 527
 528
 529 /* D-Bus method call completion functions: */
 530 void audiomanager_routinginterface_complete_ack_connect (
 531     AudiomanagerRoutinginterface *object,
 532     GDBusMethodInvocation *invocation);
 533
 534 void audiomanager_routinginterface_complete_ack_disconnect (
 535     AudiomanagerRoutinginterface *object,
 536     GDBusMethodInvocation *invocation);
 537
 538 void audiomanager_routinginterface_complete_ack_set_source_state (
 539     AudiomanagerRoutinginterface *object,
 540     GDBusMethodInvocation *invocation);
 541
 542 void audiomanager_routinginterface_complete_ack_set_sink_volume (
 543     AudiomanagerRoutinginterface *object,
 544     GDBusMethodInvocation *invocation);
 545
 546 void audiomanager_routinginterface_complete_register_sink (
 547     AudiomanagerRoutinginterface *object,
 548     GDBusMethodInvocation *invocation,
 549     guint16 sinkID,
 550     guint16 error);
 551
 552 void audiomanager_routinginterface_complete_deregister_sink (
 553     AudiomanagerRoutinginterface *object,
 554     GDBusMethodInvocation *invocation,
 555     gint error);
 556
 557 void audiomanager_routinginterface_complete_register_source (
 558     AudiomanagerRoutinginterface *object,
 559     GDBusMethodInvocation *invocation,
 560     guint16 sourceID,
 561     guint16 error);
 562
 563 void audiomanager_routinginterface_complete_deregister_source (
 564     AudiomanagerRoutinginterface *object,
 565     GDBusMethodInvocation *invocation,
 566     guint16 error);
 567
 568 void audiomanager_routinginterface_complete_hook_interrupt_status_change (
 569     AudiomanagerRoutinginterface *object,
 570     GDBusMethodInvocation *invocation);
 571
 572 void audiomanager_routinginterface_complete_hook_source_availablity_status_change (
 573     AudiomanagerRoutinginterface *object,
 574     GDBusMethodInvocation *invocation);
 575
 576 void audiomanager_routinginterface_complete_confirm_routing_ready (
 577     AudiomanagerRoutinginterface *object,
 578     GDBusMethodInvocation *invocation);
 579
 580 void audiomanager_routinginterface_complete_confirm_routing_rundown (
 581     AudiomanagerRoutinginterface *object,
 582     GDBusMethodInvocation *invocation);
 583
 584 void audiomanager_routinginterface_complete_ack_set_volumes (
 585     AudiomanagerRoutinginterface *object,
 586     GDBusMethodInvocation *invocation);
 587
 588 void audiomanager_routinginterface_complete_ack_sink_notification_configuration (
 589     AudiomanagerRoutinginterface *object,
 590     GDBusMethodInvocation *invocation);
 591
 592 void audiomanager_routinginterface_complete_ack_source_notification_configuration (
 593     AudiomanagerRoutinginterface *object,
 594     GDBusMethodInvocation *invocation);
 595
 596 void audiomanager_routinginterface_complete_register_domain (
 597     AudiomanagerRoutinginterface *object,
 598     GDBusMethodInvocation *invocation,
 599     guint16 domainid,
 600     guint16 error);
 601
 602
 603
 604 /* D-Bus signal emissions functions: */
 605 void audiomanager_routinginterface_emit_set_routing_ready (
 606     AudiomanagerRoutinginterface *object);
 607
 608 void audiomanager_routinginterface_emit_set_routing_rundown (
 609     AudiomanagerRoutinginterface *object);
 610
 611
 612
 613 /* D-Bus method calls: */
 614 void audiomanager_routinginterface_call_ack_connect (
 615     AudiomanagerRoutinginterface *proxy,
 616     guint16 arg_handle,
 617     guint16 arg_connectionID,
 618     guint16 arg_error,
 619     GCancellable *cancellable,
 620     GAsyncReadyCallback callback,
 621     gpointer user_data);
 622
 623 gboolean audiomanager_routinginterface_call_ack_connect_finish (
 624     AudiomanagerRoutinginterface *proxy,
 625     GAsyncResult *res,
 626     GError **error);
 627
 628 gboolean audiomanager_routinginterface_call_ack_connect_sync (
 629     AudiomanagerRoutinginterface *proxy,
 630     guint16 arg_handle,
 631     guint16 arg_connectionID,
 632     guint16 arg_error,
 633     GCancellable *cancellable,
 634     GError **error);
 635
 636 void audiomanager_routinginterface_call_ack_disconnect (
 637     AudiomanagerRoutinginterface *proxy,
 638     guint16 arg_handle,
 639     guint16 arg_connectionID,
 640     guint16 arg_error,
 641     GCancellable *cancellable,
 642     GAsyncReadyCallback callback,
 643     gpointer user_data);
 644
 645 gboolean audiomanager_routinginterface_call_ack_disconnect_finish (
 646     AudiomanagerRoutinginterface *proxy,
 647     GAsyncResult *res,
 648     GError **error);
 649
 650 gboolean audiomanager_routinginterface_call_ack_disconnect_sync (
 651     AudiomanagerRoutinginterface *proxy,
 652     guint16 arg_handle,
 653     guint16 arg_connectionID,
 654     guint16 arg_error,
 655     GCancellable *cancellable,
 656     GError **error);
 657
 658 void audiomanager_routinginterface_call_ack_set_source_state (
 659     AudiomanagerRoutinginterface *proxy,
 660     guint16 arg_handle,
 661     guint16 arg_error,
 662     GCancellable *cancellable,
 663     GAsyncReadyCallback callback,
 664     gpointer user_data);
 665
 666 gboolean audiomanager_routinginterface_call_ack_set_source_state_finish (
 667     AudiomanagerRoutinginterface *proxy,
 668     GAsyncResult *res,
 669     GError **error);
 670
 671 gboolean audiomanager_routinginterface_call_ack_set_source_state_sync (
 672     AudiomanagerRoutinginterface *proxy,
 673     guint16 arg_handle,
 674     guint16 arg_error,
 675     GCancellable *cancellable,
 676     GError **error);
 677
 678 void audiomanager_routinginterface_call_ack_set_sink_volume (
 679     AudiomanagerRoutinginterface *proxy,
 680     guint16 arg_handle,
 681     gint16 arg_volume,
 682     guint16 arg_error,
 683     GCancellable *cancellable,
 684     GAsyncReadyCallback callback,
 685     gpointer user_data);
 686
 687 gboolean audiomanager_routinginterface_call_ack_set_sink_volume_finish (
 688     AudiomanagerRoutinginterface *proxy,
 689     GAsyncResult *res,
 690     GError **error);
 691
 692 gboolean audiomanager_routinginterface_call_ack_set_sink_volume_sync (
 693     AudiomanagerRoutinginterface *proxy,
 694     guint16 arg_handle,
 695     gint16 arg_volume,
 696     guint16 arg_error,
 697     GCancellable *cancellable,
 698     GError **error);
 699
 700 void audiomanager_routinginterface_call_register_sink (
 701     AudiomanagerRoutinginterface *proxy,
 702     GVariant *arg_sinkData,
 703     GCancellable *cancellable,
 704     GAsyncReadyCallback callback,
 705     gpointer user_data);
 706
 707 gboolean audiomanager_routinginterface_call_register_sink_finish (
 708     AudiomanagerRoutinginterface *proxy,
 709     guint16 *out_sinkID,
 710     guint16 *out_error,
 711     GAsyncResult *res,
 712     GError **error);
 713
 714 gboolean audiomanager_routinginterface_call_register_sink_sync (
 715     AudiomanagerRoutinginterface *proxy,
 716     GVariant *arg_sinkData,
 717     guint16 *out_sinkID,
 718     guint16 *out_error,
 719     GCancellable *cancellable,
 720     GError **error);
 721
 722 void audiomanager_routinginterface_call_deregister_sink (
 723     AudiomanagerRoutinginterface *proxy,
 724     guint16 arg_sinkID,
 725     GCancellable *cancellable,
 726     GAsyncReadyCallback callback,
 727     gpointer user_data);
 728
 729 gboolean audiomanager_routinginterface_call_deregister_sink_finish (
 730     AudiomanagerRoutinginterface *proxy,
 731     gint *out_error,
 732     GAsyncResult *res,
 733     GError **error);
 734
 735 gboolean audiomanager_routinginterface_call_deregister_sink_sync (
 736     AudiomanagerRoutinginterface *proxy,
 737     guint16 arg_sinkID,
 738     gint *out_error,
 739     GCancellable *cancellable,
 740     GError **error);
 741
 742 void audiomanager_routinginterface_call_register_source (
 743     AudiomanagerRoutinginterface *proxy,
 744     GVariant *arg_sourceData,
 745     GCancellable *cancellable,
 746     GAsyncReadyCallback callback,
 747     gpointer user_data);
 748
 749 gboolean audiomanager_routinginterface_call_register_source_finish (
 750     AudiomanagerRoutinginterface *proxy,
 751     guint16 *out_sourceID,
 752     guint16 *out_error,
 753     GAsyncResult *res,
 754     GError **error);
 755
 756 gboolean audiomanager_routinginterface_call_register_source_sync (
 757     AudiomanagerRoutinginterface *proxy,
 758     GVariant *arg_sourceData,
 759     guint16 *out_sourceID,
 760     guint16 *out_error,
 761     GCancellable *cancellable,
 762     GError **error);
 763
 764 void audiomanager_routinginterface_call_deregister_source (
 765     AudiomanagerRoutinginterface *proxy,
 766     guint16 arg_sourceID,
 767     GCancellable *cancellable,
 768     GAsyncReadyCallback callback,
 769     gpointer user_data);
 770
 771 gboolean audiomanager_routinginterface_call_deregister_source_finish (
 772     AudiomanagerRoutinginterface *proxy,
 773     guint16 *out_error,
 774     GAsyncResult *res,
 775     GError **error);
 776
 777 gboolean audiomanager_routinginterface_call_deregister_source_sync (
 778     AudiomanagerRoutinginterface *proxy,
 779     guint16 arg_sourceID,
 780     guint16 *out_error,
 781     GCancellable *cancellable,
 782     GError **error);
 783
 784 void audiomanager_routinginterface_call_hook_interrupt_status_change (
 785     AudiomanagerRoutinginterface *proxy,
 786     guint16 arg_sourceID,
 787     guint16 arg_interruptState,
 788     GCancellable *cancellable,
 789     GAsyncReadyCallback callback,
 790     gpointer user_data);
 791
 792 gboolean audiomanager_routinginterface_call_hook_interrupt_status_change_finish (
 793     AudiomanagerRoutinginterface *proxy,
 794     GAsyncResult *res,
 795     GError **error);
 796
 797 gboolean audiomanager_routinginterface_call_hook_interrupt_status_change_sync (
 798     AudiomanagerRoutinginterface *proxy,
 799     guint16 arg_sourceID,
 800     guint16 arg_interruptState,
 801     GCancellable *cancellable,
 802     GError **error);
 803
 804 void audiomanager_routinginterface_call_hook_source_availablity_status_change (
 805     AudiomanagerRoutinginterface *proxy,
 806     guint16 arg_sourceID,
 807     GVariant *arg_availability,
 808     GCancellable *cancellable,
 809     GAsyncReadyCallback callback,
 810     gpointer user_data);
 811
 812 gboolean audiomanager_routinginterface_call_hook_source_availablity_status_change_finish (
 813     AudiomanagerRoutinginterface *proxy,
 814     GAsyncResult *res,
 815     GError **error);
 816
 817 gboolean audiomanager_routinginterface_call_hook_source_availablity_status_change_sync (
 818     AudiomanagerRoutinginterface *proxy,
 819     guint16 arg_sourceID,
 820     GVariant *arg_availability,
 821     GCancellable *cancellable,
 822     GError **error);
 823
 824 void audiomanager_routinginterface_call_confirm_routing_ready (
 825     AudiomanagerRoutinginterface *proxy,
 826     guint16 arg_domainID,
 827     GCancellable *cancellable,
 828     GAsyncReadyCallback callback,
 829     gpointer user_data);
 830
 831 gboolean audiomanager_routinginterface_call_confirm_routing_ready_finish (
 832     AudiomanagerRoutinginterface *proxy,
 833     GAsyncResult *res,
 834     GError **error);
 835
 836 gboolean audiomanager_routinginterface_call_confirm_routing_ready_sync (
 837     AudiomanagerRoutinginterface *proxy,
 838     guint16 arg_domainID,
 839     GCancellable *cancellable,
 840     GError **error);
 841
 842 void audiomanager_routinginterface_call_confirm_routing_rundown (
 843     AudiomanagerRoutinginterface *proxy,
 844     guint16 arg_domainID,
 845     GCancellable *cancellable,
 846     GAsyncReadyCallback callback,
 847     gpointer user_data);
 848
 849 gboolean audiomanager_routinginterface_call_confirm_routing_rundown_finish (
 850     AudiomanagerRoutinginterface *proxy,
 851     GAsyncResult *res,
 852     GError **error);
 853
 854 gboolean audiomanager_routinginterface_call_confirm_routing_rundown_sync (
 855     AudiomanagerRoutinginterface *proxy,
 856     guint16 arg_domainID,
 857     GCancellable *cancellable,
 858     GError **error);
 859
 860 void audiomanager_routinginterface_call_ack_set_volumes (
 861     AudiomanagerRoutinginterface *proxy,
 862     guint16 arg_handle,
 863     GVariant *arg_listvolumes,
 864     guint16 arg_error,
 865     GCancellable *cancellable,
 866     GAsyncReadyCallback callback,
 867     gpointer user_data);
 868
 869 gboolean audiomanager_routinginterface_call_ack_set_volumes_finish (
 870     AudiomanagerRoutinginterface *proxy,
 871     GAsyncResult *res,
 872     GError **error);
 873
 874 gboolean audiomanager_routinginterface_call_ack_set_volumes_sync (
 875     AudiomanagerRoutinginterface *proxy,
 876     guint16 arg_handle,
 877     GVariant *arg_listvolumes,
 878     guint16 arg_error,
 879     GCancellable *cancellable,
 880     GError **error);
 881
 882 void audiomanager_routinginterface_call_ack_sink_notification_configuration (
 883     AudiomanagerRoutinginterface *proxy,
 884     guint16 arg_handle,
 885     guint16 arg_error,
 886     GCancellable *cancellable,
 887     GAsyncReadyCallback callback,
 888     gpointer user_data);
 889
 890 gboolean audiomanager_routinginterface_call_ack_sink_notification_configuration_finish (
 891     AudiomanagerRoutinginterface *proxy,
 892     GAsyncResult *res,
 893     GError **error);
 894
 895 gboolean audiomanager_routinginterface_call_ack_sink_notification_configuration_sync (
 896     AudiomanagerRoutinginterface *proxy,
 897     guint16 arg_handle,
 898     guint16 arg_error,
 899     GCancellable *cancellable,
 900     GError **error);
 901
 902 void audiomanager_routinginterface_call_ack_source_notification_configuration (
 903     AudiomanagerRoutinginterface *proxy,
 904     guint16 arg_handle,
 905     guint16 arg_error,
 906     GCancellable *cancellable,
 907     GAsyncReadyCallback callback,
 908     gpointer user_data);
 909
 910 gboolean audiomanager_routinginterface_call_ack_source_notification_configuration_finish (
 911     AudiomanagerRoutinginterface *proxy,
 912     GAsyncResult *res,
 913     GError **error);
 914
 915 gboolean audiomanager_routinginterface_call_ack_source_notification_configuration_sync (
 916     AudiomanagerRoutinginterface *proxy,
 917     guint16 arg_handle,
 918     guint16 arg_error,
 919     GCancellable *cancellable,
 920     GError **error);
 921
 922 void audiomanager_routinginterface_call_register_domain (
 923     AudiomanagerRoutinginterface *proxy,
 924     GVariant *arg_domaindata,
 925     const gchar *arg_returnBusname,
 926     const gchar *arg_returnPath,
 927     const gchar *arg_returnInterface,
 928     GCancellable *cancellable,
 929     GAsyncReadyCallback callback,
 930     gpointer user_data);
 931
 932 gboolean audiomanager_routinginterface_call_register_domain_finish (
 933     AudiomanagerRoutinginterface *proxy,
 934     guint16 *out_domainid,
 935     guint16 *out_error,
 936     GAsyncResult *res,
 937     GError **error);
 938
 939 gboolean audiomanager_routinginterface_call_register_domain_sync (
 940     AudiomanagerRoutinginterface *proxy,
 941     GVariant *arg_domaindata,
 942     const gchar *arg_returnBusname,
 943     const gchar *arg_returnPath,
 944     const gchar *arg_returnInterface,
 945     guint16 *out_domainid,
 946     guint16 *out_error,
 947     GCancellable *cancellable,
 948     GError **error);
 949
 950
 951
 952 /* ---- */
 953
 954 #define TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY (audiomanager_routinginterface_proxy_get_type ())
 955 #define AUDIOMANAGER_ROUTINGINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxy))
 956 #define AUDIOMANAGER_ROUTINGINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyClass))
 957 #define AUDIOMANAGER_ROUTINGINTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyClass))
 958 #define IS_AUDIOMANAGER_ROUTINGINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY))
 959 #define IS_AUDIOMANAGER_ROUTINGINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY))
 960
 961 typedef struct _AudiomanagerRoutinginterfaceProxy AudiomanagerRoutinginterfaceProxy;
 962 typedef struct _AudiomanagerRoutinginterfaceProxyClass AudiomanagerRoutinginterfaceProxyClass;
 963 typedef struct _AudiomanagerRoutinginterfaceProxyPrivate AudiomanagerRoutinginterfaceProxyPrivate;
 964
 965 struct _AudiomanagerRoutinginterfaceProxy
 966 {
 967   /*< private >*/
 968   GDBusProxy parent_instance;
 969   AudiomanagerRoutinginterfaceProxyPrivate *priv;
 970 };
 971
 972 struct _AudiomanagerRoutinginterfaceProxyClass
 973 {
 974   GDBusProxyClass parent_class;
 975 };
 976
 977 GType audiomanager_routinginterface_proxy_get_type (void) G_GNUC_CONST;
 978
 979 #if GLIB_CHECK_VERSION(2, 44, 0)
 980 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutinginterfaceProxy, g_object_unref)
 981 #endif
 982
 983 void audiomanager_routinginterface_proxy_new (
 984     GDBusConnection     *connection,
 985     GDBusProxyFlags      flags,
 986     const gchar         *name,
 987     const gchar         *object_path,
 988     GCancellable        *cancellable,
 989     GAsyncReadyCallback  callback,
 990     gpointer             user_data);
 991 AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_finish (
 992     GAsyncResult        *res,
 993     GError             **error);
 994 AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_sync (
 995     GDBusConnection     *connection,
 996     GDBusProxyFlags      flags,
 997     const gchar         *name,
 998     const gchar         *object_path,
 999     GCancellable        *cancellable,
1000     GError             **error);
1001
1002 void audiomanager_routinginterface_proxy_new_for_bus (
1003     GBusType             bus_type,
1004     GDBusProxyFlags      flags,
1005     const gchar         *name,
1006     const gchar         *object_path,
1007     GCancellable        *cancellable,
1008     GAsyncReadyCallback  callback,
1009     gpointer             user_data);
1010 AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_for_bus_finish (
1011     GAsyncResult        *res,
1012     GError             **error);
1013 AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_for_bus_sync (
1014     GBusType             bus_type,
1015     GDBusProxyFlags      flags,
1016     const gchar         *name,
1017     const gchar         *object_path,
1018     GCancellable        *cancellable,
1019     GError             **error);
1020
1021
1022 /* ---- */
1023
1024 #define TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (audiomanager_routinginterface_skeleton_get_type ())
1025 #define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeleton))
1026 #define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonClass))
1027 #define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonClass))
1028 #define IS_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON))
1029 #define IS_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON))
1030
1031 typedef struct _AudiomanagerRoutinginterfaceSkeleton AudiomanagerRoutinginterfaceSkeleton;
1032 typedef struct _AudiomanagerRoutinginterfaceSkeletonClass AudiomanagerRoutinginterfaceSkeletonClass;
1033 typedef struct _AudiomanagerRoutinginterfaceSkeletonPrivate AudiomanagerRoutinginterfaceSkeletonPrivate;
1034
1035 struct _AudiomanagerRoutinginterfaceSkeleton
1036 {
1037   /*< private >*/
1038   GDBusInterfaceSkeleton parent_instance;
1039   AudiomanagerRoutinginterfaceSkeletonPrivate *priv;
1040 };
1041
1042 struct _AudiomanagerRoutinginterfaceSkeletonClass
1043 {
1044   GDBusInterfaceSkeletonClass parent_class;
1045 };
1046
1047 GType audiomanager_routinginterface_skeleton_get_type (void) G_GNUC_CONST;
1048
1049 #if GLIB_CHECK_VERSION(2, 44, 0)
1050 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutinginterfaceSkeleton, g_object_unref)
1051 #endif
1052
1053 AudiomanagerRoutinginterface *audiomanager_routinginterface_skeleton_new (void);
1054
1055
1056 /* ------------------------------------------------------------------------ */
1057 /* Declarations for org.genivi.audiomanager.routing.soundmanager */
1058
1059 #define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER (audiomanager_routing_soundmanager_get_type ())
1060 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, AudiomanagerRoutingSoundmanager))
1061 #define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER))
1062 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, AudiomanagerRoutingSoundmanagerIface))
1063
1064 struct _AudiomanagerRoutingSoundmanager;
1065 typedef struct _AudiomanagerRoutingSoundmanager AudiomanagerRoutingSoundmanager;
1066 typedef struct _AudiomanagerRoutingSoundmanagerIface AudiomanagerRoutingSoundmanagerIface;
1067
1068 struct _AudiomanagerRoutingSoundmanagerIface
1069 {
1070   GTypeInterface parent_iface;
1071
1072   gboolean (*handle_async_abort) (
1073     AudiomanagerRoutingSoundmanager *object,
1074     GDBusMethodInvocation *invocation,
1075     guint16 arg_handle);
1076
1077   gboolean (*handle_async_connect) (
1078     AudiomanagerRoutingSoundmanager *object,
1079     GDBusMethodInvocation *invocation,
1080     guint16 arg_handle,
1081     guint16 arg_connectionID,
1082     guint16 arg_sourceID,
1083     guint16 arg_sinkID,
1084     gint arg_connectionFormat);
1085
1086   gboolean (*handle_async_disconnect) (
1087     AudiomanagerRoutingSoundmanager *object,
1088     GDBusMethodInvocation *invocation,
1089     guint16 arg_handle,
1090     guint16 arg_connectionID);
1091
1092   gboolean (*handle_async_set_sink_volume) (
1093     AudiomanagerRoutingSoundmanager *object,
1094     GDBusMethodInvocation *invocation,
1095     guint16 arg_handle,
1096     guint16 arg_sinkID,
1097     gint16 arg_volume,
1098     gint16 arg_ramp,
1099     guint16 arg_time);
1100
1101   gboolean (*handle_async_set_source_state) (
1102     AudiomanagerRoutingSoundmanager *object,
1103     GDBusMethodInvocation *invocation,
1104     guint16 arg_handle,
1105     guint16 arg_sourceID,
1106     gint arg_sourceState);
1107
1108 };
1109
1110 GType audiomanager_routing_soundmanager_get_type (void) G_GNUC_CONST;
1111
1112 GDBusInterfaceInfo *audiomanager_routing_soundmanager_interface_info (void);
1113 guint audiomanager_routing_soundmanager_override_properties (GObjectClass *klass, guint property_id_begin);
1114
1115
1116 /* D-Bus method call completion functions: */
1117 void audiomanager_routing_soundmanager_complete_async_abort (
1118     AudiomanagerRoutingSoundmanager *object,
1119     GDBusMethodInvocation *invocation,
1120     gint16 error);
1121
1122 void audiomanager_routing_soundmanager_complete_async_connect (
1123     AudiomanagerRoutingSoundmanager *object,
1124     GDBusMethodInvocation *invocation);
1125
1126 void audiomanager_routing_soundmanager_complete_async_disconnect (
1127     AudiomanagerRoutingSoundmanager *object,
1128     GDBusMethodInvocation *invocation);
1129
1130 void audiomanager_routing_soundmanager_complete_async_set_sink_volume (
1131     AudiomanagerRoutingSoundmanager *object,
1132     GDBusMethodInvocation *invocation);
1133
1134 void audiomanager_routing_soundmanager_complete_async_set_source_state (
1135     AudiomanagerRoutingSoundmanager *object,
1136     GDBusMethodInvocation *invocation);
1137
1138
1139
1140 /* D-Bus method calls: */
1141 void audiomanager_routing_soundmanager_call_async_abort (
1142     AudiomanagerRoutingSoundmanager *proxy,
1143     guint16 arg_handle,
1144     GCancellable *cancellable,
1145     GAsyncReadyCallback callback,
1146     gpointer user_data);
1147
1148 gboolean audiomanager_routing_soundmanager_call_async_abort_finish (
1149     AudiomanagerRoutingSoundmanager *proxy,
1150     gint16 *out_error,
1151     GAsyncResult *res,
1152     GError **error);
1153
1154 gboolean audiomanager_routing_soundmanager_call_async_abort_sync (
1155     AudiomanagerRoutingSoundmanager *proxy,
1156     guint16 arg_handle,
1157     gint16 *out_error,
1158     GCancellable *cancellable,
1159     GError **error);
1160
1161 void audiomanager_routing_soundmanager_call_async_connect (
1162     AudiomanagerRoutingSoundmanager *proxy,
1163     guint16 arg_handle,
1164     guint16 arg_connectionID,
1165     guint16 arg_sourceID,
1166     guint16 arg_sinkID,
1167     gint arg_connectionFormat,
1168     GCancellable *cancellable,
1169     GAsyncReadyCallback callback,
1170     gpointer user_data);
1171
1172 gboolean audiomanager_routing_soundmanager_call_async_connect_finish (
1173     AudiomanagerRoutingSoundmanager *proxy,
1174     GAsyncResult *res,
1175     GError **error);
1176
1177 gboolean audiomanager_routing_soundmanager_call_async_connect_sync (
1178     AudiomanagerRoutingSoundmanager *proxy,
1179     guint16 arg_handle,
1180     guint16 arg_connectionID,
1181     guint16 arg_sourceID,
1182     guint16 arg_sinkID,
1183     gint arg_connectionFormat,
1184     GCancellable *cancellable,
1185     GError **error);
1186
1187 void audiomanager_routing_soundmanager_call_async_disconnect (
1188     AudiomanagerRoutingSoundmanager *proxy,
1189     guint16 arg_handle,
1190     guint16 arg_connectionID,
1191     GCancellable *cancellable,
1192     GAsyncReadyCallback callback,
1193     gpointer user_data);
1194
1195 gboolean audiomanager_routing_soundmanager_call_async_disconnect_finish (
1196     AudiomanagerRoutingSoundmanager *proxy,
1197     GAsyncResult *res,
1198     GError **error);
1199
1200 gboolean audiomanager_routing_soundmanager_call_async_disconnect_sync (
1201     AudiomanagerRoutingSoundmanager *proxy,
1202     guint16 arg_handle,
1203     guint16 arg_connectionID,
1204     GCancellable *cancellable,
1205     GError **error);
1206
1207 void audiomanager_routing_soundmanager_call_async_set_sink_volume (
1208     AudiomanagerRoutingSoundmanager *proxy,
1209     guint16 arg_handle,
1210     guint16 arg_sinkID,
1211     gint16 arg_volume,
1212     gint16 arg_ramp,
1213     guint16 arg_time,
1214     GCancellable *cancellable,
1215     GAsyncReadyCallback callback,
1216     gpointer user_data);
1217
1218 gboolean audiomanager_routing_soundmanager_call_async_set_sink_volume_finish (
1219     AudiomanagerRoutingSoundmanager *proxy,
1220     GAsyncResult *res,
1221     GError **error);
1222
1223 gboolean audiomanager_routing_soundmanager_call_async_set_sink_volume_sync (
1224     AudiomanagerRoutingSoundmanager *proxy,
1225     guint16 arg_handle,
1226     guint16 arg_sinkID,
1227     gint16 arg_volume,
1228     gint16 arg_ramp,
1229     guint16 arg_time,
1230     GCancellable *cancellable,
1231     GError **error);
1232
1233 void audiomanager_routing_soundmanager_call_async_set_source_state (
1234     AudiomanagerRoutingSoundmanager *proxy,
1235     guint16 arg_handle,
1236     guint16 arg_sourceID,
1237     gint arg_sourceState,
1238     GCancellable *cancellable,
1239     GAsyncReadyCallback callback,
1240     gpointer user_data);
1241
1242 gboolean audiomanager_routing_soundmanager_call_async_set_source_state_finish (
1243     AudiomanagerRoutingSoundmanager *proxy,
1244     GAsyncResult *res,
1245     GError **error);
1246
1247 gboolean audiomanager_routing_soundmanager_call_async_set_source_state_sync (
1248     AudiomanagerRoutingSoundmanager *proxy,
1249     guint16 arg_handle,
1250     guint16 arg_sourceID,
1251     gint arg_sourceState,
1252     GCancellable *cancellable,
1253     GError **error);
1254
1255
1256
1257 /* ---- */
1258
1259 #define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (audiomanager_routing_soundmanager_proxy_get_type ())
1260 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxy))
1261 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyClass))
1262 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyClass))
1263 #define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY))
1264 #define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY))
1265
1266 typedef struct _AudiomanagerRoutingSoundmanagerProxy AudiomanagerRoutingSoundmanagerProxy;
1267 typedef struct _AudiomanagerRoutingSoundmanagerProxyClass AudiomanagerRoutingSoundmanagerProxyClass;
1268 typedef struct _AudiomanagerRoutingSoundmanagerProxyPrivate AudiomanagerRoutingSoundmanagerProxyPrivate;
1269
1270 struct _AudiomanagerRoutingSoundmanagerProxy
1271 {
1272   /*< private >*/
1273   GDBusProxy parent_instance;
1274   AudiomanagerRoutingSoundmanagerProxyPrivate *priv;
1275 };
1276
1277 struct _AudiomanagerRoutingSoundmanagerProxyClass
1278 {
1279   GDBusProxyClass parent_class;
1280 };
1281
1282 GType audiomanager_routing_soundmanager_proxy_get_type (void) G_GNUC_CONST;
1283
1284 #if GLIB_CHECK_VERSION(2, 44, 0)
1285 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutingSoundmanagerProxy, g_object_unref)
1286 #endif
1287
1288 void audiomanager_routing_soundmanager_proxy_new (
1289     GDBusConnection     *connection,
1290     GDBusProxyFlags      flags,
1291     const gchar         *name,
1292     const gchar         *object_path,
1293     GCancellable        *cancellable,
1294     GAsyncReadyCallback  callback,
1295     gpointer             user_data);
1296 AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_finish (
1297     GAsyncResult        *res,
1298     GError             **error);
1299 AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_sync (
1300     GDBusConnection     *connection,
1301     GDBusProxyFlags      flags,
1302     const gchar         *name,
1303     const gchar         *object_path,
1304     GCancellable        *cancellable,
1305     GError             **error);
1306
1307 void audiomanager_routing_soundmanager_proxy_new_for_bus (
1308     GBusType             bus_type,
1309     GDBusProxyFlags      flags,
1310     const gchar         *name,
1311     const gchar         *object_path,
1312     GCancellable        *cancellable,
1313     GAsyncReadyCallback  callback,
1314     gpointer             user_data);
1315 AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_for_bus_finish (
1316     GAsyncResult        *res,
1317     GError             **error);
1318 AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_for_bus_sync (
1319     GBusType             bus_type,
1320     GDBusProxyFlags      flags,
1321     const gchar         *name,
1322     const gchar         *object_path,
1323     GCancellable        *cancellable,
1324     GError             **error);
1325
1326
1327 /* ---- */
1328
1329 #define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (audiomanager_routing_soundmanager_skeleton_get_type ())
1330 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeleton))
1331 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonClass))
1332 #define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonClass))
1333 #define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON))
1334 #define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON))
1335
1336 typedef struct _AudiomanagerRoutingSoundmanagerSkeleton AudiomanagerRoutingSoundmanagerSkeleton;
1337 typedef struct _AudiomanagerRoutingSoundmanagerSkeletonClass AudiomanagerRoutingSoundmanagerSkeletonClass;
1338 typedef struct _AudiomanagerRoutingSoundmanagerSkeletonPrivate AudiomanagerRoutingSoundmanagerSkeletonPrivate;
1339
1340 struct _AudiomanagerRoutingSoundmanagerSkeleton
1341 {
1342   /*< private >*/
1343   GDBusInterfaceSkeleton parent_instance;
1344   AudiomanagerRoutingSoundmanagerSkeletonPrivate *priv;
1345 };
1346
1347 struct _AudiomanagerRoutingSoundmanagerSkeletonClass
1348 {
1349   GDBusInterfaceSkeletonClass parent_class;
1350 };
1351
1352 GType audiomanager_routing_soundmanager_skeleton_get_type (void) G_GNUC_CONST;
1353
1354 #if GLIB_CHECK_VERSION(2, 44, 0)
1355 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutingSoundmanagerSkeleton, g_object_unref)
1356 #endif
1357
1358 AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_skeleton_new (void);
1359
1360
1361 /* ---- */
1362
1363 #define TYPE_OBJECT (object_get_type ())
1364 #define OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT, Object))
1365 #define IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT))
1366 #define OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_OBJECT, Object))
1367
1368 struct _Object;
1369 typedef struct _Object Object;
1370 typedef struct _ObjectIface ObjectIface;
1371
1372 struct _ObjectIface
1373 {
1374   GTypeInterface parent_iface;
1375 };
1376
1377 GType object_get_type (void) G_GNUC_CONST;
1378
1379 AudiomanagerCommandinterface *object_get_audiomanager_commandinterface (Object *object);
1380 AudiomanagerRoutinginterface *object_get_audiomanager_routinginterface (Object *object);
1381 AudiomanagerRoutingSoundmanager *object_get_audiomanager_routing_soundmanager (Object *object);
1382 AudiomanagerCommandinterface *object_peek_audiomanager_commandinterface (Object *object);
1383 AudiomanagerRoutinginterface *object_peek_audiomanager_routinginterface (Object *object);
1384 AudiomanagerRoutingSoundmanager *object_peek_audiomanager_routing_soundmanager (Object *object);
1385
1386 #define TYPE_OBJECT_PROXY (object_proxy_get_type ())
1387 #define OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_PROXY, ObjectProxy))
1388 #define OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_PROXY, ObjectProxyClass))
1389 #define OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_PROXY, ObjectProxyClass))
1390 #define IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_PROXY))
1391 #define IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_PROXY))
1392
1393 typedef struct _ObjectProxy ObjectProxy;
1394 typedef struct _ObjectProxyClass ObjectProxyClass;
1395 typedef struct _ObjectProxyPrivate ObjectProxyPrivate;
1396
1397 struct _ObjectProxy
1398 {
1399   /*< private >*/
1400   GDBusObjectProxy parent_instance;
1401   ObjectProxyPrivate *priv;
1402 };
1403
1404 struct _ObjectProxyClass
1405 {
1406   GDBusObjectProxyClass parent_class;
1407 };
1408
1409 GType object_proxy_get_type (void) G_GNUC_CONST;
1410
1411 #if GLIB_CHECK_VERSION(2, 44, 0)
1412 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectProxy, g_object_unref)
1413 #endif
1414
1415 ObjectProxy *object_proxy_new (GDBusConnection *connection, const gchar *object_path);
1416
1417 #define TYPE_OBJECT_SKELETON (object_skeleton_get_type ())
1418 #define OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_SKELETON, ObjectSkeleton))
1419 #define OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_SKELETON, ObjectSkeletonClass))
1420 #define OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_SKELETON, ObjectSkeletonClass))
1421 #define IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_SKELETON))
1422 #define IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_SKELETON))
1423
1424 typedef struct _ObjectSkeleton ObjectSkeleton;
1425 typedef struct _ObjectSkeletonClass ObjectSkeletonClass;
1426 typedef struct _ObjectSkeletonPrivate ObjectSkeletonPrivate;
1427
1428 struct _ObjectSkeleton
1429 {
1430   /*< private >*/
1431   GDBusObjectSkeleton parent_instance;
1432   ObjectSkeletonPrivate *priv;
1433 };
1434
1435 struct _ObjectSkeletonClass
1436 {
1437   GDBusObjectSkeletonClass parent_class;
1438 };
1439
1440 GType object_skeleton_get_type (void) G_GNUC_CONST;
1441
1442 #if GLIB_CHECK_VERSION(2, 44, 0)
1443 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectSkeleton, g_object_unref)
1444 #endif
1445
1446 ObjectSkeleton *object_skeleton_new (const gchar *object_path);
1447 void object_skeleton_set_audiomanager_commandinterface (ObjectSkeleton *object, AudiomanagerCommandinterface *interface_);
1448 void object_skeleton_set_audiomanager_routinginterface (ObjectSkeleton *object, AudiomanagerRoutinginterface *interface_);
1449 void object_skeleton_set_audiomanager_routing_soundmanager (ObjectSkeleton *object, AudiomanagerRoutingSoundmanager *interface_);
1450
1451 /* ---- */
1452
1453 #define TYPE_OBJECT_MANAGER_CLIENT (object_manager_client_get_type ())
1454 #define OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClient))
1455 #define OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass))
1456 #define OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass))
1457 #define IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_MANAGER_CLIENT))
1458 #define IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_MANAGER_CLIENT))
1459
1460 typedef struct _ObjectManagerClient ObjectManagerClient;
1461 typedef struct _ObjectManagerClientClass ObjectManagerClientClass;
1462 typedef struct _ObjectManagerClientPrivate ObjectManagerClientPrivate;
1463
1464 struct _ObjectManagerClient
1465 {
1466   /*< private >*/
1467   GDBusObjectManagerClient parent_instance;
1468   ObjectManagerClientPrivate *priv;
1469 };
1470
1471 struct _ObjectManagerClientClass
1472 {
1473   GDBusObjectManagerClientClass parent_class;
1474 };
1475
1476 #if GLIB_CHECK_VERSION(2, 44, 0)
1477 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectManagerClient, g_object_unref)
1478 #endif
1479
1480 GType object_manager_client_get_type (void) G_GNUC_CONST;
1481
1482 GType object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager, const gchar *object_path, const gchar *interface_name, gpointer user_data);
1483
1484 void object_manager_client_new (
1485     GDBusConnection        *connection,
1486     GDBusObjectManagerClientFlags  flags,
1487     const gchar            *name,
1488     const gchar            *object_path,
1489     GCancellable           *cancellable,
1490     GAsyncReadyCallback     callback,
1491     gpointer                user_data);
1492 GDBusObjectManager *object_manager_client_new_finish (
1493     GAsyncResult        *res,
1494     GError             **error);
1495 GDBusObjectManager *object_manager_client_new_sync (
1496     GDBusConnection        *connection,
1497     GDBusObjectManagerClientFlags  flags,
1498     const gchar            *name,
1499     const gchar            *object_path,
1500     GCancellable           *cancellable,
1501     GError                **error);
1502
1503 void object_manager_client_new_for_bus (
1504     GBusType                bus_type,
1505     GDBusObjectManagerClientFlags  flags,
1506     const gchar            *name,
1507     const gchar            *object_path,
1508     GCancellable           *cancellable,
1509     GAsyncReadyCallback     callback,
1510     gpointer                user_data);
1511 GDBusObjectManager *object_manager_client_new_for_bus_finish (
1512     GAsyncResult        *res,
1513     GError             **error);
1514 GDBusObjectManager *object_manager_client_new_for_bus_sync (
1515     GBusType                bus_type,
1516     GDBusObjectManagerClientFlags  flags,
1517     const gchar            *name,
1518     const gchar            *object_path,
1519     GCancellable           *cancellable,
1520     GError                **error);
1521
1522
1523 G_END_DECLS
1524
1525 #endif /* __AUDIO_MANAGER_INTERFACE_H__ */