daemon/studio.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010, 2011, 2012 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains part of the studio singleton object implementation
   9  * Other parts are in the other studio*.c files in same directory.
  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
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33
  34 #include "studio_internal.h"
  35 #include "../dbus_constants.h"
  36 #include "control.h"
  37 #include "../common/catdup.h"
  38 #include "../common/dirhelpers.h"
  39 #include "graph_dict.h"
  40 #include "graph_manager.h"
  41 #include "escape.h"
  42 #include "studio.h"
  43 #include "../proxies/notify_proxy.h"
  44
  45 #define STUDIOS_DIR "/studios/"
  46
  47 #define RECENT_STUDIOS_STORE_FILE "recent_studios"
  48 #define RECENT_STUDIOS_STORE_MAX_ITEMS 50
  49
  50 char * g_studios_dir;
  51 ladish_recent_store_handle g_studios_recent_store;
  52
  53 struct studio g_studio;
  54
  55 bool ladish_studio_name_generate(char ** name_ptr)
  56 {
  57   time_t now;
  58   char timestamp_str[26];
  59   char * name;
  60
  61   time(&now);
  62   //ctime_r(&now, timestamp_str);
  63   //timestamp_str[24] = 0;
  64   snprintf(timestamp_str, sizeof(timestamp_str), "%llu", (unsigned long long)now);
  65
  66   name = catdup("Studio ", timestamp_str);
  67   if (name == NULL)
  68   {
  69     log_error("catdup failed to create studio name");
  70     return false;
  71   }
  72
  73   *name_ptr = name;
  74   return true;
  75 }
  76
  77 bool ladish_studio_show(void)
  78 {
  79   cdbus_object_path object;
  80
  81   ASSERT(g_studio.name != NULL);
  82   ASSERT(!g_studio.announced);
  83
  84   object = cdbus_object_path_new(
  85     STUDIO_OBJECT_PATH,
  86     &g_interface_studio, &g_studio,
  87     &g_interface_patchbay, ladish_graph_get_dbus_context(g_studio.studio_graph),
  88     &g_iface_graph_dict, g_studio.studio_graph,
  89     &g_iface_graph_manager, g_studio.studio_graph,
  90     &g_iface_app_supervisor, g_studio.app_supervisor,
  91     NULL);
  92   if (object == NULL)
  93   {
  94     log_error("cdbus_object_path_new() failed");
  95     return false;
  96   }
  97
  98   if (!cdbus_object_path_register(cdbus_g_dbus_connection, object))
  99   {
 100     log_error("object_path_register() failed");
 101     cdbus_object_path_destroy(cdbus_g_dbus_connection, object);
 102     return false;
 103   }
 104
 105   log_info("Studio D-Bus object created. \"%s\"", g_studio.name);
 106
 107   g_studio.dbus_object = object;
 108
 109   emit_studio_appeared();
 110
 111   return true;
 112 }
 113
 114 void ladish_studio_announce(void)
 115 {
 116   ASSERT(!g_studio.announced);
 117
 118   /* notify the user that studio started successfully, but dont lie when jack was started externally */
 119   if (!g_studio.automatic)
 120   {
 121     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio loaded", NULL);
 122   }
 123
 124   g_studio.announced = true;
 125 }
 126
 127 bool ladish_studio_publish(void)
 128 {
 129   if (!ladish_studio_show())
 130   {
 131     return false;
 132   }
 133
 134   ladish_studio_announce();
 135   return true;
 136 }
 137
 138 void ladish_studio_clear(void)
 139 {
 140   ladish_graph_dump(g_studio.studio_graph);
 141   ladish_graph_dump(g_studio.jack_graph);
 142
 143   /* remove rooms that own clients in studio graph before clearing it */
 144   ladish_studio_remove_all_rooms();
 145
 146   ladish_graph_clear(g_studio.studio_graph, NULL);
 147   ladish_graph_clear(g_studio.jack_graph, NULL);
 148
 149   ladish_studio_jack_conf_clear();
 150
 151   g_studio.modified = false;
 152   g_studio.persisted = false;
 153
 154   ladish_app_supervisor_clear(g_studio.app_supervisor);
 155
 156   if (g_studio.dbus_object != NULL)
 157   {
 158     cdbus_object_path_destroy(cdbus_g_dbus_connection, g_studio.dbus_object);
 159     g_studio.dbus_object = NULL;
 160     emit_studio_disappeared();
 161   }
 162
 163   if (g_studio.announced)
 164   {
 165     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio unloaded", NULL);
 166     g_studio.announced = false;
 167   }
 168
 169   if (g_studio.name != NULL)
 170   {
 171     free(g_studio.name);
 172     g_studio.name = NULL;
 173   }
 174
 175   if (g_studio.filename != NULL)
 176   {
 177     free(g_studio.filename);
 178     g_studio.filename = NULL;
 179   }
 180 }
 181
 182 void ladish_studio_emit_started(void)
 183 {
 184   cdbus_signal_emit(cdbus_g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioStarted", "");
 185 }
 186
 187 void ladish_studio_emit_crashed(void)
 188 {
 189   cdbus_signal_emit(cdbus_g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioCrashed", "");
 190 }
 191
 192 void ladish_studio_emit_stopped(void)
 193 {
 194   cdbus_signal_emit(cdbus_g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioStopped", "");
 195 }
 196
 197 static bool ladish_studio_fill_room_info(DBusMessageIter * iter_ptr, ladish_room_handle room)
 198 {
 199   DBusMessageIter dict_iter;
 200   const char * name;
 201   uuid_t template_uuid;
 202   ladish_room_handle template;
 203   const char * template_name;
 204   const char * opath;
 205
 206   name = ladish_room_get_name(room);
 207   opath = ladish_room_get_opath(room);
 208
 209   if (!ladish_room_get_template_uuid(room, template_uuid))
 210   {
 211     template = NULL;
 212     template_name = NULL;
 213   }
 214   else
 215   {
 216     template = find_room_template_by_uuid(template_uuid);
 217     if (template != NULL)
 218     {
 219       template_name = ladish_room_get_name(template);
 220     }
 221     else
 222     {
 223       template_name = NULL;
 224     }
 225   }
 226
 227   if (!dbus_message_iter_append_basic(iter_ptr, DBUS_TYPE_STRING, &opath))
 228   {
 229     log_error("dbus_message_iter_append_basic() failed.");
 230     return false;
 231   }
 232
 233   if (!dbus_message_iter_open_container(iter_ptr, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
 234   {
 235     log_error("dbus_message_iter_open_container() failed.");
 236     return false;
 237   }
 238
 239   if (!cdbus_maybe_add_dict_entry_string(&dict_iter, "template", template_name))
 240   {
 241     log_error("dbus_maybe_add_dict_entry_string() failed.");
 242     return false;
 243   }
 244
 245   if (!cdbus_maybe_add_dict_entry_string(&dict_iter, "name", name))
 246   {
 247     log_error("dbus_maybe_add_dict_entry_string() failed.");
 248     return false;
 249   }
 250
 251   if (!dbus_message_iter_close_container(iter_ptr, &dict_iter))
 252   {
 253     log_error("dbus_message_iter_close_container() failed.");
 254     return false;
 255   }
 256
 257   return true;
 258 }
 259
 260 static void ladish_studio_emit_room_appeared(ladish_room_handle room)
 261 {
 262   DBusMessage * message_ptr;
 263   DBusMessageIter iter;
 264
 265   message_ptr = dbus_message_new_signal(STUDIO_OBJECT_PATH, IFACE_STUDIO, "RoomAppeared");
 266   if (message_ptr == NULL)
 267   {
 268     log_error("dbus_message_new_signal() failed.");
 269     return;
 270   }
 271
 272   dbus_message_iter_init_append(message_ptr, &iter);
 273
 274   if (ladish_studio_fill_room_info(&iter, room))
 275   {
 276     cdbus_signal_send(cdbus_g_dbus_connection, message_ptr);
 277   }
 278
 279   dbus_message_unref(message_ptr);
 280 }
 281
 282 void ladish_studio_emit_room_disappeared(ladish_room_handle room)
 283 {
 284   DBusMessage * message_ptr;
 285   DBusMessageIter iter;
 286
 287   message_ptr = dbus_message_new_signal(STUDIO_OBJECT_PATH, IFACE_STUDIO, "RoomDisappeared");
 288   if (message_ptr == NULL)
 289   {
 290     log_error("dbus_message_new_signal() failed.");
 291     return;
 292   }
 293
 294   dbus_message_iter_init_append(message_ptr, &iter);
 295
 296   if (ladish_studio_fill_room_info(&iter, room))
 297   {
 298     cdbus_signal_send(cdbus_g_dbus_connection, message_ptr);
 299   }
 300
 301   dbus_message_unref(message_ptr);
 302 }
 303
 304 void ladish_studio_room_appeared(ladish_room_handle room)
 305 {
 306   log_info("Room \"%s\" appeared", ladish_room_get_name(room));
 307   list_add_tail(ladish_room_get_list_node(room), &g_studio.rooms);
 308   ladish_studio_emit_room_appeared(room);
 309 }
 310
 311 void ladish_studio_room_disappeared(ladish_room_handle room)
 312 {
 313   log_info("Room \"%s\" disappeared", ladish_room_get_name(room));
 314   list_del(ladish_room_get_list_node(room));
 315   ladish_studio_emit_room_disappeared(room);
 316 }
 317
 318 bool
 319 ladish_studio_set_graph_connection_handlers(
 320   void * context,
 321   ladish_graph_handle graph,
 322   ladish_app_supervisor_handle UNUSED(app_supervisor))
 323 {
 324   ladish_virtualizer_set_graph_connection_handlers(context, graph);
 325   return true;                  /* iterate all graphs */
 326 }
 327
 328 void ladish_studio_on_event_jack_started(void)
 329 {
 330   if (!ladish_studio_fetch_jack_settings())
 331   {
 332     log_error("studio_fetch_jack_settings() failed.");
 333
 334     return;
 335   }
 336
 337   log_info("jack conf successfully retrieved");
 338   g_studio.jack_conf_valid = true;
 339
 340   if (!graph_proxy_create(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, false, false, &g_studio.jack_graph_proxy))
 341   {
 342     log_error("graph_proxy_create() failed for jackdbus");
 343   }
 344   else
 345   {
 346     if (!ladish_virtualizer_create(g_studio.jack_graph_proxy, g_studio.jack_graph, &g_studio.virtualizer))
 347     {
 348       log_error("ladish_virtualizer_create() failed.");
 349     }
 350     else
 351     {
 352       ladish_studio_iterate_virtual_graphs(g_studio.virtualizer, ladish_studio_set_graph_connection_handlers);
 353     }
 354
 355     if (!graph_proxy_activate(g_studio.jack_graph_proxy))
 356     {
 357       log_error("graph_proxy_activate() failed.");
 358     }
 359   }
 360
 361   ladish_app_supervisor_autorun(g_studio.app_supervisor);
 362
 363   ladish_studio_emit_started();
 364
 365   /* notify the user that studio started successfully, but dont lie when jack was started externally */
 366   if (!g_studio.automatic)
 367   {
 368     ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio started", NULL);
 369   }
 370 }
 371
 372 static void ladish_studio_on_jack_stopped_internal(void)
 373 {
 374   if (g_studio.virtualizer)
 375   {
 376     ladish_virtualizer_destroy(g_studio.virtualizer);
 377     g_studio.virtualizer = NULL;
 378   }
 379
 380   if (g_studio.jack_graph_proxy)
 381   {
 382     graph_proxy_destroy(g_studio.jack_graph_proxy);
 383     g_studio.jack_graph_proxy = NULL;
 384   }
 385 }
 386
 387 void ladish_studio_on_event_jack_stopped(void)
 388 {
 389   ladish_studio_emit_stopped();
 390   ladish_studio_on_jack_stopped_internal();
 391   ladish_notify_simple(LADISH_NOTIFY_URGENCY_NORMAL, "Studio stopped", NULL);
 392 }
 393
 394 void ladish_studio_handle_unexpected_jack_server_stop(void)
 395 {
 396   ladish_studio_emit_crashed();
 397   ladish_studio_on_jack_stopped_internal();
 398
 399   /* TODO: if user wants, restart jack server and reconnect all jack apps to it */
 400 }
 401
 402 static
 403 bool
 404 ladish_studio_hide_vgraph_non_virtual(
 405   void * UNUSED(context),
 406   ladish_graph_handle graph,
 407   ladish_app_supervisor_handle UNUSED(app_supervisor))
 408 {
 409   ladish_graph_hide_non_virtual(graph);
 410   return true;                  /* iterate all vgraphs */
 411 }
 412
 413 void ladish_studio_run(void)
 414 {
 415   bool state;
 416
 417   ladish_cqueue_run(&g_studio.cmd_queue);
 418   if (g_quit)
 419   { /* if quit is requested, don't bother to process external events */
 420     return;
 421   }
 422
 423   if (ladish_environment_consume_change(&g_studio.env_store, ladish_environment_jack_server_started, &state))
 424   {
 425     ladish_cqueue_clear(&g_studio.cmd_queue);
 426
 427     if (state)
 428     {
 429       ladish_environment_ignore(&g_studio.env_store, ladish_environment_jack_server_present);
 430
 431       if (g_studio.jack_graph_proxy != NULL)
 432       {
 433         log_error("Ignoring \"JACK started\" notification because it is already known that JACK is currently started.");
 434         return;
 435       }
 436
 437       /* Automatic studio creation on JACK server start */
 438       if (g_studio.dbus_object == NULL)
 439       {
 440         ASSERT(g_studio.name == NULL);
 441         if (!ladish_studio_name_generate(&g_studio.name))
 442         {
 443           log_error("studio_name_generate() failed.");
 444           return;
 445         }
 446
 447         g_studio.automatic = true;
 448
 449         ladish_studio_publish();
 450       }
 451
 452       ladish_studio_on_event_jack_started();
 453
 454       if (g_studio.automatic)
 455       {
 456         ladish_notify_simple(
 457           LADISH_NOTIFY_URGENCY_NORMAL,
 458           "Automatic studio created",
 459           "JACK server is started not by ladish daemon and there is no loaded studio, so a new studio is created and marked as started.");
 460       }
 461     }
 462     else
 463     {
 464       /* JACK stopped but this was not expected. When expected.
 465        * the change will be consumed by the run method of the studio stop command */
 466
 467       if (g_studio.jack_graph_proxy == NULL)
 468       {
 469         log_error("Ignoring \"JACK stopped\" notification because it is already known that JACK is currently stopped.");
 470         return;
 471       }
 472
 473       if (g_studio.automatic)
 474       {
 475         log_info("Unloading automatic studio.");
 476         ladish_command_unload_studio(NULL, &g_studio.cmd_queue);
 477
 478         ladish_studio_on_event_jack_stopped();
 479         return;
 480       }
 481
 482       log_error("JACK stopped unexpectedly.");
 483       log_error("Save your work, then unload and reload the studio.");
 484       ladish_notify_simple(
 485         LADISH_NOTIFY_URGENCY_HIGH,
 486         "Studio crashed",
 487         "JACK stopped unexpectedly.\n\n"
 488         "Save your work, then unload and reload the studio.");
 489       ladish_studio_handle_unexpected_jack_server_stop();
 490     }
 491   }
 492
 493   if (ladish_environment_consume_change(&g_studio.env_store, ladish_environment_jack_server_present, &state))
 494   {
 495     if (g_studio.jack_graph_proxy != NULL)
 496     {
 497       ladish_cqueue_clear(&g_studio.cmd_queue);
 498
 499       /* jack was started, this probably means that jackdbus has crashed */
 500       log_error("JACK disappeared unexpectedly. Maybe it crashed.");
 501       log_error("Save your work, then unload and reload the studio.");
 502       ladish_notify_simple(
 503         LADISH_NOTIFY_URGENCY_HIGH,
 504         "Studio crashed",
 505         "JACK disappeared unexpectedly. Maybe it crashed.\n\n"
 506         "Save your work, then unload and reload the studio.");
 507       ladish_environment_reset_stealth(&g_studio.env_store, ladish_environment_jack_server_started);
 508
 509       ladish_studio_iterate_virtual_graphs(NULL, ladish_studio_hide_vgraph_non_virtual);
 510
 511       ladish_studio_handle_unexpected_jack_server_stop();
 512     }
 513   }
 514
 515   ladish_environment_assert_consumed(&g_studio.env_store);
 516 }
 517
 518 static void ladish_studio_on_jack_server_started(void)
 519 {
 520   log_info("JACK server start detected.");
 521   ladish_environment_set(&g_studio.env_store, ladish_environment_jack_server_started);
 522 }
 523
 524 static void ladish_studio_on_jack_server_stopped(void)
 525 {
 526   log_info("JACK server stop detected.");
 527   ladish_environment_reset(&g_studio.env_store, ladish_environment_jack_server_started);
 528 }
 529
 530 static void ladish_studio_on_jack_server_appeared(void)
 531 {
 532   log_info("JACK controller appeared.");
 533   ladish_environment_set(&g_studio.env_store, ladish_environment_jack_server_present);
 534 }
 535
 536 static void ladish_studio_on_jack_server_disappeared(void)
 537 {
 538   log_info("JACK controller disappeared.");
 539   ladish_environment_reset(&g_studio.env_store, ladish_environment_jack_server_present);
 540 }
 541
 542 bool ladish_studio_init(void)
 543 {
 544   char * studios_recent_store_path;
 545
 546   log_info("studio object construct");
 547
 548   g_studios_dir = catdup(g_base_dir, STUDIOS_DIR);
 549   if (g_studios_dir == NULL)
 550   {
 551     log_error("catdup failed for '%s' and '%s'", g_base_dir, STUDIOS_DIR);
 552     goto fail;
 553   }
 554
 555   if (!ensure_dir_exist(g_studios_dir, 0700))
 556   {
 557     goto free_studios_dir;
 558   }
 559
 560   studios_recent_store_path = catdup(g_base_dir, "/" RECENT_STUDIOS_STORE_FILE);
 561   if (studios_recent_store_path == NULL)
 562   {
 563     log_error("catdup failed for to compose recent studios store file path");
 564     goto free_studios_dir;
 565   }
 566
 567   if (!ladish_recent_store_create(studios_recent_store_path, 10, &g_studios_recent_store))
 568   {
 569     free(studios_recent_store_path);
 570     goto free_studios_dir;
 571   }
 572
 573   free(studios_recent_store_path);
 574
 575   INIT_LIST_HEAD(&g_studio.all_connections);
 576   INIT_LIST_HEAD(&g_studio.all_ports);
 577   INIT_LIST_HEAD(&g_studio.all_clients);
 578   INIT_LIST_HEAD(&g_studio.jack_connections);
 579   INIT_LIST_HEAD(&g_studio.jack_ports);
 580   INIT_LIST_HEAD(&g_studio.jack_clients);
 581   INIT_LIST_HEAD(&g_studio.rooms);
 582   INIT_LIST_HEAD(&g_studio.clients);
 583   INIT_LIST_HEAD(&g_studio.ports);
 584
 585   INIT_LIST_HEAD(&g_studio.jack_conf);
 586   INIT_LIST_HEAD(&g_studio.jack_params);
 587
 588   g_studio.dbus_object = NULL;
 589   g_studio.announced = false;
 590   g_studio.name = NULL;
 591   g_studio.filename = NULL;
 592
 593   g_studio.room_count = 0;
 594
 595   if (!ladish_graph_create(&g_studio.jack_graph, NULL))
 596   {
 597     log_error("ladish_graph_create() failed to create jack graph object.");
 598     goto destroy_recent_store;
 599   }
 600
 601   if (!ladish_graph_create(&g_studio.studio_graph, STUDIO_OBJECT_PATH))
 602   {
 603     log_error("ladish_graph_create() failed to create studio graph object.");
 604     goto jack_graph_destroy;
 605   }
 606
 607   if (!ladish_app_supervisor_create(&g_studio.app_supervisor, STUDIO_OBJECT_PATH, "studio", g_studio.studio_graph, ladish_virtualizer_rename_app))
 608   {
 609     log_error("ladish_app_supervisor_create() failed.");
 610     goto studio_graph_destroy;
 611   }
 612
 613   ladish_cqueue_init(&g_studio.cmd_queue);
 614   ladish_environment_init(&g_studio.env_store);
 615
 616   if (!jack_proxy_init(
 617         ladish_studio_on_jack_server_started,
 618         ladish_studio_on_jack_server_stopped,
 619         ladish_studio_on_jack_server_appeared,
 620         ladish_studio_on_jack_server_disappeared))
 621   {
 622     log_error("jack_proxy_init() failed.");
 623     goto app_supervisor_destroy;
 624   }
 625
 626   return true;
 627
 628 app_supervisor_destroy:
 629   ladish_app_supervisor_destroy(g_studio.app_supervisor);
 630 studio_graph_destroy:
 631   ladish_graph_destroy(g_studio.studio_graph);
 632 jack_graph_destroy:
 633   ladish_graph_destroy(g_studio.jack_graph);
 634 destroy_recent_store:
 635   ladish_recent_store_destroy(g_studios_recent_store);
 636 free_studios_dir:
 637   free(g_studios_dir);
 638 fail:
 639   return false;
 640 }
 641
 642 void ladish_studio_uninit(void)
 643 {
 644   log_info("studio_uninit()");
 645
 646   jack_proxy_uninit();
 647
 648   ladish_cqueue_clear(&g_studio.cmd_queue);
 649
 650   ladish_graph_destroy(g_studio.studio_graph);
 651   ladish_graph_destroy(g_studio.jack_graph);
 652
 653   ladish_recent_store_destroy(g_studios_recent_store);
 654
 655   free(g_studios_dir);
 656
 657   log_info("studio object destroy");
 658 }
 659
 660 struct on_child_exit_context
 661 {
 662   pid_t pid;
 663   int exit_status;
 664   bool found;
 665 };
 666
 667 #define child_exit_context_ptr ((struct on_child_exit_context *)context)
 668
 669 static
 670 bool
 671 ladish_studio_on_child_exit_callback(
 672   void * context,
 673   ladish_graph_handle UNUSED(graph),
 674   ladish_app_supervisor_handle app_supervisor)
 675 {
 676   child_exit_context_ptr->found = ladish_app_supervisor_child_exit(app_supervisor, child_exit_context_ptr->pid, child_exit_context_ptr->exit_status);
 677   /* if child is found, return false - it will cause iteration to stop */
 678   /* if child is not found, return true - it will cause next supervisor to be checked */
 679   return !child_exit_context_ptr->found;
 680 }
 681
 682 #undef child_exit_context_ptr
 683
 684 void ladish_studio_on_child_exit(pid_t pid, int exit_status)
 685 {
 686   struct on_child_exit_context context;
 687
 688   context.pid = pid;
 689   context.exit_status = exit_status;
 690   context.found = false;
 691
 692   ladish_studio_iterate_virtual_graphs(&context, ladish_studio_on_child_exit_callback);
 693
 694   if (!context.found)
 695   {
 696     log_error("unknown child exit detected. pid is %llu", (unsigned long long)pid);
 697   }
 698 }
 699
 700 bool ladish_studio_is_loaded(void)
 701 {
 702   return g_studio.dbus_object != NULL && g_studio.announced;
 703 }
 704
 705 bool ladish_studio_is_started(void)
 706 {
 707   return ladish_environment_get(&g_studio.env_store, ladish_environment_jack_server_started);
 708 }
 709
 710 bool ladish_studio_compose_filename(const char * name, char ** filename_ptr_ptr, char ** backup_filename_ptr_ptr)
 711 {
 712   size_t len_dir;
 713   char * p;
 714   const char * src;
 715   char * filename_ptr;
 716   char * backup_filename_ptr = NULL;
 717
 718   len_dir = strlen(g_studios_dir);
 719
 720   filename_ptr = malloc(len_dir + 1 + strlen(name) * 3 + 4 + 1);
 721   if (filename_ptr == NULL)
 722   {
 723     log_error("malloc failed to allocate memory for studio file path");
 724     return false;
 725   }
 726
 727   if (backup_filename_ptr_ptr != NULL)
 728   {
 729     backup_filename_ptr = malloc(len_dir + 1 + strlen(name) * 3 + 4 + 4 + 1);
 730     if (backup_filename_ptr == NULL)
 731     {
 732       log_error("malloc failed to allocate memory for studio backup file path");
 733       free(filename_ptr);
 734       return false;
 735     }
 736   }
 737
 738   p = filename_ptr;
 739   memcpy(p, g_studios_dir, len_dir);
 740   p += len_dir;
 741
 742   *p++ = '/';
 743
 744   src = name;
 745   escape(&src, &p, LADISH_ESCAPE_FLAG_ALL);
 746   strcpy(p, ".xml");
 747
 748   *filename_ptr_ptr = filename_ptr;
 749
 750   if (backup_filename_ptr_ptr != NULL)
 751   {
 752     strcpy(backup_filename_ptr, filename_ptr);
 753     strcat(backup_filename_ptr, ".bak");
 754     *backup_filename_ptr_ptr = backup_filename_ptr;
 755   }
 756
 757   return true;
 758 }
 759
 760 struct ladish_cqueue * ladish_studio_get_cmd_queue(void)
 761 {
 762   return &g_studio.cmd_queue;
 763 }
 764
 765 ladish_virtualizer_handle ladish_studio_get_virtualizer(void)
 766 {
 767   return g_studio.virtualizer;
 768 }
 769
 770 ladish_graph_handle ladish_studio_get_jack_graph(void)
 771 {
 772   return g_studio.jack_graph;
 773 }
 774
 775 ladish_graph_handle ladish_studio_get_studio_graph(void)
 776 {
 777   return g_studio.studio_graph;
 778 }
 779
 780 ladish_app_supervisor_handle ladish_studio_get_studio_app_supervisor(void)
 781 {
 782   return g_studio.app_supervisor;
 783 }
 784
 785 struct ladish_studio_app_supervisor_match_opath_context
 786 {
 787   const char * opath;
 788   ladish_app_supervisor_handle supervisor;
 789 };
 790
 791 #define iterate_context_ptr ((struct ladish_studio_app_supervisor_match_opath_context *)context)
 792
 793 static bool ladish_studio_app_supervisor_match_opath(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 794 {
 795   ASSERT(strcmp(ladish_app_supervisor_get_opath(app_supervisor), ladish_graph_get_opath(graph)) == 0);
 796   if (strcmp(ladish_app_supervisor_get_opath(app_supervisor), iterate_context_ptr->opath) == 0)
 797   {
 798     ASSERT(iterate_context_ptr->supervisor == NULL);
 799     iterate_context_ptr->supervisor = app_supervisor;
 800     return false;               /* stop iteration */
 801   }
 802
 803   return true;                  /* continue iteration */
 804 }
 805
 806 #undef iterate_context_ptr
 807
 808 ladish_app_supervisor_handle ladish_studio_find_app_supervisor(const char * opath)
 809 {
 810   struct ladish_studio_app_supervisor_match_opath_context ctx;
 811
 812   ctx.opath = opath;
 813   ctx.supervisor = NULL;
 814   ladish_studio_iterate_virtual_graphs(&ctx, ladish_studio_app_supervisor_match_opath);
 815   return ctx.supervisor;
 816 }
 817
 818 struct ladish_studio_app_supervisor_match_app_context
 819 {
 820   uuid_t app_uuid;
 821   ladish_app_handle app;
 822 };
 823
 824 #define iterate_context_ptr ((struct ladish_studio_app_supervisor_match_app_context *)context)
 825
 826 static bool ladish_studio_app_supervisor_match_app(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
 827 {
 828   ASSERT(strcmp(ladish_app_supervisor_get_opath(app_supervisor), ladish_graph_get_opath(graph)) == 0);
 829   ASSERT(iterate_context_ptr->app == NULL);
 830
 831   iterate_context_ptr->app = ladish_app_supervisor_find_app_by_uuid(app_supervisor, iterate_context_ptr->app_uuid);
 832   if (iterate_context_ptr->app != NULL)
 833   {
 834     return false;               /* stop iteration */
 835   }
 836
 837   return true;                  /* continue iteration */
 838 }
 839
 840 #undef iterate_context_ptr
 841
 842 ladish_app_handle ladish_studio_find_app_by_uuid(const uuid_t app_uuid)
 843 {
 844   struct ladish_studio_app_supervisor_match_app_context ctx;
 845
 846   uuid_copy(ctx.app_uuid, app_uuid);
 847   ctx.app = NULL;
 848   ladish_studio_iterate_virtual_graphs(&ctx, ladish_studio_app_supervisor_match_app);
 849   return ctx.app;
 850 }
 851
 852 bool ladish_studio_delete(void * call_ptr, const char * studio_name)
 853 {
 854   char * filename;
 855   char * bak_filename;
 856   struct stat st;
 857   bool ret;
 858
 859   ret = false;
 860
 861   if (!ladish_studio_compose_filename(studio_name, &filename, &bak_filename))
 862   {
 863     cdbus_error(call_ptr, DBUS_ERROR_FAILED, "failed to compose studio filename");
 864     goto exit;
 865   }
 866
 867   log_info("Deleting studio ('%s')", filename);
 868
 869   if (unlink(filename) != 0)
 870   {
 871     cdbus_error(call_ptr, DBUS_ERROR_FAILED, "unlink(%s) failed: %d (%s)", filename, errno, strerror(errno));
 872     goto free;
 873   }
 874
 875   /* try to delete the backup file */
 876   if (stat(bak_filename, &st) == 0)
 877   {
 878     if (unlink(bak_filename) != 0)
 879     {
 880       /* failing to delete backup file will not case delete command failure */
 881       log_error("unlink(%s) failed: %d (%s)", bak_filename, errno, strerror(errno));
 882     }
 883   }
 884
 885   ret = true;
 886
 887 free:
 888   free(filename);
 889   free(bak_filename);
 890 exit:
 891   return ret;
 892 }
 893
 894 bool
 895 ladish_studio_iterate_virtual_graphs(
 896   void * context,
 897   bool (* callback)(
 898     void * context,
 899     ladish_graph_handle graph,
 900     ladish_app_supervisor_handle app_supervisor))
 901 {
 902   struct list_head * node_ptr;
 903   ladish_room_handle room;
 904   ladish_app_supervisor_handle room_app_supervisor;
 905   ladish_graph_handle room_graph;
 906
 907   if (!callback(context, g_studio.studio_graph, g_studio.app_supervisor))
 908   {
 909     return false;
 910   }
 911
 912   list_for_each(node_ptr, &g_studio.rooms)
 913   {
 914     room = ladish_room_from_list_node(node_ptr);
 915     room_app_supervisor = ladish_room_get_app_supervisor(room);
 916     ASSERT(room_app_supervisor != NULL);
 917     room_graph = ladish_room_get_graph(room);
 918
 919     if (!callback(context, room_graph, room_app_supervisor))
 920     {
 921       return false;
 922     }
 923   }
 924
 925   return true;
 926 }
 927
 928 bool
 929 ladish_studio_iterate_rooms(
 930   void * context,
 931   bool (* callback)(
 932     void * context,
 933     ladish_room_handle room))
 934 {
 935   struct list_head * node_ptr;
 936   ladish_room_handle room;
 937
 938   list_for_each(node_ptr, &g_studio.rooms)
 939   {
 940     room = ladish_room_from_list_node(node_ptr);
 941     if (!callback(context, room))
 942     {
 943       return false;
 944     }
 945   }
 946
 947   return true;
 948 }
 949
 950 bool ladish_studio_has_rooms(void)
 951 {
 952   return !list_empty(&g_studio.rooms);
 953 }
 954
 955 static
 956 bool
 957 ladish_studio_stop_app_supervisor(
 958   void * UNUSED(context),
 959   ladish_graph_handle UNUSED(graph),
 960   ladish_app_supervisor_handle app_supervisor)
 961 {
 962   ladish_app_supervisor_stop(app_supervisor);
 963   return true;                  /* iterate all supervisors */
 964 }
 965
 966 void ladish_studio_stop_app_supervisors(void)
 967 {
 968   ladish_studio_iterate_virtual_graphs(NULL, ladish_studio_stop_app_supervisor);
 969 }
 970
 971 void ladish_studio_emit_renamed(void)
 972 {
 973   cdbus_signal_emit(cdbus_g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "StudioRenamed", "s", &g_studio.name);
 974 }
 975
 976 unsigned int ladish_studio_get_room_index(void)
 977 {
 978   return ++g_studio.room_count;
 979 }
 980
 981 void ladish_studio_release_room_index(unsigned int index)
 982 {
 983   if (index == g_studio.room_count)
 984   {
 985     g_studio.room_count--;
 986   }
 987 }
 988
 989 void ladish_studio_remove_all_rooms(void)
 990 {
 991   while (!list_empty(&g_studio.rooms))
 992   {
 993     ladish_room_destroy(ladish_room_from_list_node(g_studio.rooms.next));
 994   }
 995 }
 996
 997 ladish_room_handle ladish_studio_find_room_by_uuid(const uuid_t room_uuid_ptr)
 998 {
 999   struct list_head * node_ptr;
1000   ladish_room_handle room;
1001   uuid_t room_uuid;
1002
1003   list_for_each(node_ptr, &g_studio.rooms)
1004   {
1005     room = ladish_room_from_list_node(node_ptr);
1006     ladish_room_get_uuid(room, room_uuid);
1007     if (uuid_compare(room_uuid, room_uuid_ptr) == 0)
1008     {
1009       return room;
1010     }
1011   }
1012
1013   return NULL;
1014 }
1015
1016 bool ladish_studio_check_room_name(const char * room_name)
1017 {
1018   struct list_head * node_ptr;
1019   ladish_room_handle room;
1020
1021   list_for_each(node_ptr, &g_studio.rooms)
1022   {
1023     room = ladish_room_from_list_node(node_ptr);
1024     if (strcmp(ladish_room_get_name(room), room_name) == 0)
1025     {
1026       return true;
1027     }
1028   }
1029
1030   return false;
1031 }
1032
1033 /**********************************************************************************/
1034 /*                                D-Bus methods                                   */
1035 /**********************************************************************************/
1036
1037 static void ladish_studio_dbus_get_name(struct cdbus_method_call * call_ptr)
1038 {
1039   cdbus_method_return_new_single(call_ptr, DBUS_TYPE_STRING, &g_studio.name);
1040 }
1041
1042 static void ladish_studio_dbus_rename(struct cdbus_method_call * call_ptr)
1043 {
1044   const char * new_name;
1045   char * new_name_dup;
1046
1047   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &new_name, DBUS_TYPE_INVALID))
1048   {
1049     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1050     dbus_error_free(&cdbus_g_dbus_error);
1051     return;
1052   }
1053
1054   log_info("Rename studio request (%s)", new_name);
1055
1056   new_name_dup = strdup(new_name);
1057   if (new_name_dup == NULL)
1058   {
1059     cdbus_error(call_ptr, DBUS_ERROR_FAILED, "strdup() failed to allocate new name.");
1060     return;
1061   }
1062
1063   free(g_studio.name);
1064   g_studio.name = new_name_dup;
1065
1066   cdbus_method_return_new_void(call_ptr);
1067   ladish_studio_emit_renamed();
1068 }
1069
1070 static void ladish_studio_dbus_save(struct cdbus_method_call * call_ptr)
1071 {
1072   log_info("Save studio request");
1073
1074   if (ladish_command_save_studio(call_ptr, &g_studio.cmd_queue, g_studio.name))
1075   {
1076     cdbus_method_return_new_void(call_ptr);
1077   }
1078 }
1079
1080 static void ladish_studio_dbus_save_as(struct cdbus_method_call * call_ptr)
1081 {
1082   const char * new_name;
1083
1084   log_info("SaveAs studio request");
1085
1086   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &new_name, DBUS_TYPE_INVALID))
1087   {
1088     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1089     dbus_error_free(&cdbus_g_dbus_error);
1090     return;
1091   }
1092
1093   if (ladish_command_save_studio(call_ptr, &g_studio.cmd_queue, new_name))
1094   {
1095     cdbus_method_return_new_void(call_ptr);
1096   }
1097 }
1098
1099 static void ladish_studio_dbus_unload(struct cdbus_method_call * call_ptr)
1100 {
1101   log_info("Unload studio request");
1102
1103   if (ladish_command_unload_studio(call_ptr, &g_studio.cmd_queue))
1104   {
1105     cdbus_method_return_new_void(call_ptr);
1106   }
1107 }
1108
1109 static void ladish_studio_dbus_stop(struct cdbus_method_call * call_ptr)
1110 {
1111   log_info("Stop studio request");
1112
1113   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because user knows about it */
1114
1115   if (ladish_command_stop_studio(call_ptr, &g_studio.cmd_queue))
1116   {
1117     cdbus_method_return_new_void(call_ptr);
1118   }
1119 }
1120
1121 static void ladish_studio_dbus_start(struct cdbus_method_call * call_ptr)
1122 {
1123   log_info("Start studio request");
1124
1125   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because user knows about it */
1126
1127   if (ladish_command_start_studio(call_ptr, &g_studio.cmd_queue))
1128   {
1129     cdbus_method_return_new_void(call_ptr);
1130   }
1131 }
1132
1133 static void ladish_studio_dbus_is_started(struct cdbus_method_call * call_ptr)
1134 {
1135   dbus_bool_t started;
1136
1137   started = g_studio.jack_graph_proxy != NULL;
1138
1139   cdbus_method_return_new_single(call_ptr, DBUS_TYPE_BOOLEAN, &started);
1140 }
1141
1142 static void ladish_studio_dbus_create_room(struct cdbus_method_call * call_ptr)
1143 {
1144   const char * room_name;
1145   const char * template_name;
1146
1147   dbus_error_init(&cdbus_g_dbus_error);
1148
1149   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &room_name, DBUS_TYPE_STRING, &template_name, DBUS_TYPE_INVALID))
1150   {
1151     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1152     dbus_error_free(&cdbus_g_dbus_error);
1153     return;
1154   }
1155
1156   if (ladish_command_create_room(call_ptr, ladish_studio_get_cmd_queue(), room_name, template_name))
1157   {
1158     cdbus_method_return_new_void(call_ptr);
1159   }
1160 }
1161
1162 static void ladish_studio_dbus_get_room_list(struct cdbus_method_call * call_ptr)
1163 {
1164   DBusMessageIter iter, array_iter;
1165   DBusMessageIter struct_iter;
1166   struct list_head * node_ptr;
1167   ladish_room_handle room;
1168
1169   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
1170   if (call_ptr->reply == NULL)
1171   {
1172     goto fail;
1173   }
1174
1175   dbus_message_iter_init_append(call_ptr->reply, &iter);
1176
1177   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
1178   {
1179     goto fail_unref;
1180   }
1181
1182   list_for_each(node_ptr, &g_studio.rooms)
1183   {
1184     room = ladish_room_from_list_node(node_ptr);
1185
1186     if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
1187       goto fail_unref;
1188
1189     if (!ladish_studio_fill_room_info(&struct_iter, room))
1190       goto fail_unref;
1191
1192     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
1193       goto fail_unref;
1194   }
1195
1196   if (!dbus_message_iter_close_container(&iter, &array_iter))
1197   {
1198     goto fail_unref;
1199   }
1200
1201   return;
1202
1203 fail_unref:
1204   dbus_message_unref(call_ptr->reply);
1205   call_ptr->reply = NULL;
1206
1207 fail:
1208   log_error("Ran out of memory trying to construct method return");
1209 }
1210
1211 static void ladish_studio_dbus_delete_room(struct cdbus_method_call * call_ptr)
1212 {
1213   const char * name;
1214
1215   dbus_error_init(&cdbus_g_dbus_error);
1216
1217   if (!dbus_message_get_args(call_ptr->message, &cdbus_g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
1218   {
1219     cdbus_error(call_ptr, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1220     dbus_error_free(&cdbus_g_dbus_error);
1221     return;
1222   }
1223
1224   if (ladish_command_delete_room(call_ptr, ladish_studio_get_cmd_queue(), name))
1225   {
1226     cdbus_method_return_new_void(call_ptr);
1227   }
1228 }
1229
1230 CDBUS_METHOD_ARGS_BEGIN(GetName, "Get studio name")
1231   CDBUS_METHOD_ARG_DESCRIBE_OUT("studio_name", "s", "Name of studio")
1232 CDBUS_METHOD_ARGS_END
1233
1234 CDBUS_METHOD_ARGS_BEGIN(Rename, "Rename studio")
1235   CDBUS_METHOD_ARG_DESCRIBE_IN("studio_name", "s", "New name")
1236 CDBUS_METHOD_ARGS_END
1237
1238 CDBUS_METHOD_ARGS_BEGIN(Save, "Save studio")
1239 CDBUS_METHOD_ARGS_END
1240
1241 CDBUS_METHOD_ARGS_BEGIN(SaveAs, "SaveAs studio")
1242   CDBUS_METHOD_ARG_DESCRIBE_IN("studio_name", "s", "New name")
1243 CDBUS_METHOD_ARGS_END
1244
1245 CDBUS_METHOD_ARGS_BEGIN(Unload, "Unload studio")
1246 CDBUS_METHOD_ARGS_END
1247
1248 CDBUS_METHOD_ARGS_BEGIN(Start, "Start studio")
1249 CDBUS_METHOD_ARGS_END
1250
1251 CDBUS_METHOD_ARGS_BEGIN(Stop, "Stop studio")
1252 CDBUS_METHOD_ARGS_END
1253
1254 CDBUS_METHOD_ARGS_BEGIN(IsStarted, "Check whether studio is started")
1255   CDBUS_METHOD_ARG_DESCRIBE_OUT("started", "b", "Whether studio is started")
1256 CDBUS_METHOD_ARGS_END
1257
1258 CDBUS_METHOD_ARGS_BEGIN(CreateRoom, "Create new studio room")
1259   CDBUS_METHOD_ARG_DESCRIBE_IN("room_name", "s", "Studio room name")
1260   CDBUS_METHOD_ARG_DESCRIBE_IN("room_template_name", "s", "Room template name")
1261 CDBUS_METHOD_ARGS_END
1262
1263 CDBUS_METHOD_ARGS_BEGIN(GetRoomList, "Get list of rooms in this studio")
1264   CDBUS_METHOD_ARG_DESCRIBE_OUT("room_list", "a(sa{sv})", "List of studio rooms: opaths and properties")
1265 CDBUS_METHOD_ARGS_END
1266
1267 CDBUS_METHOD_ARGS_BEGIN(DeleteRoom, "Delete studio room")
1268   CDBUS_METHOD_ARG_DESCRIBE_IN("room_name", "s", "Name of studio room to delete")
1269 CDBUS_METHOD_ARGS_END
1270
1271 CDBUS_METHODS_BEGIN
1272   CDBUS_METHOD_DESCRIBE(GetName, ladish_studio_dbus_get_name)          /* sync */
1273   CDBUS_METHOD_DESCRIBE(Rename, ladish_studio_dbus_rename)             /* sync */
1274   CDBUS_METHOD_DESCRIBE(Save, ladish_studio_dbus_save)                 /* async */
1275   CDBUS_METHOD_DESCRIBE(SaveAs, ladish_studio_dbus_save_as)            /* async */
1276   CDBUS_METHOD_DESCRIBE(Unload, ladish_studio_dbus_unload)             /* async */
1277   CDBUS_METHOD_DESCRIBE(Start, ladish_studio_dbus_start)               /* async */
1278   CDBUS_METHOD_DESCRIBE(Stop, ladish_studio_dbus_stop)                 /* async */
1279   CDBUS_METHOD_DESCRIBE(IsStarted, ladish_studio_dbus_is_started)      /* sync */
1280   CDBUS_METHOD_DESCRIBE(CreateRoom, ladish_studio_dbus_create_room)    /* async */
1281   CDBUS_METHOD_DESCRIBE(GetRoomList, ladish_studio_dbus_get_room_list) /* sync */
1282   CDBUS_METHOD_DESCRIBE(DeleteRoom, ladish_studio_dbus_delete_room)    /* async */
1283 CDBUS_METHODS_END
1284
1285 CDBUS_SIGNAL_ARGS_BEGIN(StudioRenamed, "Studio name changed")
1286   CDBUS_SIGNAL_ARG_DESCRIBE("studio_name", "s", "New studio name")
1287 CDBUS_SIGNAL_ARGS_END
1288
1289 CDBUS_SIGNAL_ARGS_BEGIN(StudioStarted, "Studio started")
1290 CDBUS_SIGNAL_ARGS_END
1291
1292 CDBUS_SIGNAL_ARGS_BEGIN(StudioCrashed, "Studio crashed")
1293 CDBUS_SIGNAL_ARGS_END
1294
1295 CDBUS_SIGNAL_ARGS_BEGIN(StudioStopped, "Studio stopped")
1296 CDBUS_SIGNAL_ARGS_END
1297
1298 CDBUS_SIGNAL_ARGS_BEGIN(RoomAppeared, "Room D-Bus object appeared")
1299   CDBUS_SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1300   CDBUS_SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1301 CDBUS_SIGNAL_ARGS_END
1302
1303 CDBUS_SIGNAL_ARGS_BEGIN(RoomChanged, "Room D-Bus object changed")
1304   CDBUS_SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1305   CDBUS_SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1306 CDBUS_SIGNAL_ARGS_END
1307
1308 CDBUS_SIGNAL_ARGS_BEGIN(RoomDisappeared, "Room D-Bus object disappeared")
1309   CDBUS_SIGNAL_ARG_DESCRIBE("opath", "s", "room object path")
1310   CDBUS_SIGNAL_ARG_DESCRIBE("properties", "a{sv}", "room properties")
1311 CDBUS_SIGNAL_ARGS_END
1312
1313 CDBUS_SIGNALS_BEGIN
1314   CDBUS_SIGNAL_DESCRIBE(StudioRenamed)
1315   CDBUS_SIGNAL_DESCRIBE(StudioStarted)
1316   CDBUS_SIGNAL_DESCRIBE(StudioCrashed)
1317   CDBUS_SIGNAL_DESCRIBE(StudioStopped)
1318   CDBUS_SIGNAL_DESCRIBE(RoomAppeared)
1319   CDBUS_SIGNAL_DESCRIBE(RoomDisappeared)
1320   CDBUS_SIGNAL_DESCRIBE(RoomChanged)
1321 CDBUS_SIGNALS_END
1322
1323 CDBUS_INTERFACE_DEFAULT_HANDLER_METHODS_AND_SIGNALS(g_interface_studio, IFACE_STUDIO)