server/vcd_dbus.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <dbus/dbus.h>
  18 #include "vcd_client_data.h"
  19 #include "vcd_dbus.h"
  20 #include "vcd_dbus_server.h"
  21 #include "vcd_main.h"
  22
  23
  24 static DBusConnection* g_conn_sender = NULL;
  25 static DBusConnection* g_conn_listener = NULL;
  26
  27 static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
  28
  29 static int g_waiting_time = 3000;
  30
  31 static int g_volume_count = 0;
  32
  33
  34 static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type)
  35 {
  36         char service_name[64] = {0,};
  37         char object_path[64] = {0,};
  38         char target_if_name[128] = {0,};
  39
  40         if (VCD_CLIENT_TYPE_NORMAL == type) {
  41                 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
  42                 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
  43                 snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_INTERFACE);
  44         } else if (VCD_CLIENT_TYPE_WIDGET == type) {
  45                 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
  46                 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
  47                 snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
  48         } else if (VCD_CLIENT_TYPE_MANAGER == type) {
  49                 snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
  50                 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
  51                 snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
  52         } else {
  53                 return NULL;
  54         }
  55
  56         return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
  57 }
  58
  59 int vcd_dbus_reconnect()
  60 {
  61         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
  62         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
  63         SLOG(LOG_WARN, TAG_VCD, "[DBUS] Sender(%s) Listener(%s)",
  64                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
  65
  66         if (false == sender_connected || false == listener_connected) {
  67                 vcd_dbus_close_connection();
  68
  69                 if (0 != vcd_dbus_open_connection()) {
  70                         SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to reconnect");
  71                         return -1;
  72                 }
  73
  74                 SLOG(LOG_DEBUG, TAG_VCD, "[DBUS] Reconnect");
  75         }
  76
  77         return 0;
  78 }
  79
  80 static int __dbus_check()
  81 {
  82         if (NULL == g_conn_sender) {
  83                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] NULL connection");
  84                 return vcd_dbus_reconnect();
  85         }
  86         return 0;
  87 }
  88
  89 int vcdc_send_hello(int pid, vcd_client_type_e type)
  90 {
  91         if (0 != __dbus_check()) {
  92                 return VCD_ERROR_OPERATION_FAILED;
  93         }
  94
  95         DBusMessage* msg = NULL;
  96
  97         if (VCD_CLIENT_TYPE_NORMAL == type) {
  98                 msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL);
  99         } else if (VCD_CLIENT_TYPE_WIDGET == type) {
 100                 msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET);
 101         } else if (VCD_CLIENT_TYPE_MANAGER == type) {
 102                 msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
 103         } else {
 104                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
 105                 return -1;
 106         }
 107
 108         if (NULL == msg) {
 109                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 110                 return VCD_ERROR_OUT_OF_MEMORY;
 111         }
 112
 113         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 114
 115         DBusError err;
 116         dbus_error_init(&err);
 117
 118         DBusMessage* result_msg;
 119         int result = -1;
 120
 121         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 122         dbus_message_unref(msg);
 123
 124         if (dbus_error_is_set(&err)) {
 125                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
 126                 if (NULL != err.name) {
 127                         if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
 128                                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
 129                                 dbus_error_free(&err);
 130                                 return 0;
 131                         }
 132                 }
 133                 dbus_error_free(&err);
 134         }
 135
 136         if (NULL != result_msg) {
 137                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 138
 139                 if (dbus_error_is_set(&err)) {
 140                         SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
 141                         dbus_error_free(&err);
 142                         result = VCD_ERROR_OPERATION_FAILED;
 143                 }
 144
 145                 dbus_message_unref(result_msg);
 146         } else {
 147                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
 148         }
 149
 150         return result;
 151 }
 152
 153 int vcdc_send_show_tooltip(int pid, bool show)
 154 {
 155         if (0 != __dbus_check()) {
 156                 return VCD_ERROR_OPERATION_FAILED;
 157         }
 158
 159         if (0 > pid) {
 160                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid");
 161                 return -1;
 162         }
 163
 164         char service_name[64] = {0, };
 165         memset(service_name, 0, 64);
 166         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 167
 168         char target_if_name[128] = {0, };
 169         snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
 170
 171         DBusMessage* msg;
 172
 173         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
 174
 175         msg = dbus_message_new_method_call(
 176                           service_name,
 177                           VC_WIDGET_SERVICE_OBJECT_PATH,
 178                           target_if_name,
 179                           VCD_WIDGET_METHOD_SHOW_TOOLTIP);
 180
 181         if (NULL == msg) {
 182                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 183                 return VCD_ERROR_OUT_OF_MEMORY;
 184         }
 185
 186         int temp = (int)show;
 187
 188         DBusMessageIter args;
 189         dbus_message_iter_init_append(msg, &args);
 190
 191         /* Append pid & type */
 192         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &pid);
 193         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
 194
 195         dbus_message_set_no_reply(msg, TRUE);
 196
 197         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 198                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 199                 return VCD_ERROR_OPERATION_FAILED;
 200         } else {
 201                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 202                 dbus_connection_flush(g_conn_sender);
 203         }
 204
 205         dbus_message_unref(msg);
 206
 207         return 0;
 208 }
 209
 210 int vcdc_send_set_volume(int manger_pid, float volume)
 211 {
 212         if (0 != __dbus_check()) {
 213                 return VCD_ERROR_OPERATION_FAILED;
 214         }
 215
 216         DBusMessage* msg = NULL;
 217
 218         /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */
 219
 220         msg = dbus_message_new_signal(
 221                 VC_MANAGER_SERVICE_OBJECT_PATH,
 222                 VC_MANAGER_SERVICE_INTERFACE,
 223                 VCD_MANAGER_METHOD_SET_VOLUME);
 224
 225         if (NULL == msg) {
 226                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 227                 return VCD_ERROR_OUT_OF_MEMORY;
 228         }
 229
 230         dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
 231
 232         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 233                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 234                 dbus_message_unref(msg);
 235                 return -1;
 236         } else {
 237                 if (10 == g_volume_count) {
 238                         SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send set volume : pid(%d), volume(%f)", manger_pid, volume);
 239                         g_volume_count = 0;
 240                 }
 241
 242                 dbus_connection_flush(g_conn_sender);
 243
 244                 g_volume_count++;
 245         }
 246
 247         dbus_message_unref(msg);
 248
 249         return 0;
 250 }
 251
 252 int vcdc_send_result(int pid, int manager_pid, int cmd_type)
 253 {
 254         if (0 != __dbus_check()) {
 255                 return VCD_ERROR_OPERATION_FAILED;
 256         }
 257
 258         DBusMessage* msg = NULL;
 259
 260         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
 261
 262         switch (cmd_type) {
 263         case VC_COMMAND_TYPE_FOREGROUND:
 264         case VC_COMMAND_TYPE_BACKGROUND:
 265                 if (pid == manager_pid) {
 266                         msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 267                 } else {
 268                         msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL);
 269                 }
 270                 break;
 271         case VC_COMMAND_TYPE_WIDGET:
 272                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, VCD_CLIENT_TYPE_WIDGET);
 273                 break;
 274         case VC_COMMAND_TYPE_SYSTEM:
 275         case VC_COMMAND_TYPE_SYSTEM_BACKGROUND:
 276         case VC_COMMAND_TYPE_EXCLUSIVE:
 277                 msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 278                 break;
 279
 280         default:
 281                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
 282                 return -1;
 283         }
 284
 285         if (NULL == msg) {
 286                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 287                 return VCD_ERROR_OUT_OF_MEMORY;
 288         }
 289
 290         dbus_message_set_no_reply(msg, TRUE);
 291
 292         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 293                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 294                 return VCD_ERROR_OPERATION_FAILED;
 295         } else {
 296                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 297                 dbus_connection_flush(g_conn_sender);
 298         }
 299
 300         dbus_message_unref(msg);
 301
 302         return 0;
 303 }
 304
 305 int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
 306 {
 307         if (0 != __dbus_check()) {
 308                 return VCD_ERROR_OPERATION_FAILED;
 309         }
 310
 311         DBusError err;
 312         dbus_error_init(&err);
 313
 314         DBusMessage* msg = NULL;
 315
 316         msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
 317
 318         if (NULL == msg) {
 319                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 320                 return VCD_ERROR_OUT_OF_MEMORY;
 321         }
 322
 323         dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
 324
 325         dbus_message_set_no_reply(msg, TRUE);
 326
 327         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 328                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 329                 return VCD_ERROR_OPERATION_FAILED;
 330         } else {
 331                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 332                 dbus_connection_flush(g_conn_sender);
 333         }
 334
 335         return 0;
 336 }
 337
 338 int vcdc_send_result_to_manager(int manger_pid, int result_type)
 339 {
 340         if (0 != __dbus_check()) {
 341                 return VCD_ERROR_OPERATION_FAILED;
 342         }
 343
 344         DBusError err;
 345         dbus_error_init(&err);
 346
 347         DBusMessage* msg = NULL;
 348
 349         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
 350
 351         if (NULL == msg) {
 352                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 353                 return VCD_ERROR_OUT_OF_MEMORY;
 354         }
 355
 356         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
 357
 358         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 359
 360         dbus_message_set_no_reply(msg, TRUE);
 361
 362         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 363                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 364                 return VCD_ERROR_OPERATION_FAILED;
 365         } else {
 366                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 367                 dbus_connection_flush(g_conn_sender);
 368         }
 369
 370         dbus_message_unref(msg);
 371
 372         return 0;
 373 }
 374
 375 int vcdc_send_speech_detected(int manger_pid)
 376 {
 377         if (0 != __dbus_check()) {
 378                 return VCD_ERROR_OPERATION_FAILED;
 379         }
 380
 381         DBusError err;
 382         dbus_error_init(&err);
 383
 384         /* Send to manager */
 385         DBusMessage* msg = NULL;
 386
 387         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
 388
 389         if (NULL == msg) {
 390                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 391                 return VCD_ERROR_OUT_OF_MEMORY;
 392         }
 393
 394         dbus_message_set_no_reply(msg, TRUE);
 395
 396         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 397                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 398                 return VCD_ERROR_OPERATION_FAILED;
 399         } else {
 400                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 401                 dbus_connection_flush(g_conn_sender);
 402         }
 403
 404         dbus_message_unref(msg);
 405
 406         return 0;
 407 }
 408
 409 int vcdc_send_service_state(vcd_state_e state)
 410 {
 411         if (0 != __dbus_check()) {
 412                 return VCD_ERROR_OPERATION_FAILED;
 413         }
 414
 415         DBusError err;
 416         dbus_error_init(&err);
 417
 418         DBusMessage* msg = NULL;
 419
 420         msg = dbus_message_new_signal(
 421                 VC_MANAGER_SERVICE_OBJECT_PATH,
 422                 VC_MANAGER_SERVICE_INTERFACE,
 423                 VCD_MANAGER_METHOD_SET_SERVICE_STATE);
 424
 425         if (NULL == msg) {
 426                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 427                 return VCD_ERROR_OUT_OF_MEMORY;
 428         }
 429
 430         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 431
 432         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 433                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 434                 return VCD_ERROR_OPERATION_FAILED;
 435         } else {
 436                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to manager : state(%d)", state);
 437                 dbus_connection_flush(g_conn_sender);
 438         }
 439
 440         dbus_message_unref(msg);
 441
 442         /* Send to client */
 443         msg = NULL;
 444
 445         msg = dbus_message_new_signal(
 446                 VC_CLIENT_SERVICE_OBJECT_PATH,
 447                 VC_CLIENT_SERVICE_INTERFACE,
 448                 VCD_METHOD_SET_SERVICE_STATE);
 449
 450         if (NULL == msg) {
 451                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 452                 return VCD_ERROR_OUT_OF_MEMORY;
 453         }
 454
 455         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 456
 457         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 458                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 459                 return VCD_ERROR_OPERATION_FAILED;
 460         } else {
 461                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to client : state(%d)", state);
 462                 dbus_connection_flush(g_conn_sender);
 463         }
 464
 465         dbus_message_unref(msg);
 466
 467         msg = NULL;
 468
 469         /* Send to widget client */
 470         msg = dbus_message_new_signal(
 471                 VC_WIDGET_SERVICE_OBJECT_PATH,
 472                 VC_WIDGET_SERVICE_INTERFACE,
 473                 VCD_WIDGET_METHOD_SET_SERVICE_STATE);
 474
 475         if (NULL == msg) {
 476                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 477                 return VCD_ERROR_OUT_OF_MEMORY;
 478         }
 479
 480         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 481
 482         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 483                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 484                 return VCD_ERROR_OPERATION_FAILED;
 485         } else {
 486                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to widget client : state(%d)", state);
 487                 dbus_connection_flush(g_conn_sender);
 488         }
 489
 490         dbus_message_unref(msg);
 491
 492         return 0;
 493 }
 494
 495 int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
 496 {
 497         if (0 != __dbus_check()) {
 498                 return VCD_ERROR_OPERATION_FAILED;
 499         }
 500
 501         DBusError err;
 502         dbus_error_init(&err);
 503
 504         DBusMessage* msg = NULL;
 505
 506         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER);
 507
 508         if (NULL == msg) {
 509                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 510                 return VCD_ERROR_OUT_OF_MEMORY;
 511         }
 512
 513         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
 514
 515         dbus_message_append_args(msg,
 516                                 DBUS_TYPE_INT32, &pid,
 517                                 DBUS_TYPE_STRING, &disp_text,
 518                                 DBUS_TYPE_STRING, &utt_text,
 519                                 DBUS_TYPE_INT32, &continuous,
 520                                 DBUS_TYPE_INVALID);
 521
 522         dbus_message_set_no_reply(msg, TRUE);
 523
 524         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 525                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 526                 return VCD_ERROR_OPERATION_FAILED;
 527         } else {
 528                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 529                 dbus_connection_flush(g_conn_sender);
 530         }
 531
 532         dbus_message_unref(msg);
 533
 534         return 0;
 535 }
 536
 537 int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
 538 {
 539         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal to manager");
 540
 541         if (NULL == err_msg) {
 542                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 543                 return VCD_ERROR_INVALID_PARAMETER;
 544         }
 545
 546         if (0 != __dbus_check()) {
 547                 return VCD_ERROR_OPERATION_FAILED;
 548         }
 549
 550         int daemon_pid;
 551         DBusError err;
 552         dbus_error_init(&err);
 553
 554         DBusMessage* msg = NULL;
 555
 556         msg = dbus_message_new_signal(
 557                 VC_MANAGER_SERVICE_OBJECT_PATH,
 558                 VC_MANAGER_SERVICE_INTERFACE,
 559                 VCD_MANAGER_METHOD_ERROR);
 560
 561         if (NULL == msg) {
 562                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 563                 return VCD_ERROR_OUT_OF_MEMORY;
 564         }
 565
 566         daemon_pid = getpid();
 567         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 568
 569         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 570                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 571                 return VCD_ERROR_OPERATION_FAILED;
 572         } else {
 573                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager : reason(%d), Error Msg(%s)", reason, err_msg);
 574                 dbus_connection_flush(g_conn_sender);
 575         }
 576
 577         dbus_message_unref(msg);
 578
 579         return 0;
 580 }
 581
 582 int vcdc_send_error_signal(int reason, char *err_msg)
 583 {
 584         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal");
 585
 586         if (NULL == err_msg) {
 587                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 588                 return VCD_ERROR_INVALID_PARAMETER;
 589         }
 590
 591         if (0 != __dbus_check()) {
 592                 return VCD_ERROR_OPERATION_FAILED;
 593         }
 594
 595         int daemon_pid;
 596         DBusError err;
 597         dbus_error_init(&err);
 598
 599         DBusMessage* msg = NULL;
 600
 601         msg = dbus_message_new_signal(
 602                 VC_MANAGER_SERVICE_OBJECT_PATH,
 603                 VC_MANAGER_SERVICE_INTERFACE,
 604                 VCD_MANAGER_METHOD_ERROR);
 605
 606         if (NULL == msg) {
 607                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 608                 return VCD_ERROR_OUT_OF_MEMORY;
 609         }
 610
 611         daemon_pid = getpid();
 612         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 613
 614         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 615                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 616                 return VCD_ERROR_OPERATION_FAILED;
 617         } else {
 618                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 619                 dbus_connection_flush(g_conn_sender);
 620         }
 621
 622         dbus_message_unref(msg);
 623
 624         msg = NULL;
 625         msg = dbus_message_new_signal(
 626                 VC_CLIENT_SERVICE_OBJECT_PATH,
 627                 VC_CLIENT_SERVICE_INTERFACE,
 628                 VCD_METHOD_ERROR);
 629
 630         if (NULL == msg) {
 631                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 632                 return VCD_ERROR_OUT_OF_MEMORY;
 633         }
 634
 635         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 636
 637         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 638                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 639                 return VCD_ERROR_OPERATION_FAILED;
 640         } else {
 641                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 642                 dbus_connection_flush(g_conn_sender);
 643         }
 644
 645         dbus_message_unref(msg);
 646
 647         msg = NULL;
 648         msg = dbus_message_new_signal(
 649                 VC_WIDGET_SERVICE_OBJECT_PATH,
 650                 VC_WIDGET_SERVICE_INTERFACE,
 651                 VCD_WIDGET_METHOD_ERROR);
 652
 653         if (NULL == msg) {
 654                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 655                 return VCD_ERROR_OUT_OF_MEMORY;
 656         }
 657
 658         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 659
 660         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 661                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 662                 return VCD_ERROR_OPERATION_FAILED;
 663         } else {
 664                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 665                 dbus_connection_flush(g_conn_sender);
 666         }
 667
 668         dbus_message_unref(msg);
 669
 670         return 0;
 671 }
 672
 673 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 674 {
 675         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 676
 677         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 678
 679         while (1) {
 680                 DBusMessage* msg = NULL;
 681                 msg = dbus_connection_pop_message(g_conn_listener);
 682
 683                 /* loop again if we haven't read a message */
 684                 if (NULL == msg) {
 685                         break;
 686                 }
 687
 688                 /* Common event */
 689                 if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
 690                         vcd_dbus_server_hello(g_conn_listener, msg);
 691
 692                 /* manager event */
 693                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
 694                         vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
 695
 696                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
 697                         vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
 698
 699                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
 700                         vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
 701
 702                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
 703                         vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
 704
 705                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
 706                         vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
 707
 708                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
 709                         vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
 710
 711                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
 712                         vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
 713
 714                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
 715                         vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
 716
 717                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA))
 718                         vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg);
 719
 720                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA))
 721                         vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg);
 722
 723                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
 724                         vcd_dbus_server_mgr_start(g_conn_listener, msg);
 725
 726                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
 727                         vcd_dbus_server_mgr_stop(g_conn_listener, msg);
 728
 729                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
 730                         vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
 731
 732                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
 733                         vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
 734
 735                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN))
 736                         vcd_dbus_server_mgr_set_domain(g_conn_listener, msg);
 737
 738                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION))
 739                         vcd_dbus_server_mgr_do_action(g_conn_listener, msg);
 740
 741                 /* client event */
 742                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
 743                         vcd_dbus_server_initialize(g_conn_listener, msg);
 744
 745                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
 746                         vcd_dbus_server_finalize(g_conn_listener, msg);
 747 #if 0
 748                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
 749                         vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
 750 #endif
 751                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
 752                         vcd_dbus_server_set_command(g_conn_listener, msg);
 753
 754                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
 755                         vcd_dbus_server_unset_command(g_conn_listener, msg);
 756
 757                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
 758                         vcd_dbus_server_set_foreground(g_conn_listener, msg);
 759
 760                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_DIALOG))
 761                         vcd_dbus_server_dialog(g_conn_listener, msg);
 762
 763                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_IS_SYS_COMMAND_VALID))
 764                         vcd_dbus_server_is_system_command_valid(g_conn_listener, msg);
 765
 766 #if 0
 767                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
 768                         vcd_dbus_server_start_request(g_conn_listener, msg);
 769
 770                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
 771                         vcd_dbus_server_stop_request(g_conn_listener, msg);
 772
 773                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
 774                         vcd_dbus_server_cancel_request(g_conn_listener, msg);
 775 #endif
 776                 /* widget event */
 777                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
 778                         vcd_dbus_server_widget_initialize(g_conn_listener, msg);
 779
 780                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
 781                         vcd_dbus_server_widget_finalize(g_conn_listener, msg);
 782
 783                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
 784                         vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
 785
 786                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
 787                         vcd_dbus_server_widget_start(g_conn_listener, msg);
 788
 789                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
 790                         vcd_dbus_server_widget_stop(g_conn_listener, msg);
 791
 792                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
 793                         vcd_dbus_server_widget_cancel(g_conn_listener, msg);
 794
 795                 else {
 796                         SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
 797                         dbus_message_unref(msg);
 798                         break;
 799                 }
 800
 801                 /* free the message */
 802                 dbus_message_unref(msg);
 803         }
 804
 805         return ECORE_CALLBACK_RENEW;
 806 }
 807
 808 int vcd_dbus_open_connection()
 809 {
 810         DBusError err;
 811         dbus_error_init(&err);
 812
 813         int ret;
 814
 815         /* Create connection for sender */
 816         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 817
 818         if (dbus_error_is_set(&err)) {
 819                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 820                 dbus_error_free(&err);
 821         }
 822
 823         if (NULL == g_conn_sender) {
 824                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 825                 return VCD_ERROR_OPERATION_FAILED;
 826         }
 827
 828         /* connect to the bus and check for errors */
 829         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 830
 831         if (dbus_error_is_set(&err)) {
 832                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 833                 dbus_error_free(&err);
 834         }
 835
 836         if (NULL == g_conn_listener) {
 837                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 838                 return VCD_ERROR_OPERATION_FAILED;
 839         }
 840
 841         /* request our name on the bus and check for errors */
 842         ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 843
 844         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 845                 printf("Fail to be primary owner in dbus request.");
 846                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
 847                 return VCD_ERROR_OPERATION_FAILED;
 848         }
 849
 850         if (dbus_error_is_set(&err)) {
 851                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
 852                 dbus_error_free(&err);
 853                 return VCD_ERROR_OPERATION_FAILED;
 854         }
 855
 856         /* add a rule for getting signal */
 857         char rule[128];
 858         snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
 859
 860         /* add a rule for which messages we want to see */
 861         dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
 862         dbus_connection_flush(g_conn_listener);
 863
 864         if (dbus_error_is_set(&err)) {
 865                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
 866                 dbus_error_free(&err);
 867                 return VCD_ERROR_OPERATION_FAILED;
 868         }
 869
 870         int fd = 0;
 871         dbus_connection_get_unix_fd(g_conn_listener, &fd);
 872
 873         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 874
 875         if (NULL == g_dbus_fd_handler) {
 876                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
 877                 return VCD_ERROR_OPERATION_FAILED;
 878         }
 879
 880         return 0;
 881 }
 882
 883 int vcd_dbus_close_connection()
 884 {
 885         DBusError err;
 886         dbus_error_init(&err);
 887
 888         if (NULL != g_dbus_fd_handler) {
 889                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 890                 g_dbus_fd_handler = NULL;
 891         }
 892
 893         dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
 894
 895         if (dbus_error_is_set(&err)) {
 896                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
 897                 dbus_error_free(&err);
 898         }
 899
 900         dbus_connection_close(g_conn_listener);
 901         dbus_connection_close(g_conn_sender);
 902
 903         dbus_connection_unref(g_conn_listener);
 904         dbus_connection_unref(g_conn_sender);
 905
 906         g_conn_listener = NULL;
 907         g_conn_sender = NULL;
 908
 909         return 0;
 910 }