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 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         DBusError err;
 339         dbus_error_init(&err);
 340
 341         DBusMessage* result_msg;
 342
 343         int result = 0;
 344         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 5000, &err);
 345         dbus_message_unref(msg);
 346
 347         if (dbus_error_is_set(&err)) {
 348                 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", err.message);
 349                 dbus_error_free(&err);
 350         }
 351
 352         if (NULL != result_msg) {
 353                 dbus_message_get_args(result_msg, &err,
 354                         DBUS_TYPE_INT32, &result,
 355                         DBUS_TYPE_INVALID);
 356
 357                 if (dbus_error_is_set(&err)) {
 358                         SLOG(LOG_ERROR, TAG_VCD, "<<<< Get arguments error (%s)", err.message);
 359                         dbus_error_free(&err);
 360                         result = VCD_ERROR_OPERATION_FAILED;
 361                 }
 362
 363                 dbus_message_unref(result_msg);
 364                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< vc send asr result : result = %d", result);
 365                 *is_consumed = result;
 366                 return VCD_ERROR_NONE;
 367         } else {
 368                 SLOG(LOG_ERROR, TAG_VCD, "<<<< Result message is NULL ");
 369                 return VCD_ERROR_OPERATION_FAILED;
 370         }
 371 }
 372
 373 int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
 374 {
 375         if (0 != __dbus_check()) {
 376                 return VCD_ERROR_OPERATION_FAILED;
 377         }
 378
 379         DBusError err;
 380         dbus_error_init(&err);
 381
 382         DBusMessage* msg = NULL;
 383
 384         msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
 385
 386         if (NULL == msg) {
 387                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 388                 return VCD_ERROR_OUT_OF_MEMORY;
 389         }
 390
 391         dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
 392
 393         dbus_message_set_no_reply(msg, TRUE);
 394
 395         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 396                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 397                 return VCD_ERROR_OPERATION_FAILED;
 398         } else {
 399                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 400                 dbus_connection_flush(g_conn_sender);
 401         }
 402
 403         return 0;
 404 }
 405
 406 int vcdc_send_result_to_manager(int manger_pid, int result_type)
 407 {
 408         if (0 != __dbus_check()) {
 409                 return VCD_ERROR_OPERATION_FAILED;
 410         }
 411
 412         DBusError err;
 413         dbus_error_init(&err);
 414
 415         DBusMessage* msg = NULL;
 416
 417         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
 418
 419         if (NULL == msg) {
 420                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 421                 return VCD_ERROR_OUT_OF_MEMORY;
 422         }
 423
 424         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
 425
 426         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 427
 428         dbus_message_set_no_reply(msg, TRUE);
 429
 430         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 431                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 432                 return VCD_ERROR_OPERATION_FAILED;
 433         } else {
 434                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 435                 dbus_connection_flush(g_conn_sender);
 436         }
 437
 438         dbus_message_unref(msg);
 439
 440         return 0;
 441 }
 442
 443 int vcdc_send_speech_detected(int manger_pid)
 444 {
 445         if (0 != __dbus_check()) {
 446                 return VCD_ERROR_OPERATION_FAILED;
 447         }
 448
 449         DBusError err;
 450         dbus_error_init(&err);
 451
 452         /* Send to manager */
 453         DBusMessage* msg = NULL;
 454
 455         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
 456
 457         if (NULL == msg) {
 458                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 459                 return VCD_ERROR_OUT_OF_MEMORY;
 460         }
 461
 462         dbus_message_set_no_reply(msg, TRUE);
 463
 464         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 465                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 466                 return VCD_ERROR_OPERATION_FAILED;
 467         } else {
 468                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 469                 dbus_connection_flush(g_conn_sender);
 470         }
 471
 472         dbus_message_unref(msg);
 473
 474         return 0;
 475 }
 476
 477 int vcdc_send_service_state(vcd_state_e state)
 478 {
 479         if (0 != __dbus_check()) {
 480                 return VCD_ERROR_OPERATION_FAILED;
 481         }
 482
 483         DBusError err;
 484         dbus_error_init(&err);
 485
 486         DBusMessage* msg = NULL;
 487
 488         msg = dbus_message_new_signal(
 489                 VC_MANAGER_SERVICE_OBJECT_PATH,
 490                 VC_MANAGER_SERVICE_INTERFACE,
 491                 VCD_MANAGER_METHOD_SET_SERVICE_STATE);
 492
 493         if (NULL == msg) {
 494                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 495                 return VCD_ERROR_OUT_OF_MEMORY;
 496         }
 497
 498         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 499
 500         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 501                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 502                 return VCD_ERROR_OPERATION_FAILED;
 503         } else {
 504                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to manager : state(%d)", state);
 505                 dbus_connection_flush(g_conn_sender);
 506         }
 507
 508         dbus_message_unref(msg);
 509
 510         /* Send to client */
 511         msg = NULL;
 512
 513         msg = dbus_message_new_signal(
 514                 VC_CLIENT_SERVICE_OBJECT_PATH,
 515                 VC_CLIENT_SERVICE_INTERFACE,
 516                 VCD_METHOD_SET_SERVICE_STATE);
 517
 518         if (NULL == msg) {
 519                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 520                 return VCD_ERROR_OUT_OF_MEMORY;
 521         }
 522
 523         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 524
 525         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 526                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 527                 return VCD_ERROR_OPERATION_FAILED;
 528         } else {
 529                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to client : state(%d)", state);
 530                 dbus_connection_flush(g_conn_sender);
 531         }
 532
 533         dbus_message_unref(msg);
 534
 535         msg = NULL;
 536
 537         /* Send to widget client */
 538         msg = dbus_message_new_signal(
 539                 VC_WIDGET_SERVICE_OBJECT_PATH,
 540                 VC_WIDGET_SERVICE_INTERFACE,
 541                 VCD_WIDGET_METHOD_SET_SERVICE_STATE);
 542
 543         if (NULL == msg) {
 544                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 545                 return VCD_ERROR_OUT_OF_MEMORY;
 546         }
 547
 548         dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 549
 550         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 551                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 552                 return VCD_ERROR_OPERATION_FAILED;
 553         } else {
 554                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send serive state message to widget client : state(%d)", state);
 555                 dbus_connection_flush(g_conn_sender);
 556         }
 557
 558         dbus_message_unref(msg);
 559
 560         return 0;
 561 }
 562
 563 int vcdc_send_manager_pid(int manager_pid)
 564 {
 565         DBusError err;
 566         dbus_error_init(&err);
 567
 568         DBusMessage* msg = NULL;
 569
 570         /* Send to client */
 571         msg = dbus_message_new_signal(
 572                 VC_CLIENT_SERVICE_OBJECT_PATH,
 573                 VC_CLIENT_SERVICE_INTERFACE,
 574                 VCD_METHOD_SEND_MANAGER_PID);
 575
 576         if (NULL == msg) {
 577                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 578                 return VCD_ERROR_OUT_OF_MEMORY;
 579         }
 580
 581         dbus_message_append_args(msg, DBUS_TYPE_INT32, &manager_pid, DBUS_TYPE_INVALID);
 582
 583         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 584                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 585                 return VCD_ERROR_OPERATION_FAILED;
 586         } else {
 587                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send manager pid to client : pid(%d)", manager_pid);
 588                 dbus_connection_flush(g_conn_sender);
 589         }
 590
 591         dbus_message_unref(msg);
 592
 593         return 0;
 594 }
 595
 596 int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
 597 {
 598         if (0 != __dbus_check()) {
 599                 return VCD_ERROR_OPERATION_FAILED;
 600         }
 601
 602         DBusError err;
 603         dbus_error_init(&err);
 604
 605         DBusMessage* msg = NULL;
 606
 607         msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER);
 608
 609         if (NULL == msg) {
 610                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 611                 return VCD_ERROR_OUT_OF_MEMORY;
 612         }
 613
 614         SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
 615
 616         dbus_message_append_args(msg,
 617                                 DBUS_TYPE_INT32, &pid,
 618                                 DBUS_TYPE_STRING, &disp_text,
 619                                 DBUS_TYPE_STRING, &utt_text,
 620                                 DBUS_TYPE_INT32, &continuous,
 621                                 DBUS_TYPE_INVALID);
 622
 623         dbus_message_set_no_reply(msg, TRUE);
 624
 625         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 626                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 627                 return VCD_ERROR_OPERATION_FAILED;
 628         } else {
 629                 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
 630                 dbus_connection_flush(g_conn_sender);
 631         }
 632
 633         dbus_message_unref(msg);
 634
 635         return 0;
 636 }
 637
 638 int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
 639 {
 640         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal to manager");
 641
 642         if (NULL == err_msg) {
 643                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 644                 return VCD_ERROR_INVALID_PARAMETER;
 645         }
 646
 647         if (0 != __dbus_check()) {
 648                 return VCD_ERROR_OPERATION_FAILED;
 649         }
 650
 651         int daemon_pid;
 652         DBusError err;
 653         dbus_error_init(&err);
 654
 655         DBusMessage* msg = NULL;
 656
 657         msg = dbus_message_new_signal(
 658                 VC_MANAGER_SERVICE_OBJECT_PATH,
 659                 VC_MANAGER_SERVICE_INTERFACE,
 660                 VCD_MANAGER_METHOD_ERROR);
 661
 662         if (NULL == msg) {
 663                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 664                 return VCD_ERROR_OUT_OF_MEMORY;
 665         }
 666
 667         daemon_pid = getpid();
 668         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 669
 670         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 671                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 672                 return VCD_ERROR_OPERATION_FAILED;
 673         } else {
 674                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager : reason(%d), Error Msg(%s)", reason, err_msg);
 675                 dbus_connection_flush(g_conn_sender);
 676         }
 677
 678         dbus_message_unref(msg);
 679
 680         return 0;
 681 }
 682
 683 int vcdc_send_error_signal(int reason, char *err_msg)
 684 {
 685         SLOG(LOG_ERROR, TAG_VCD, ">>>> Send error signal");
 686
 687         if (NULL == err_msg) {
 688                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
 689                 return VCD_ERROR_INVALID_PARAMETER;
 690         }
 691
 692         if (0 != __dbus_check()) {
 693                 return VCD_ERROR_OPERATION_FAILED;
 694         }
 695
 696         int daemon_pid;
 697         DBusError err;
 698         dbus_error_init(&err);
 699
 700         DBusMessage* msg = NULL;
 701
 702         msg = dbus_message_new_signal(
 703                 VC_MANAGER_SERVICE_OBJECT_PATH,
 704                 VC_MANAGER_SERVICE_INTERFACE,
 705                 VCD_MANAGER_METHOD_ERROR);
 706
 707         if (NULL == msg) {
 708                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 709                 return VCD_ERROR_OUT_OF_MEMORY;
 710         }
 711
 712         daemon_pid = getpid();
 713         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 714
 715         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 716                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 717                 return VCD_ERROR_OPERATION_FAILED;
 718         } else {
 719                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 720                 dbus_connection_flush(g_conn_sender);
 721         }
 722
 723         dbus_message_unref(msg);
 724
 725         msg = NULL;
 726         msg = dbus_message_new_signal(
 727                 VC_CLIENT_SERVICE_OBJECT_PATH,
 728                 VC_CLIENT_SERVICE_INTERFACE,
 729                 VCD_METHOD_ERROR);
 730
 731         if (NULL == msg) {
 732                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 733                 return VCD_ERROR_OUT_OF_MEMORY;
 734         }
 735
 736         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 737
 738         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 739                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 740                 return VCD_ERROR_OPERATION_FAILED;
 741         } else {
 742                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 743                 dbus_connection_flush(g_conn_sender);
 744         }
 745
 746         dbus_message_unref(msg);
 747
 748         msg = NULL;
 749         msg = dbus_message_new_signal(
 750                 VC_WIDGET_SERVICE_OBJECT_PATH,
 751                 VC_WIDGET_SERVICE_INTERFACE,
 752                 VCD_WIDGET_METHOD_ERROR);
 753
 754         if (NULL == msg) {
 755                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
 756                 return VCD_ERROR_OUT_OF_MEMORY;
 757         }
 758
 759         dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
 760
 761         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 762                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
 763                 return VCD_ERROR_OPERATION_FAILED;
 764         } else {
 765                 SLOG(LOG_DEBUG, TAG_VCD, "<<<< Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
 766                 dbus_connection_flush(g_conn_sender);
 767         }
 768
 769         dbus_message_unref(msg);
 770
 771         return 0;
 772 }
 773
 774 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 775 {
 776         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 777
 778         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 779
 780         while (1) {
 781                 DBusMessage* msg = NULL;
 782                 msg = dbus_connection_pop_message(g_conn_listener);
 783
 784                 /* loop again if we haven't read a message */
 785                 if (NULL == msg) {
 786                         break;
 787                 }
 788
 789                 /* Common event */
 790                 if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
 791                         vcd_dbus_server_hello(g_conn_listener, msg);
 792
 793                 /* manager event */
 794                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
 795                         vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
 796
 797                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
 798                         vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
 799
 800                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
 801                         vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
 802
 803                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
 804                         vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
 805
 806                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
 807                         vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
 808
 809                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
 810                         vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
 811
 812                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
 813                         vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
 814
 815                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
 816                         vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
 817
 818                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA))
 819                         vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg);
 820
 821                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA))
 822                         vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg);
 823
 824                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
 825                         vcd_dbus_server_mgr_start(g_conn_listener, msg);
 826
 827                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
 828                         vcd_dbus_server_mgr_stop(g_conn_listener, msg);
 829
 830                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
 831                         vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
 832
 833                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
 834                         vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
 835
 836                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN))
 837                         vcd_dbus_server_mgr_set_domain(g_conn_listener, msg);
 838
 839                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION))
 840                         vcd_dbus_server_mgr_do_action(g_conn_listener, msg);
 841
 842                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_ENABLE_COMMAND_TYPE))
 843                         vcd_dbus_server_mgr_enable_command_type(g_conn_listener, msg);
 844
 845                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DISABLE_COMMAND_TYPE))
 846                         vcd_dbus_server_mgr_disable_command_type(g_conn_listener, msg);
 847
 848                 /* client event */
 849                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
 850                         vcd_dbus_server_initialize(g_conn_listener, msg);
 851
 852                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
 853                         vcd_dbus_server_finalize(g_conn_listener, msg);
 854 #if 0
 855                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
 856                         vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
 857 #endif
 858                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
 859                         vcd_dbus_server_set_command(g_conn_listener, msg);
 860
 861                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
 862                         vcd_dbus_server_unset_command(g_conn_listener, msg);
 863
 864                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
 865                         vcd_dbus_server_set_foreground(g_conn_listener, msg);
 866
 867                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_DIALOG))
 868                         vcd_dbus_server_dialog(g_conn_listener, msg);
 869
 870                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_IS_SYS_COMMAND_VALID))
 871                         vcd_dbus_server_is_system_command_valid(g_conn_listener, msg);
 872
 873 #if 0
 874                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
 875                         vcd_dbus_server_start_request(g_conn_listener, msg);
 876
 877                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
 878                         vcd_dbus_server_stop_request(g_conn_listener, msg);
 879
 880                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
 881                         vcd_dbus_server_cancel_request(g_conn_listener, msg);
 882 #endif
 883                 /* widget event */
 884                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
 885                         vcd_dbus_server_widget_initialize(g_conn_listener, msg);
 886
 887                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
 888                         vcd_dbus_server_widget_finalize(g_conn_listener, msg);
 889
 890                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
 891                         vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
 892
 893                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
 894                         vcd_dbus_server_widget_start(g_conn_listener, msg);
 895
 896                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
 897                         vcd_dbus_server_widget_stop(g_conn_listener, msg);
 898
 899                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
 900                         vcd_dbus_server_widget_cancel(g_conn_listener, msg);
 901
 902                 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_ENABLE_ASR_RESULT))
 903                         vcd_dbus_server_widget_enable_asr_result(g_conn_listener, msg);
 904
 905                 else {
 906                         SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
 907                         dbus_message_unref(msg);
 908                         break;
 909                 }
 910
 911                 /* free the message */
 912                 dbus_message_unref(msg);
 913         }
 914
 915         return ECORE_CALLBACK_RENEW;
 916 }
 917
 918 int vcd_dbus_open_connection()
 919 {
 920         DBusError err;
 921         dbus_error_init(&err);
 922
 923         int ret;
 924
 925         /* Create connection for sender */
 926         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 927
 928         if (dbus_error_is_set(&err)) {
 929                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 930                 dbus_error_free(&err);
 931         }
 932
 933         if (NULL == g_conn_sender) {
 934                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 935                 return VCD_ERROR_OPERATION_FAILED;
 936         }
 937
 938         /* connect to the bus and check for errors */
 939         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 940
 941         if (dbus_error_is_set(&err)) {
 942                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
 943                 dbus_error_free(&err);
 944         }
 945
 946         if (NULL == g_conn_listener) {
 947                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
 948                 return VCD_ERROR_OPERATION_FAILED;
 949         }
 950
 951         /* request our name on the bus and check for errors */
 952         ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 953
 954         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 955                 printf("Fail to be primary owner in dbus request.");
 956                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
 957                 return VCD_ERROR_OPERATION_FAILED;
 958         }
 959
 960         if (dbus_error_is_set(&err)) {
 961                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
 962                 dbus_error_free(&err);
 963                 return VCD_ERROR_OPERATION_FAILED;
 964         }
 965
 966         /* add a rule for getting signal */
 967         char rule[128];
 968         snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
 969
 970         /* add a rule for which messages we want to see */
 971         dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
 972         dbus_connection_flush(g_conn_listener);
 973
 974         if (dbus_error_is_set(&err)) {
 975                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
 976                 dbus_error_free(&err);
 977                 return VCD_ERROR_OPERATION_FAILED;
 978         }
 979
 980         int fd = 0;
 981         dbus_connection_get_unix_fd(g_conn_listener, &fd);
 982
 983         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 984
 985         if (NULL == g_dbus_fd_handler) {
 986                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
 987                 return VCD_ERROR_OPERATION_FAILED;
 988         }
 989
 990         return 0;
 991 }
 992
 993 int vcd_dbus_close_connection()
 994 {
 995         DBusError err;
 996         dbus_error_init(&err);
 997
 998         if (NULL != g_dbus_fd_handler) {
 999                 ecore_main_fd_handler_del(g_dbus_fd_handler);
1000                 g_dbus_fd_handler = NULL;
1001         }
1002
1003         dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
1004
1005         if (dbus_error_is_set(&err)) {
1006                 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
1007                 dbus_error_free(&err);
1008         }
1009
1010         dbus_connection_close(g_conn_listener);
1011         dbus_connection_close(g_conn_sender);
1012
1013         dbus_connection_unref(g_conn_listener);
1014         dbus_connection_unref(g_conn_sender);
1015
1016         g_conn_listener = NULL;
1017         g_conn_sender = NULL;
1018
1019         return 0;
1020 }