daemon/control.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  * Copyright (C) 2008 Juuso Alasuutari <juuso.alasuutari@gmail.com>
   7  *
   8  **************************************************************************
   9  * This file contains code of the D-Bus control interface helpers
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include "common.h"
  29 #include "studio.h"
  30 #include "../dbus/error.h"
  31 #include "control.h"
  32 #include "../dbus_constants.h"
  33 #include "cmd.h"
  34 #include "room.h"
  35 #include "../lib/wkports.h"
  36
  37 #define INTERFACE_NAME IFACE_CONTROL
  38
  39 /* 805e485f-65e4-4c37-a959-2a3b60b3c270 */
  40 UUID_DEFINE(empty_room,0x80,0x5E,0x48,0x5F,0x65,0xE4,0x4C,0x37,0xA9,0x59,0x2A,0x3B,0x60,0xB3,0xC2,0x70);
  41
  42 /* c603f2a0-d96a-493e-a8cf-55581d950aa9 */
  43 UUID_DEFINE(basic_room,0xC6,0x03,0xF2,0xA0,0xD9,0x6A,0x49,0x3E,0xA8,0xCF,0x55,0x58,0x1D,0x95,0x0A,0xA9);
  44
  45 static struct list_head g_room_templates;
  46
  47 static bool create_empty_room_template(const uuid_t uuid_ptr, const char * name, ladish_room_handle * room_ptr)
  48 {
  49   if (!ladish_room_create_template(uuid_ptr, name, room_ptr))
  50   {
  51     log_error("ladish_room_create_template() failed for room template \"%s\".", name);
  52     return false;
  53   }
  54
  55   return true;
  56 }
  57
  58 struct room_descriptor
  59 {
  60   const char * name;
  61   ladish_room_handle room;
  62   ladish_graph_handle graph;
  63   ladish_client_handle capture;
  64   ladish_client_handle playback;
  65 };
  66
  67 static
  68 bool
  69 create_room_template(
  70   const uuid_t uuid_ptr,
  71   const char * name,
  72   struct room_descriptor * room_descriptor_ptr)
  73 {
  74   ladish_room_handle room;
  75   ladish_graph_handle graph;
  76   ladish_client_handle capture;
  77   ladish_client_handle playback;
  78
  79   if (!create_empty_room_template(uuid_ptr, name, &room))
  80   {
  81     log_error("ladish_room_create() failed for room template \"%s\".", name);
  82     goto fail;
  83   }
  84
  85   graph = ladish_room_get_graph(room);
  86
  87   if (!ladish_client_create(ladish_wkclient_capture, &capture))
  88   {
  89     log_error("ladish_client_create() failed to create capture client to room template \"%s\".", name);
  90     goto fail_destroy;
  91   }
  92
  93   if (!ladish_graph_add_client(graph, capture, "Capture", false))
  94   {
  95     log_error("ladish_graph_add_client() failed to add capture client to room template \"%s\".", name);
  96     goto fail_destroy;
  97   }
  98
  99   if (!ladish_client_create(ladish_wkclient_playback, &playback))
 100   {
 101     log_error("ladish_client_create() failed to create playback client to room template \"%s\".", name);
 102     goto fail_destroy;
 103   }
 104
 105   if (!ladish_graph_add_client(graph, playback, "Playback", false))
 106   {
 107     log_error("ladish_graph_add_client() failed to add playback client to room template \"%s\".", name);
 108     goto fail_destroy;
 109   }
 110
 111   room_descriptor_ptr->name = ladish_room_get_name(room);
 112   room_descriptor_ptr->room = room;
 113   room_descriptor_ptr->graph = graph;
 114   room_descriptor_ptr->capture = capture;
 115   room_descriptor_ptr->playback = playback;
 116
 117   return true;
 118
 119 fail_destroy:
 120   ladish_room_destroy(room);    /* this will destroy the graph clients as well */
 121 fail:
 122   return false;
 123 }
 124
 125 static
 126 bool
 127 create_room_template_port(
 128   struct room_descriptor * room_descriptor_ptr,
 129   const uuid_t uuid_ptr,
 130   const char * name,
 131   uint32_t type,
 132   uint32_t flags)
 133 {
 134   ladish_port_handle port;
 135   bool playback;
 136   ladish_client_handle client;
 137
 138   playback = JACKDBUS_PORT_IS_INPUT(flags);
 139   ASSERT(playback || JACKDBUS_PORT_IS_OUTPUT(flags)); /* playback or capture */
 140   ASSERT(!(playback && JACKDBUS_PORT_IS_OUTPUT(flags))); /* but not both */
 141   client = playback ? room_descriptor_ptr->playback : room_descriptor_ptr->capture;
 142
 143   if (!ladish_port_create(uuid_ptr, true, &port))
 144   {
 145     log_error("Creation of room template \"%s\" %s port \"%s\" failed.", room_descriptor_ptr->name, playback ? "playback" : "capture", name);
 146     return false;
 147   }
 148
 149   if (!ladish_graph_add_port(room_descriptor_ptr->graph, client, port, name, type, flags, false))
 150   {
 151     log_error("Adding of room template \"%s\" %s port \"%s\" to graph failed.", room_descriptor_ptr->name, playback ? "playback" : "capture", name);
 152     ladish_port_destroy(port);
 153     return false;
 154   }
 155
 156   return true;
 157 }
 158
 159 void create_builtin_room_templates(void)
 160 {
 161   struct room_descriptor room_descriptor;
 162
 163   if (create_empty_room_template(empty_room, "Empty", &room_descriptor.room))
 164   {
 165     list_add_tail(ladish_room_get_list_node(room_descriptor.room), &g_room_templates);
 166   }
 167
 168   if (create_room_template(basic_room, "Basic", &room_descriptor))
 169   {
 170     if (!create_room_template_port(&room_descriptor, ladish_wkport_capture_left, "Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_OUTPUT))
 171     {
 172       goto fail;
 173     }
 174
 175     if (!create_room_template_port(&room_descriptor, ladish_wkport_capture_right, "Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_OUTPUT))
 176     {
 177       goto fail;
 178     }
 179
 180     if (!create_room_template_port(&room_descriptor, ladish_wkport_midi_capture, "MIDI", JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_OUTPUT))
 181     {
 182       goto fail;
 183     }
 184
 185     if (!create_room_template_port(&room_descriptor, ladish_wkport_playback_left, "Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 186     {
 187       goto fail;
 188     }
 189
 190     if (!create_room_template_port(&room_descriptor, ladish_wkport_playback_right, "Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 191     {
 192       goto fail;
 193     }
 194
 195     if (!create_room_template_port(&room_descriptor, ladish_wkport_monitor_left, "Monitor Left", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 196     {
 197       goto fail;
 198     }
 199
 200     if (!create_room_template_port(&room_descriptor, ladish_wkport_monitor_right, "Monitor Right", JACKDBUS_PORT_TYPE_AUDIO, JACKDBUS_PORT_FLAG_INPUT))
 201     {
 202       goto fail;
 203     }
 204
 205     if (!create_room_template_port(&room_descriptor, ladish_wkport_midi_playback, "MIDI", JACKDBUS_PORT_TYPE_MIDI, JACKDBUS_PORT_FLAG_INPUT))
 206     {
 207       goto fail;
 208     }
 209
 210     list_add_tail(ladish_room_get_list_node(room_descriptor.room), &g_room_templates);
 211   }
 212
 213   return;
 214
 215 fail:
 216   ladish_room_destroy(room_descriptor.room); /* this will destroy the graph clients and ports as well */
 217 }
 218
 219 void create_room_templates(void)
 220 {
 221   create_builtin_room_templates();
 222 }
 223
 224 void maybe_create_room_templates(void)
 225 {
 226   if (list_empty(&g_room_templates))
 227   {
 228     create_room_templates();
 229   }
 230 }
 231
 232 bool room_templates_init(void)
 233 {
 234   INIT_LIST_HEAD(&g_room_templates);
 235
 236   return true;
 237 }
 238
 239 void room_templates_uninit(void)
 240 {
 241   struct list_head * node_ptr;
 242   ladish_room_handle room;
 243
 244   while (!list_empty(&g_room_templates))
 245   {
 246     node_ptr = g_room_templates.next;
 247     list_del(node_ptr);
 248     room = ladish_room_from_list_node(node_ptr);
 249     ladish_room_destroy(room);
 250   }
 251 }
 252
 253 bool room_templates_enum(void * context, bool (* callback)(void * context, ladish_room_handle room))
 254 {
 255   struct list_head * node_ptr;
 256
 257   maybe_create_room_templates();
 258
 259   list_for_each(node_ptr, &g_room_templates)
 260   {
 261     if (!callback(context, ladish_room_from_list_node(node_ptr)))
 262     {
 263       return false;
 264     }
 265   }
 266
 267   return true;
 268 }
 269
 270 ladish_room_handle find_room_template_by_name(const char * name)
 271 {
 272   ladish_room_handle room;
 273   struct list_head * node_ptr;
 274
 275   maybe_create_room_templates();
 276
 277   list_for_each(node_ptr, &g_room_templates)
 278   {
 279     room = ladish_room_from_list_node(node_ptr);
 280     if (strcmp(ladish_room_get_name(room), name) == 0)
 281     {
 282       return room;
 283     }
 284   }
 285
 286   return NULL;
 287 }
 288
 289 ladish_room_handle find_room_template_by_uuid(const uuid_t uuid_ptr)
 290 {
 291   ladish_room_handle room;
 292   struct list_head * node_ptr;
 293   uuid_t uuid;
 294
 295   maybe_create_room_templates();
 296
 297   list_for_each(node_ptr, &g_room_templates)
 298   {
 299     room = ladish_room_from_list_node(node_ptr);
 300     ladish_room_get_uuid(room, uuid);
 301     if (uuid_compare(uuid, uuid_ptr) == 0)
 302     {
 303       return room;
 304     }
 305   }
 306
 307   return NULL;
 308 }
 309
 310 static void ladish_is_studio_loaded(struct dbus_method_call * call_ptr)
 311 {
 312   DBusMessageIter iter;
 313   dbus_bool_t is_loaded;
 314
 315   is_loaded = ladish_studio_is_loaded();
 316
 317   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 318   if (call_ptr->reply == NULL)
 319   {
 320     goto fail;
 321   }
 322
 323   dbus_message_iter_init_append(call_ptr->reply, &iter);
 324
 325   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &is_loaded))
 326   {
 327     goto fail_unref;
 328   }
 329
 330   return;
 331
 332 fail_unref:
 333   dbus_message_unref(call_ptr->reply);
 334   call_ptr->reply = NULL;
 335
 336 fail:
 337   log_error("Ran out of memory trying to construct method return");
 338 }
 339
 340 #define array_iter_ptr ((DBusMessageIter *)context)
 341
 342 static bool get_studio_list_callback(void * call_ptr, void * context, const char * studio, uint32_t modtime)
 343 {
 344   DBusMessageIter struct_iter;
 345   DBusMessageIter dict_iter;
 346   bool ret;
 347
 348   ret = false;
 349
 350   if (!dbus_message_iter_open_container(array_iter_ptr, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 351     goto exit;
 352
 353   if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &studio))
 354     goto close_struct;
 355
 356   if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 357     goto close_struct;
 358
 359 /*   if (!maybe_add_dict_entry_string(&dict_iter, "Description", xxx)) */
 360 /*     goto close_dict; */
 361
 362   if (!dbus_add_dict_entry_uint32(&dict_iter, "Modification Time", modtime))
 363     goto close_dict;
 364
 365   ret = true;
 366
 367 close_dict:
 368   if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 369     ret = false;
 370
 371 close_struct:
 372   if (!dbus_message_iter_close_container(array_iter_ptr, &struct_iter))
 373     ret = false;
 374
 375 exit:
 376   return ret;
 377 }
 378
 379 static void ladish_get_studio_list(struct dbus_method_call * call_ptr)
 380 {
 381   DBusMessageIter iter, array_iter;
 382
 383   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 384   if (call_ptr->reply == NULL)
 385   {
 386     goto fail;
 387   }
 388
 389   dbus_message_iter_init_append(call_ptr->reply, &iter);
 390
 391   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 392   {
 393     goto fail_unref;
 394   }
 395
 396   if (!ladish_studios_iterate(call_ptr, &array_iter, get_studio_list_callback))
 397   {
 398     dbus_message_iter_close_container(&iter, &array_iter);
 399     if (call_ptr->reply == NULL)
 400       goto fail_unref;
 401
 402     /* studios_iterate or get_studio_list_callback() composed error reply */
 403     return;
 404   }
 405
 406   if (!dbus_message_iter_close_container(&iter, &array_iter))
 407   {
 408     goto fail_unref;
 409   }
 410
 411   return;
 412
 413 fail_unref:
 414   dbus_message_unref(call_ptr->reply);
 415   call_ptr->reply = NULL;
 416
 417 fail:
 418   log_error("Ran out of memory trying to construct method return");
 419 }
 420
 421 static void ladish_load_studio(struct dbus_method_call * call_ptr)
 422 {
 423   const char * name;
 424
 425   dbus_error_init(&g_dbus_error);
 426
 427   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 428   {
 429     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 430     dbus_error_free(&g_dbus_error);
 431     return;
 432   }
 433
 434   log_info("Load studio request (%s)", name);
 435
 436   if (ladish_command_load_studio(call_ptr, ladish_studio_get_cmd_queue(), name))
 437   {
 438     method_return_new_void(call_ptr);
 439   }
 440 }
 441
 442 static void ladish_delete_studio(struct dbus_method_call * call_ptr)
 443 {
 444   const char * name;
 445
 446   dbus_error_init(&g_dbus_error);
 447
 448   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 449   {
 450     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 451     dbus_error_free(&g_dbus_error);
 452     return;
 453   }
 454
 455   if (ladish_studio_delete(call_ptr, name))
 456   {
 457     method_return_new_void(call_ptr);
 458   }
 459 }
 460
 461 static void ladish_new_studio(struct dbus_method_call * call_ptr)
 462 {
 463   const char * name;
 464
 465   dbus_error_init(&g_dbus_error);
 466
 467   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 468   {
 469     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 470     dbus_error_free(&g_dbus_error);
 471     return;
 472   }
 473
 474   log_info("New studio request (%s)", name);
 475
 476   if (ladish_command_new_studio(call_ptr, ladish_studio_get_cmd_queue(), name))
 477   {
 478     method_return_new_void(call_ptr);
 479   }
 480 }
 481
 482 static void ladish_get_application_list(struct dbus_method_call * call_ptr)
 483 {
 484   DBusMessageIter iter;
 485   DBusMessageIter array_iter;
 486 #if 0
 487   DBusMessageIter struct_iter;
 488   DBusMessageIter dict_iter;
 489   struct list_head * node_ptr;
 490   struct lash_appdb_entry * entry_ptr;
 491 #endif
 492
 493   log_info("Getting applications list");
 494
 495   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 496   if (call_ptr->reply == NULL)
 497   {
 498     goto fail;
 499   }
 500
 501   dbus_message_iter_init_append(call_ptr->reply, &iter);
 502
 503   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 504   {
 505     goto fail_unref;
 506   }
 507
 508 #if 0
 509   list_for_each(node_ptr, &g_server->appdb)
 510   {
 511     entry_ptr = list_entry(node_ptr, struct lash_appdb_entry, siblings);
 512
 513     if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 514       goto fail_unref;
 515
 516     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, (const void *) &entry_ptr->name))
 517     {
 518       dbus_message_iter_close_container(&iter, &array_iter);
 519       goto fail_unref;
 520     }
 521
 522     if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 523       goto fail_unref;
 524
 525     if (!maybe_add_dict_entry_string(&dict_iter, "GenericName", entry_ptr->generic_name))
 526       goto fail_unref;
 527
 528     if (!maybe_add_dict_entry_string(&dict_iter, "Comment", entry_ptr->comment))
 529       goto fail_unref;
 530
 531     if (!maybe_add_dict_entry_string(&dict_iter, "Icon", entry_ptr->icon))
 532       goto fail_unref;
 533
 534     if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 535       goto fail_unref;
 536
 537     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
 538       goto fail_unref;
 539   }
 540 #endif
 541
 542   if (!dbus_message_iter_close_container(&iter, &array_iter))
 543   {
 544     goto fail_unref;
 545   }
 546
 547   return;
 548
 549 fail_unref:
 550   dbus_message_unref(call_ptr->reply);
 551   call_ptr->reply = NULL;
 552 fail:
 553   return;
 554 }
 555
 556 #define array_iter_ptr ((DBusMessageIter *)context)
 557
 558 bool room_template_list_filler(void * context, ladish_room_handle room)
 559 {
 560   DBusMessageIter struct_iter;
 561   DBusMessageIter dict_iter;
 562   const char * name;
 563
 564   name = ladish_room_get_name(room);
 565
 566   if (!dbus_message_iter_open_container(array_iter_ptr, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 567     return false;
 568
 569   if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &name))
 570     return false;
 571
 572   if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 573     return false;
 574
 575   if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
 576     return false;
 577
 578   if (!dbus_message_iter_close_container(array_iter_ptr, &struct_iter))
 579     return false;
 580
 581   return true;
 582 }
 583
 584 #undef array_iter_ptr
 585
 586 static void ladish_get_room_template_list(struct dbus_method_call * call_ptr)
 587 {
 588   DBusMessageIter iter, array_iter;
 589
 590   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 591   if (call_ptr->reply == NULL)
 592   {
 593     goto fail;
 594   }
 595
 596   dbus_message_iter_init_append(call_ptr->reply, &iter);
 597
 598   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
 599   {
 600     goto fail_unref;
 601   }
 602
 603   if (!room_templates_enum(&array_iter, room_template_list_filler))
 604   {
 605     goto fail_unref;
 606   }
 607
 608   if (!dbus_message_iter_close_container(&iter, &array_iter))
 609   {
 610     goto fail_unref;
 611   }
 612
 613   return;
 614
 615 fail_unref:
 616   dbus_message_unref(call_ptr->reply);
 617   call_ptr->reply = NULL;
 618
 619 fail:
 620   log_error("Ran out of memory trying to construct method return");
 621 }
 622
 623 static void ladish_delete_room_template(struct dbus_method_call * call_ptr)
 624 {
 625   const char * name;
 626
 627   dbus_error_init(&g_dbus_error);
 628
 629   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 630   {
 631     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 632     dbus_error_free(&g_dbus_error);
 633     return;
 634   }
 635
 636   log_info("Delete room request (%s)", name);
 637
 638   {
 639     method_return_new_void(call_ptr);
 640   }
 641 }
 642
 643 static void ladish_create_room_template(struct dbus_method_call * call_ptr)
 644 {
 645   const char * name;
 646
 647   dbus_error_init(&g_dbus_error);
 648
 649   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
 650   {
 651     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 652     dbus_error_free(&g_dbus_error);
 653     return;
 654   }
 655
 656   log_info("New room request (%s)", name);
 657
 658   {
 659     method_return_new_void(call_ptr);
 660   }
 661 }
 662
 663 static void ladish_exit(struct dbus_method_call * call_ptr)
 664 {
 665   log_info("Exit command received through D-Bus");
 666
 667   if (!ladish_command_exit(NULL, ladish_studio_get_cmd_queue()))
 668   { /* if queuing of command failed, force exit anyway,
 669        JACK server will be left started,
 670        but refusing exit command is worse */
 671     g_quit = true;
 672   }
 673
 674   method_return_new_void(call_ptr);
 675 }
 676
 677 void emit_studio_appeared(void)
 678 {
 679   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioAppeared", "");
 680 }
 681
 682 void emit_studio_disappeared(void)
 683 {
 684   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "StudioDisappeared", "");
 685 }
 686
 687 void emit_queue_execution_halted(void)
 688 {
 689   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "QueueExecutionHalted", "");
 690 }
 691
 692 void emit_clean_exit(void)
 693 {
 694   dbus_signal_emit(g_dbus_connection, CONTROL_OBJECT_PATH, INTERFACE_NAME, "CleanExit", "");
 695 }
 696
 697 METHOD_ARGS_BEGIN(IsStudioLoaded, "Check whether studio D-Bus object is present")
 698   METHOD_ARG_DESCRIBE_OUT("present", "b", "Whether studio D-Bus object is present")
 699 METHOD_ARGS_END
 700
 701 METHOD_ARGS_BEGIN(GetStudioList, "Get list of studios")
 702   METHOD_ARG_DESCRIBE_OUT("studio_list", "a(sa{sv})", "List of studios, name and properties")
 703 METHOD_ARGS_END
 704
 705 METHOD_ARGS_BEGIN(NewStudio, "New studio")
 706   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio, if empty name will be generated")
 707 METHOD_ARGS_END
 708
 709 METHOD_ARGS_BEGIN(LoadStudio, "Load studio")
 710   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to load")
 711   METHOD_ARG_DESCRIBE_IN("options", "a{sv}", "Load options")
 712 METHOD_ARGS_END
 713
 714 METHOD_ARGS_BEGIN(DeleteStudio, "Delete studio")
 715   METHOD_ARG_DESCRIBE_IN("studio_name", "s", "Name of studio to delete")
 716 METHOD_ARGS_END
 717
 718 METHOD_ARGS_BEGIN(GetApplicationList, "Get list of applications that can be launched")
 719   METHOD_ARG_DESCRIBE_OUT("applications", "a(sa{sv})", "List of applications, name and properties")
 720 METHOD_ARGS_END
 721
 722 METHOD_ARGS_BEGIN(GetRoomTemplateList, "Get list of room templates")
 723   METHOD_ARG_DESCRIBE_OUT("room_template_list", "a(sa{sv})", "List of room templates (name and properties)")
 724 METHOD_ARGS_END
 725
 726 METHOD_ARGS_BEGIN(CreateRoomTemplate, "New room template")
 727   METHOD_ARG_DESCRIBE_IN("room_template name", "s", "Name of the room template")
 728 METHOD_ARGS_END
 729
 730 METHOD_ARGS_BEGIN(DeleteRoomTemplate, "Delete room template")
 731   METHOD_ARG_DESCRIBE_IN("room_template_name", "s", "Name of room template to delete")
 732 METHOD_ARGS_END
 733
 734 METHOD_ARGS_BEGIN(Exit, "Tell ladish D-Bus service to exit")
 735 METHOD_ARGS_END
 736
 737 METHODS_BEGIN
 738   METHOD_DESCRIBE(IsStudioLoaded, ladish_is_studio_loaded)
 739   METHOD_DESCRIBE(GetStudioList, ladish_get_studio_list)
 740   METHOD_DESCRIBE(NewStudio, ladish_new_studio)
 741   METHOD_DESCRIBE(LoadStudio, ladish_load_studio)
 742   METHOD_DESCRIBE(DeleteStudio, ladish_delete_studio)
 743   METHOD_DESCRIBE(GetApplicationList, ladish_get_application_list)
 744   METHOD_DESCRIBE(GetRoomTemplateList, ladish_get_room_template_list)
 745   METHOD_DESCRIBE(CreateRoomTemplate, ladish_create_room_template)
 746   METHOD_DESCRIBE(DeleteRoomTemplate, ladish_delete_room_template)
 747   METHOD_DESCRIBE(Exit, ladish_exit)
 748 METHODS_END
 749
 750 SIGNAL_ARGS_BEGIN(StudioAppeared, "Studio D-Bus object appeared")
 751 SIGNAL_ARGS_END
 752
 753 SIGNAL_ARGS_BEGIN(StudioDisappeared, "Studio D-Bus object disappeared")
 754 SIGNAL_ARGS_END
 755
 756 SIGNAL_ARGS_BEGIN(QueueExecutionHalted, "Queue execution is halted because of error")
 757 SIGNAL_ARGS_END
 758
 759 SIGNAL_ARGS_BEGIN(CleanExit, "Exit was requested")
 760 SIGNAL_ARGS_END
 761
 762 SIGNALS_BEGIN
 763   SIGNAL_DESCRIBE(StudioAppeared)
 764   SIGNAL_DESCRIBE(StudioDisappeared)
 765   SIGNAL_DESCRIBE(QueueExecutionHalted)
 766   SIGNAL_DESCRIBE(CleanExit)
 767 SIGNALS_END
 768
 769 /*
 770  * Interface description.
 771  */
 772
 773 INTERFACE_BEGIN(g_lashd_interface_control, INTERFACE_NAME)
 774   INTERFACE_DEFAULT_HANDLER
 775   INTERFACE_EXPOSE_METHODS
 776   INTERFACE_EXPOSE_SIGNALS
 777 INTERFACE_END