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 || NULL == g_conn_listener) {
  83                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] NULL connection");
  84                 return vcd_dbus_reconnect();
  85         }
  86         return 0;
  87 }
  88
  89 int vcd_check_dbus_connection()
  90 {
  91         if (NULL == g_conn_sender || NULL == g_conn_listener) {
  92                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] NULL connection sender(%p), listener(%p)", g_conn_sender, g_conn_listener);
  93                 return -1;
  94         }
  95         return 0;
  96 }
  97
  98 int vcdc_send_hello(int pid, vcd_client_type_e type)
  99 {
 100         if (0 != __dbus_check()) {
 101                 return VCD_ERROR_OPERATION_FAILED;
 102         }
 103
 104         DBusMessage* msg = NULL;
 105
 106         if (VCD_CLIENT_TYPE_NORMAL == type) {
 107                 msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL);
 108         } else if (VCD_CLIENT_TYPE_WIDGET == type) {
 109                 msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET);
 110         } else if (VCD_CLIENT_TYPE_MANAGER == type) {
 111                 msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
 112         } else {
 113                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
 114                 return -1;
 115         }
 116
 117         if (NULL == msg) {
 118                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 119                 return VCD_ERROR_OUT_OF_MEMORY;
 120         }
 121
 122         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 123
 124         DBusError err;
 125         dbus_error_init(&err);
 126
 127         DBusMessage* result_msg;
 128         int result = -1;
 129
 130         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 131         dbus_message_unref(msg);
 132
 133         if (dbus_error_is_set(&err)) {
 134                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
 135                 if (NULL != err.name) {
 136                         if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
 137                                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
 138                                 dbus_error_free(&err);
 139                                 return 0;
 140                         }
 141                 }
 142                 dbus_error_free(&err);
 143         }
 144
 145         if (NULL != result_msg) {
 146                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 147
 148                 if (dbus_error_is_set(&err)) {
 149                         SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
 150                         dbus_error_free(&err);
 151                         result = VCD_ERROR_OPERATION_FAILED;
 152                 }
 153
 154                 dbus_message_unref(result_msg);
 155         } else {
 156                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
 157         }
 158
 159         return result;
 160 }
 161
 162 int vcdc_send_show_tooltip(int pid, bool show)
 163 {
 164         if (0 != __dbus_check()) {
 165                 return VCD_ERROR_OPERATION_FAILED;
 166         }
 167
 168         if (0 > pid) {
 169                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid");
 170                 return -1;
 171         }
 172
 173         char service_name[64] = {0, };
 174         memset(service_name, 0, 64);
 175         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 176
 177         char target_if_name[128] = {0, };
 178         snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
 179
 180         DBusMessage* msg;
 181
 182         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
 183
 184         msg = dbus_message_new_method_call(
 185                           service_name,
 186                           VC_WIDGET_SERVICE_OBJECT_PATH,
 187                           target_if_name,
 188                           VCD_WIDGET_METHOD_SHOW_TOOLTIP);
 189
 190         if (NULL == msg) {
 191                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 192                 return VCD_ERROR_OUT_OF_MEMORY;
 193         }
 194
 195         int temp = (int)show;
 196
 197         DBusMessageIter args;
 198         dbus_message_iter_init_append(msg, &args);
 199
 200         /* Append pid & type */
 201         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &pid);
 202         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
 203
 204         dbus_message_set_no_reply(msg, TRUE);
 205
 206         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 207                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 208                 return VCD_ERROR_OPERATION_FAILED;
 209         } else {
 210                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 211                 dbus_connection_flush(g_conn_sender);
 212         }
 213
 214         dbus_message_unref(msg);
 215
 216         return 0;
 217 }
 218
 219 int vcdc_send_set_volume(int manger_pid, float volume)
 220 {
 221         if (0 != __dbus_check()) {
 222                 return VCD_ERROR_OPERATION_FAILED;
 223         }
 224
 225         DBusMessage* msg = NULL;
 226
 227         /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */
 228
 229         msg = dbus_message_new_signal(
 230                 VC_MANAGER_SERVICE_OBJECT_PATH,
 231                 VC_MANAGER_SERVICE_INTERFACE,
 232                 VCD_MANAGER_METHOD_SET_VOLUME);
 233
 234         if (NULL == msg) {
 235                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 236                 return VCD_ERROR_OUT_OF_MEMORY;
 237         }
 238
 239         dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
 240
 241         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 242                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 243                 dbus_message_unref(msg);
 244                 return -1;
 245         } else {
 246                 if (10 == g_volume_count) {
 247                         SLOG(LOG_DEBUG, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume);
 248                         g_volume_count = 0;
 249                 }
 250
 251                 dbus_connection_flush(g_conn_sender);
 252
 253                 g_volume_count++;
 254         }
 255
 256         dbus_message_unref(msg);
 257
 258         return 0;
 259 }
 260
 261 int vcdc_send_result(int pid, int manager_pid, int cmd_type)
 262 {
 263         if (0 != __dbus_check()) {
 264                 return VCD_ERROR_OPERATION_FAILED;
 265         }
 266
 267         DBusMessage* msg = NULL;
 268
 269         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
 270
 271         switch (cmd_type) {
 272         case VC_COMMAND_TYPE_FOREGROUND:
 273         case VC_COMMAND_TYPE_BACKGROUND:
 274                 if (pid == manager_pid) {
 275                         msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 276                 } else {
 277                         msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL);
 278                 }
 279                 break;
 280         case VC_COMMAND_TYPE_WIDGET:
 281                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, VCD_CLIENT_TYPE_WIDGET);
 282                 break;
 283         case VC_COMMAND_TYPE_SYSTEM:
 284         case VC_COMMAND_TYPE_SYSTEM_BACKGROUND:
 285         case VC_COMMAND_TYPE_EXCLUSIVE:
 286                 msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
 287                 break;
 288
 289         default:
 290                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
 291                 return -1;
 292         }
 293
 294         if (NULL == msg) {
 295                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 296                 return VCD_ERROR_OUT_OF_MEMORY;
 297         }
 298
 299         dbus_message_set_no_reply(msg, TRUE);
 300
 301         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 302                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 303                 return VCD_ERROR_OPERATION_FAILED;
 304         } else {
 305                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 306                 dbus_connection_flush(g_conn_sender);
 307         }
 308
 309         dbus_message_unref(msg);
 310
 311         return 0;
 312 }
 313
 314 int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_type, bool* is_consumed)
 315 {
 316         if (0 != __dbus_check()) {
 317                 return VCD_ERROR_OPERATION_FAILED;
 318         }
 319
 320         DBusMessage* msg = NULL;
 321
 322         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
 323
 324         switch (cmd_type) {
 325         case VC_COMMAND_TYPE_WIDGET:
 326                 msg = __get_message(pid, VCD_WIDGET_METHOD_ASR_RESULT, VCD_CLIENT_TYPE_WIDGET);
 327                 break;
 328         default:
 329                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
 330                 return VCD_ERROR_INVALID_PARAMETER;
 331         }
 332
 333         if (NULL == msg) {
 334                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 335                 return VCD_ERROR_OUT_OF_MEMORY;
 336         }
 337
 338         dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &asr_result, DBUS_TYPE_INVALID);
 339
 340         DBusError err;
 341         dbus_error_init(&err);
 342
 343         DBusMessage* result_msg;
 344
 345         int result = 0;
 346         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 5000, &err);
 347         dbus_message_unref(msg);
 348
 349         if (dbus_error_is_set(&err)) {
 350                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", err.message);
 351                 dbus_error_free(&err);
 352         }
 353
 354         if (NULL != result_msg) {
 355                 dbus_message_get_args(result_msg, &err,
 356                         DBUS_TYPE_INT32, &result,
 357                         DBUS_TYPE_INVALID);
 358
 359                 if (dbus_error_is_set(&err)) {
 360                         SLOG(LOG_ERROR, TAG_VCD, "@@ Get arguments error (%s)", err.message);
 361                         dbus_error_free(&err);
 362                         result = VCD_ERROR_OPERATION_FAILED;
 363                 }
 364
 365                 dbus_message_unref(result_msg);
 366                 SLOG(LOG_DEBUG, TAG_VCD, "@@ vc send asr result : result = %d", result);
 367                 *is_consumed = result;
 368                 return VCD_ERROR_NONE;
 369         } else {
 370                 SLOG(LOG_ERROR, TAG_VCD, "@@ Result message is NULL ");
 371                 return VCD_ERROR_OPERATION_FAILED;
 372         }
 373 }
 374
 375 int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
 376 {
 377         if (0 != __dbus_check()) {
 378                 return VCD_ERROR_OPERATION_FAILED;
 379         }
 380
 381         DBusError err;
 382         dbus_error_init(&err);
 383
 384         DBusMessage* msg = NULL;
 385
 386         msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
 387
 388         if (NULL == msg) {
 389                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 390                 return VCD_ERROR_OUT_OF_MEMORY;
 391         }
 392
 393         dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
 394
 395         dbus_message_set_no_reply(msg, TRUE);
 396
 397         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 398                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 399                 return VCD_ERROR_OPERATION_FAILED;
 400         } else {
 401                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 402                 dbus_connection_flush(g_conn_sender);
 403         }
 404
 405         return 0;
 406 }
 407
 408 int vcdc_send_result_to_manager(int manger_pid, int result_type)
 409 {
 410         if (0 != __dbus_check()) {
 411                 return VCD_ERROR_OPERATION_FAILED;
 412         }
 413
 414         DBusError err;
 415         dbus_error_init(&err);
 416
 417         DBusMessage* msg = NULL;
 418
 419         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
 420
 421         if (NULL == msg) {
 422                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 423                 return VCD_ERROR_OUT_OF_MEMORY;
 424         }
 425
 426         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
 427
 428         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 429
 430         dbus_message_set_no_reply(msg, TRUE);
 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, "[Dbus] SUCCESS Send");
 437                 dbus_connection_flush(g_conn_sender);
 438         }
 439
 440         dbus_message_unref(msg);
 441
 442         return 0;
 443 }
 444
 445 int vcdc_send_speech_detected(int manger_pid)
 446 {
 447         if (0 != __dbus_check()) {
 448                 return VCD_ERROR_OPERATION_FAILED;
 449         }
 450
 451         DBusError err;
 452         dbus_error_init(&err);
 453
 454         /* Send to manager */
 455         DBusMessage* msg = NULL;
 456
 457         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
 458
 459         if (NULL == msg) {
 460                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 461                 return VCD_ERROR_OUT_OF_MEMORY;
 462         }
 463
 464         dbus_message_set_no_reply(msg, TRUE);
 465
 466         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 467                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 468                 return VCD_ERROR_OPERATION_FAILED;
 469         } else {
 470                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 471                 dbus_connection_flush(g_conn_sender);
 472         }
 473
 474         dbus_message_unref(msg);
 475
 476         return 0;
 477 }
 478
 479 int vcdc_send_service_state(vcd_state_e state)
 480 {
 481         if (0 != __dbus_check()) {
 482                 return VCD_ERROR_OPERATION_FAILED;
 483         }
 484
 485         DBusError err;
 486         dbus_error_init(&err);
 487
 488         DBusMessage* msg = NULL;
 489
 490         msg = __get_message(vcd_client_manager_get_pid(), VCD_MANAGER_METHOD_SET_SERVICE_STATE, VCD_CLIENT_TYPE_MANAGER);
 491
 492         if (NULL == msg) {
 493                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 494                 return VCD_ERROR_OUT_OF_MEMORY;
 495         }
 496
 497         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 498
 499         dbus_message_set_no_reply(msg, TRUE);
 500
 501         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 502                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 503                 return VCD_ERROR_OPERATION_FAILED;
 504         } else {
 505                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send serive state message to manager : state(%d)", state);
 506                 dbus_connection_flush(g_conn_sender);
 507         }
 508
 509         dbus_message_unref(msg);
 510
 511         /* Send to client */
 512         msg = NULL;
 513
 514         msg = dbus_message_new_signal(
 515                 VC_CLIENT_SERVICE_OBJECT_PATH,
 516                 VC_CLIENT_SERVICE_INTERFACE,
 517                 VCD_METHOD_SET_SERVICE_STATE);
 518
 519         if (NULL == msg) {
 520                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 521                 return VCD_ERROR_OUT_OF_MEMORY;
 522         }
 523
 524         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 525
 526         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 527                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 528                 return VCD_ERROR_OPERATION_FAILED;
 529         } else {
 530                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send serive state message to client : state(%d)", state);
 531                 dbus_connection_flush(g_conn_sender);
 532         }
 533
 534         dbus_message_unref(msg);
 535
 536         msg = NULL;
 537
 538         /* Send to widget client */
 539         msg = dbus_message_new_signal(
 540                 VC_WIDGET_SERVICE_OBJECT_PATH,
 541                 VC_WIDGET_SERVICE_INTERFACE,
 542                 VCD_WIDGET_METHOD_SET_SERVICE_STATE);
 543
 544         if (NULL == msg) {
 545                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 546                 return VCD_ERROR_OUT_OF_MEMORY;
 547         }
 548
 549         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 550
 551         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 552                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 553                 return VCD_ERROR_OPERATION_FAILED;
 554         } else {
 555                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send serive state message to widget client : state(%d)", state);
 556                 dbus_connection_flush(g_conn_sender);
 557         }
 558
 559         dbus_message_unref(msg);
 560
 561         return 0;
 562 }
 563
 564 int vcdc_send_manager_pid(int manager_pid)
 565 {
 566         DBusError err;
 567         dbus_error_init(&err);
 568
 569         DBusMessage* msg = NULL;
 570
 571         /* Send to client */
 572         msg = dbus_message_new_signal(
 573                 VC_CLIENT_SERVICE_OBJECT_PATH,
 574                 VC_CLIENT_SERVICE_INTERFACE,
 575                 VCD_METHOD_SEND_MANAGER_PID);
 576
 577         if (NULL == msg) {
 578                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 579                 return VCD_ERROR_OUT_OF_MEMORY;
 580         }
 581
 582         dbus_message_append_args(msg, DBUS_TYPE_INT32, &manager_pid, DBUS_TYPE_INVALID);
 583
 584         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 585                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 586                 return VCD_ERROR_OPERATION_FAILED;
 587         } else {
 588                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send manager pid to client : pid(%d)", manager_pid);
 589                 dbus_connection_flush(g_conn_sender);
 590         }
 591
 592         dbus_message_unref(msg);
 593
 594         return 0;
 595 }
 596
 597 int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
 598 {
 599         if (0 != __dbus_check()) {
 600                 return VCD_ERROR_OPERATION_FAILED;
 601         }
 602
 603         DBusError err;
 604         dbus_error_init(&err);
 605
 606         DBusMessage* msg = NULL;
 607
 608         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER);
 609
 610         if (NULL == msg) {
 611                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 612                 return VCD_ERROR_OUT_OF_MEMORY;
 613         }
 614
 615         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
 616
 617         char* disp_null = NULL;
 618         char* utt_null = NULL;
 619         int ret = VCD_ERROR_NONE;
 620         if (NULL == disp_text) {
 621                 disp_null = strdup("#NULL");
 622                 disp_text = disp_null;
 623         }
 624
 625         if (NULL == utt_text) {
 626                 utt_null = strdup("#NULL");
 627                 utt_text = utt_null;
 628         }
 629
 630         dbus_message_append_args(msg,
 631                                 DBUS_TYPE_INT32, &pid,
 632                                 DBUS_TYPE_STRING, &disp_text,
 633                                 DBUS_TYPE_STRING, &utt_text,
 634                                 DBUS_TYPE_INT32, &continuous,
 635                                 DBUS_TYPE_INVALID);
 636
 637         dbus_message_set_no_reply(msg, TRUE);
 638
 639         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 640                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 641                 ret = VCD_ERROR_OPERATION_FAILED;
 642         } else {
 643                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 644                 dbus_connection_flush(g_conn_sender);
 645         }
 646
 647         dbus_message_unref(msg);
 648
 649         if (NULL != disp_null) {
 650                 free(disp_null);
 651                 disp_null = NULL;
 652         }
 653
 654         if (NULL != utt_null) {
 655                 free(utt_null);
 656                 utt_null = NULL;
 657         }
 658
 659         return ret;
 660 }
 661
 662 int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
 663 {
 664         SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal to manager");
 665
 666         if (0 != __dbus_check()) {
 667                 return VCD_ERROR_OPERATION_FAILED;
 668         }
 669
 670         int daemon_pid;
 671         DBusError err;
 672         dbus_error_init(&err);
 673
 674         DBusMessage* msg = NULL;
 675
 676         msg = dbus_message_new_signal(
 677                 VC_MANAGER_SERVICE_OBJECT_PATH,
 678                 VC_MANAGER_SERVICE_INTERFACE,
 679                 VCD_MANAGER_METHOD_ERROR);
 680
 681         if (NULL == msg) {
 682                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 683                 return VCD_ERROR_OUT_OF_MEMORY;
 684         }
 685
 686         char *temp_msg = NULL;
 687         if (NULL == err_msg) {
 688                 SLOG(LOG_WARN, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 689                 temp_msg = strdup("#NULL");
 690         } else {
 691                 temp_msg = strdup(err_msg);
 692         }
 693
 694         daemon_pid = getpid();
 695         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &temp_msg, DBUS_TYPE_INVALID);
 696
 697         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 698                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 699                 if (NULL != temp_msg) {
 700                         free(temp_msg);
 701                         temp_msg = NULL;
 702                 }
 703                 return VCD_ERROR_OPERATION_FAILED;
 704         } else {
 705                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager : reason(%d), Error Msg(%s)", reason, temp_msg);
 706                 dbus_connection_flush(g_conn_sender);
 707         }
 708
 709         dbus_message_unref(msg);
 710         if (NULL != temp_msg) {
 711                 free(temp_msg);
 712                 temp_msg = NULL;
 713         }
 714
 715         return 0;
 716 }
 717
 718 int vcdc_send_error_signal(int reason, char *err_msg)
 719 {
 720         SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal");
 721
 722         if (NULL == err_msg) {
 723                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 724                 return VCD_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         if (0 != __dbus_check()) {
 728                 return VCD_ERROR_OPERATION_FAILED;
 729         }
 730
 731         int daemon_pid;
 732         DBusError err;
 733         dbus_error_init(&err);
 734
 735         DBusMessage* msg = NULL;
 736
 737         msg = dbus_message_new_signal(
 738                 VC_MANAGER_SERVICE_OBJECT_PATH,
 739                 VC_MANAGER_SERVICE_INTERFACE,
 740                 VCD_MANAGER_METHOD_ERROR);
 741
 742         if (NULL == msg) {
 743                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 744                 return VCD_ERROR_OUT_OF_MEMORY;
 745         }
 746
 747         daemon_pid = getpid();
 748         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 749
 750         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 751                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 752                 return VCD_ERROR_OPERATION_FAILED;
 753         } else {
 754                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 755                 dbus_connection_flush(g_conn_sender);
 756         }
 757
 758         dbus_message_unref(msg);
 759
 760         msg = NULL;
 761         msg = dbus_message_new_signal(
 762                 VC_CLIENT_SERVICE_OBJECT_PATH,
 763                 VC_CLIENT_SERVICE_INTERFACE,
 764                 VCD_METHOD_ERROR);
 765
 766         if (NULL == msg) {
 767                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 768                 return VCD_ERROR_OUT_OF_MEMORY;
 769         }
 770
 771         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 772
 773         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 774                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 775                 return VCD_ERROR_OPERATION_FAILED;
 776         } else {
 777                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 778                 dbus_connection_flush(g_conn_sender);
 779         }
 780
 781         dbus_message_unref(msg);
 782
 783         msg = NULL;
 784         msg = dbus_message_new_signal(
 785                 VC_WIDGET_SERVICE_OBJECT_PATH,
 786                 VC_WIDGET_SERVICE_INTERFACE,
 787                 VCD_WIDGET_METHOD_ERROR);
 788
 789         if (NULL == msg) {
 790                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 791                 return VCD_ERROR_OUT_OF_MEMORY;
 792         }
 793
 794         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 795
 796         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 797                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 798                 return VCD_ERROR_OPERATION_FAILED;
 799         } else {
 800                 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 801                 dbus_connection_flush(g_conn_sender);
 802         }
 803
 804         dbus_message_unref(msg);
 805
 806         return 0;
 807 }
 808
 809 int vcdc_send_request_set_private_data(int pid, const char* key, const char* data)
 810 {
 811         if (0 != __dbus_check()) {
 812                 return VCD_ERROR_OPERATION_FAILED;
 813         }
 814
 815         DBusMessage* msg = NULL;
 816         msg = __get_message(pid, VCD_MANAGER_METHOD_SET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER);
 817         if (NULL == msg) {
 818                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 819                 return VCD_ERROR_OUT_OF_MEMORY;
 820         }
 821
 822         dbus_message_append_args(msg,
 823                 DBUS_TYPE_INT32, &pid,
 824                 DBUS_TYPE_STRING, &key,
 825                 DBUS_TYPE_STRING, &data,
 826                 DBUS_TYPE_INVALID);
 827
 828         dbus_message_set_no_reply(msg, TRUE);
 829
 830         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 831                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send request set private data");
 832                 dbus_message_unref(msg);
 833                 return VCD_ERROR_OPERATION_FAILED;
 834         } else {
 835                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send request set private data");
 836                 dbus_connection_flush(g_conn_sender);
 837         }
 838
 839         dbus_message_unref(msg);
 840
 841         return VCD_ERROR_NONE;
 842 }
 843
 844 int vcdc_send_request_get_private_data(int pid, const char* key, char** data)
 845 {
 846         if (0 != __dbus_check()) {
 847                 return VCD_ERROR_OPERATION_FAILED;
 848         }
 849
 850         DBusMessage* msg = NULL;
 851         msg = __get_message(pid, VCD_MANAGER_METHOD_GET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER);
 852         if (NULL == msg) {
 853                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
 854                 return VCD_ERROR_OUT_OF_MEMORY;
 855         }
 856
 857         dbus_message_append_args(msg,
 858                 DBUS_TYPE_INT32, &pid,
 859                 DBUS_TYPE_STRING, &key,
 860                 DBUS_TYPE_INVALID);
 861
 862         DBusError err;
 863         dbus_error_init(&err);
 864
 865         DBusMessage* result_msg;
 866         int result = -1;
 867         char* temp = NULL;
 868
 869         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 870         dbus_message_unref(msg);
 871
 872         if (dbus_error_is_set(&err)) {
 873                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
 874                 if (NULL != err.name) {
 875                         if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
 876                                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
 877                                 dbus_error_free(&err);
 878                                 return 0;
 879                         }
 880                 }
 881                 dbus_error_free(&err);
 882         }
 883
 884         if (NULL != result_msg) {
 885                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &temp, DBUS_TYPE_INVALID);
 886
 887                 if (dbus_error_is_set(&err)) {
 888                         SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
 889                         dbus_error_free(&err);
 890                         result = VCD_ERROR_OPERATION_FAILED;
 891                 }
 892
 893                 dbus_message_unref(result_msg);
 894         } else {
 895                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
 896         }
 897
 898         if (NULL != data && NULL != temp) {
 899                 *data = strdup(temp);
 900         }
 901
 902         return result;
 903 }
 904
 905 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 906 {
 907         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 908
 909         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 910
 911         while (1) {
 912                 DBusMessage* msg = NULL;
 913                 msg = dbus_connection_pop_message(g_conn_listener);
 914
 915                 /* loop again if we haven't read a message */
 916                 if (NULL == msg) {
 917                         break;
 918                 }
 919
 920                 /* Common event */
 921                 if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
 922                         vcd_dbus_server_hello(g_conn_listener, msg);
 923
 924                 /* manager event */
 925                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
 926                         vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
 927
 928                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
 929                         vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
 930
 931                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
 932                         vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
 933
 934                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
 935                         vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
 936
 937                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
 938                         vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
 939
 940                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
 941                         vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
 942
 943                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
 944                         vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
 945
 946                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
 947                         vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
 948
 949                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA))
 950                         vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg);
 951
 952                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA))
 953                         vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg);
 954
 955                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
 956                         vcd_dbus_server_mgr_start(g_conn_listener, msg);
 957
 958                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
 959                         vcd_dbus_server_mgr_stop(g_conn_listener, msg);
 960
 961                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
 962                         vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
 963
 964                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
 965                         vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
 966
 967                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN))
 968                         vcd_dbus_server_mgr_set_domain(g_conn_listener, msg);
 969
 970                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION))
 971                         vcd_dbus_server_mgr_do_action(g_conn_listener, msg);
 972
 973                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_ENABLE_COMMAND_TYPE))
 974                         vcd_dbus_server_mgr_enable_command_type(g_conn_listener, msg);
 975
 976                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DISABLE_COMMAND_TYPE))
 977                         vcd_dbus_server_mgr_disable_command_type(g_conn_listener, msg);
 978
 979                 /* client event */
 980                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
 981                         vcd_dbus_server_initialize(g_conn_listener, msg);
 982
 983                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
 984                         vcd_dbus_server_finalize(g_conn_listener, msg);
 985 #if 0
 986                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
 987                         vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
 988 #endif
 989                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
 990                         vcd_dbus_server_set_command(g_conn_listener, msg);
 991
 992                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
 993                         vcd_dbus_server_unset_command(g_conn_listener, msg);
 994
 995                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
 996                         vcd_dbus_server_set_foreground(g_conn_listener, msg);
 997
 998                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_DIALOG))
 999                         vcd_dbus_server_dialog(g_conn_listener, msg);
1000
1001                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_IS_SYS_COMMAND_VALID))
1002                         vcd_dbus_server_is_system_command_valid(g_conn_listener, msg);
1003
1004 #if 0
1005                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
1006                         vcd_dbus_server_start_request(g_conn_listener, msg);
1007
1008                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
1009                         vcd_dbus_server_stop_request(g_conn_listener, msg);
1010
1011                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
1012                         vcd_dbus_server_cancel_request(g_conn_listener, msg);
1013 #endif
1014                 /* widget event */
1015                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
1016                         vcd_dbus_server_widget_initialize(g_conn_listener, msg);
1017
1018                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
1019                         vcd_dbus_server_widget_finalize(g_conn_listener, msg);
1020
1021                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
1022                         vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
1023
1024                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
1025                         vcd_dbus_server_widget_start(g_conn_listener, msg);
1026
1027                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
1028                         vcd_dbus_server_widget_stop(g_conn_listener, msg);
1029
1030                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
1031                         vcd_dbus_server_widget_cancel(g_conn_listener, msg);
1032
1033                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_ENABLE_ASR_RESULT))
1034                         vcd_dbus_server_widget_enable_asr_result(g_conn_listener, msg);
1035
1036                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_SETTING_METHOD_SET_LANGUAGE))
1037                         vcd_dbus_server_set_language(g_conn_listener, msg);
1038
1039                 else {
1040                         SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
1041                         dbus_message_unref(msg);
1042                         break;
1043                 }
1044
1045                 /* free the message */
1046                 dbus_message_unref(msg);
1047         }
1048
1049         return ECORE_CALLBACK_RENEW;
1050 }
1051
1052 int vcd_dbus_open_connection()
1053 {
1054         DBusError err;
1055         dbus_error_init(&err);
1056
1057         int ret;
1058
1059         /* Create connection for sender */
1060         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
1061
1062         if (dbus_error_is_set(&err)) {
1063                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
1064                 dbus_error_free(&err);
1065         }
1066
1067         if (NULL == g_conn_sender) {
1068                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
1069                 return VCD_ERROR_OPERATION_FAILED;
1070         }
1071
1072         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
1073
1074         /* connect to the bus and check for errors */
1075         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
1076
1077         if (dbus_error_is_set(&err)) {
1078                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
1079                 dbus_error_free(&err);
1080         }
1081
1082         if (NULL == g_conn_listener) {
1083                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
1084                 return VCD_ERROR_OPERATION_FAILED;
1085         }
1086
1087         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
1088
1089         /* request our name on the bus and check for errors */
1090         ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
1091
1092         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
1093                 printf("Fail to be primary owner in dbus request.");
1094                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
1095                 return VCD_ERROR_OPERATION_FAILED;
1096         }
1097
1098         if (dbus_error_is_set(&err)) {
1099                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
1100                 dbus_error_free(&err);
1101                 return VCD_ERROR_OPERATION_FAILED;
1102         }
1103
1104         /* add a rule for getting signal */
1105         char rule[128];
1106         snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
1107
1108         /* add a rule for which messages we want to see */
1109         dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
1110         dbus_connection_flush(g_conn_listener);
1111
1112         if (dbus_error_is_set(&err)) {
1113                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
1114                 dbus_error_free(&err);
1115                 return VCD_ERROR_OPERATION_FAILED;
1116         }
1117
1118         int fd = 0;
1119         dbus_connection_get_unix_fd(g_conn_listener, &fd);
1120
1121         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
1122
1123         if (NULL == g_dbus_fd_handler) {
1124                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
1125                 return VCD_ERROR_OPERATION_FAILED;
1126         }
1127
1128         return 0;
1129 }
1130
1131 int vcd_dbus_close_connection()
1132 {
1133         DBusError err;
1134         dbus_error_init(&err);
1135
1136         if (NULL != g_dbus_fd_handler) {
1137                 ecore_main_fd_handler_del(g_dbus_fd_handler);
1138                 g_dbus_fd_handler = NULL;
1139         }
1140
1141         dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
1142
1143         if (dbus_error_is_set(&err)) {
1144                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
1145                 dbus_error_free(&err);
1146         }
1147
1148         dbus_connection_close(g_conn_listener);
1149         dbus_connection_unref(g_conn_listener);
1150         dbus_connection_close(g_conn_sender);
1151         dbus_connection_unref(g_conn_sender);
1152
1153         g_conn_listener = NULL;
1154         g_conn_sender = NULL;
1155
1156         return 0;
1157 }