client/vc_widget_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
  18 #include "vc_main.h"
  19 #include "vc_widget_client.h"
  20 #include "vc_widget_dbus.h"
  21
  22
  23 static int g_w_waiting_time = 3000;
  24
  25 static Ecore_Fd_Handler* g_w_fd_handler = NULL;
  26
  27 static DBusConnection* g_w_conn_sender = NULL;
  28 static DBusConnection* g_w_conn_listener = NULL;
  29
  30 extern int __vc_widget_cb_error(int reason, int daemon_pid, char* msg);
  31
  32 extern void __vc_widget_cb_show_tooltip(int pid, bool show);
  33
  34 extern void __vc_widget_cb_result();
  35
  36 extern bool __vc_widget_cb_asr_result(int event, const char* asr_result);
  37
  38 extern int __vc_widget_cb_service_state(int state);
  39
  40
  41 static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  42 {
  43         if (NULL == g_w_conn_listener)  return ECORE_CALLBACK_RENEW;
  44
  45         dbus_connection_read_write_dispatch(g_w_conn_listener, 50);
  46
  47         while (1) {
  48                 DBusMessage* msg = NULL;
  49                 msg = dbus_connection_pop_message(g_w_conn_listener);
  50
  51                 /* loop again if we haven't read a message */
  52                 if (NULL == msg) {
  53                         break;
  54                 }
  55
  56                 SLOG(LOG_DEBUG, TAG_VCW, "[DEBUG] Message is arrived");
  57
  58                 DBusError err;
  59                 dbus_error_init(&err);
  60
  61                 char if_name[64] = {0, };
  62                 snprintf(if_name, 64, "%s", VC_WIDGET_SERVICE_INTERFACE);
  63
  64                 if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_HELLO)) {
  65                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget hello");
  66                         int pid = 0;
  67                         int response = -1;
  68
  69                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  70
  71                         if (dbus_error_is_set(&err)) {
  72                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
  73                                 dbus_error_free(&err);
  74                         }
  75
  76                         if (pid > 0) {
  77                                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get hello : pid(%d) ", pid);
  78                                 response = 1;
  79                         } else {
  80                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get hello : invalid pid ");
  81                         }
  82
  83                         DBusMessage* reply = NULL;
  84                         reply = dbus_message_new_method_return(msg);
  85
  86                         if (NULL != reply) {
  87                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  88
  89                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
  90                                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get hello : fail to send reply");
  91                                 else
  92                                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get hello : result(%d)", response);
  93
  94                                 dbus_connection_flush(g_w_conn_listener);
  95                                 dbus_message_unref(reply);
  96                         } else {
  97                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get hello : fail to create reply message");
  98                         }
  99
 100                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 101                 } /* VCD_WIDGET_METHOD_HELLO */
 102
 103                 else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_SET_SERVICE_STATE)) {
 104                         int state = 0;
 105
 106                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 107                         if (dbus_error_is_set(&err)) {
 108                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Get arguments error (%s)", err.message);
 109                                 dbus_error_free(&err);
 110                         }
 111
 112                         SLOG(LOG_DEBUG, TAG_VCW, "@@ service state changed : %d", state);
 113
 114                         __vc_widget_cb_service_state(state);
 115
 116                 } /* VCD_WIDGET_METHOD_SET_SERVICE_STATE */
 117
 118                 else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_SHOW_TOOLTIP)) {
 119                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Show / Hide tooltip");
 120                         int pid = 0;
 121                         int show = 0;
 122
 123                         dbus_message_get_args(msg, &err,
 124                                         DBUS_TYPE_INT32, &pid,
 125                                         DBUS_TYPE_INT32, &show,
 126                                         DBUS_TYPE_INVALID);
 127
 128                         if (dbus_error_is_set(&err)) {
 129                                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 130                                 dbus_error_free(&err);
 131                         }
 132
 133                         if (pid > 0) {
 134                                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget show tooltip : pid(%d), show(%d)", pid, show);
 135                                 __vc_widget_cb_show_tooltip(pid, (bool)show);
 136                         } else {
 137                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget show tooltip : invalid pid");
 138                         }
 139
 140                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 141                 } /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
 142
 143                 else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
 144                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget result");
 145
 146                         __vc_widget_cb_result();
 147
 148                         /*
 149                         reply = dbus_message_new_method_return(msg);
 150
 151                         if (NULL != reply) {
 152                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
 153                                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get result : fail to send reply");
 154                                 else
 155                                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get result");
 156
 157                                 dbus_connection_flush(g_w_conn_listener);
 158                                 dbus_message_unref(reply);
 159                         } else {
 160                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get result : fail to create reply message");
 161
 162                         */
 163
 164                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 165
 166                 } /* VCD_WIDGET_METHOD_RESULT */
 167
 168                 else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_ASR_RESULT)) {
 169                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget asr result");
 170                         int ret = 0;
 171                         int event = -1;
 172                         char* asr_result = NULL;
 173
 174                         dbus_message_get_args(msg, &err,
 175                                 DBUS_TYPE_INT32, &event,
 176                                 DBUS_TYPE_STRING, &asr_result,
 177                                 DBUS_TYPE_INVALID);
 178
 179                         if (false == __vc_widget_cb_asr_result(event, asr_result))
 180                                 ret = 0;
 181                         else
 182                                 ret = 1;
 183
 184                         DBusMessage* reply = dbus_message_new_method_return(msg);
 185                         if (NULL != reply) {
 186                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 187                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
 188                                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get asr result : fail to send reply");
 189                                 else
 190                                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get asr result, event(%d), asr_result(%s), consumed(%d)", event, asr_result, ret);
 191
 192                                 dbus_connection_flush(g_w_conn_listener);
 193                                 dbus_message_unref(reply);
 194                         } else {
 195                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget asr get result : fail to create reply message");
 196                         }
 197
 198                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 199
 200                 } /* VCD_WIDGET_METHOD_ASR_RESULT */
 201
 202                 else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
 203                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Get widget error");
 204                         int reason;
 205                         int daemon_pid;
 206                         char* err_msg;
 207
 208                         dbus_message_get_args(msg, &err,
 209                                 DBUS_TYPE_INT32, &reason,
 210                                 DBUS_TYPE_INT32, &daemon_pid,
 211                                 DBUS_TYPE_STRING, &err_msg,
 212                                 DBUS_TYPE_INVALID);
 213
 214                         if (dbus_error_is_set(&err)) {
 215                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget get error message : Get arguments error (%s)", err.message);
 216                                 dbus_error_free(&err);
 217                         } else {
 218                                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget get error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
 219                                 __vc_widget_cb_error(reason, daemon_pid, err_msg);
 220                         }
 221
 222                         /*
 223                         reply = dbus_message_new_method_return(msg);
 224
 225                         if (NULL != reply) {
 226                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
 227                                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget error message : fail to send reply");
 228                                 else
 229                                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget error message");
 230
 231                                 dbus_connection_flush(g_w_conn_listener);
 232                                 dbus_message_unref(reply);
 233                         } else {
 234                                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget error message : fail to create reply message");
 235                         }
 236                         */
 237
 238                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 239                 } /* VCD_WIDGET_METHOD_ERROR */
 240
 241                 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 242                         SLOG(LOG_DEBUG, TAG_VCW, "@@@ Owner Changed");
 243                         DBusError err;
 244                         dbus_error_init(&err);
 245
 246                         /* remove a rule for daemon error */
 247                         char rule_err[256] = {0, };
 248                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
 249                         dbus_bus_remove_match(g_w_conn_listener, rule_err, &err);
 250                         dbus_connection_flush(g_w_conn_listener);
 251
 252                         if (dbus_error_is_set(&err)) {
 253                                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 254                                 dbus_error_free(&err);
 255                         }
 256                         __vc_widget_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
 257                         SLOG(LOG_DEBUG, TAG_VCW, "@@@");
 258                 } /* NameOwnerChanged */
 259
 260                 else {
 261                         SLOG(LOG_ERROR, TAG_VCW, "Message is NOT valid");
 262                         dbus_message_unref(msg);
 263                         break;
 264                 }
 265
 266                 /* free the message */
 267                 dbus_message_unref(msg);
 268         } /* while(1) */
 269
 270         return ECORE_CALLBACK_PASS_ON;
 271 }
 272
 273 static void __vc_mgr_dbus_connection_free()
 274 {
 275         if (NULL != g_w_conn_listener) {
 276                 dbus_connection_close(g_w_conn_listener);
 277                 g_w_conn_listener = NULL;
 278         }
 279         if (NULL != g_w_conn_sender) {
 280                 dbus_connection_close(g_w_conn_sender);
 281                 g_w_conn_sender = NULL;
 282         }
 283 }
 284
 285 int vc_widget_dbus_open_connection()
 286 {
 287         if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
 288                 SLOG(LOG_WARN, TAG_VCW, "Already existed connection ");
 289                 return 0;
 290         }
 291
 292         DBusError err;
 293         int ret;
 294
 295         /* initialise the error value */
 296         dbus_error_init(&err);
 297
 298         /* connect to the DBUS system bus, and check for errors */
 299         g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 300
 301         if (dbus_error_is_set(&err)) {
 302                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 303                 dbus_error_free(&err);
 304         }
 305
 306         if (NULL == g_w_conn_sender) {
 307                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 308                 return VC_ERROR_OPERATION_FAILED;
 309         }
 310
 311         dbus_connection_set_exit_on_disconnect(g_w_conn_sender, false);
 312
 313         g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 314
 315         if (dbus_error_is_set(&err)) {
 316                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 317                 dbus_error_free(&err);
 318         }
 319
 320         if (NULL == g_w_conn_listener) {
 321                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 322                 __vc_mgr_dbus_connection_free();
 323                 return VC_ERROR_OPERATION_FAILED;
 324         }
 325
 326         dbus_connection_set_exit_on_disconnect(g_w_conn_listener, false);
 327
 328         int pid = getpid();
 329
 330         char service_name[64];
 331         memset(service_name, '\0', 64);
 332         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 333
 334         SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
 335
 336         /* register our name on the bus, and check for errors */
 337         ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 338
 339         if (dbus_error_is_set(&err)) {
 340                 SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
 341                 dbus_error_free(&err);
 342         }
 343
 344         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 345                 SLOG(LOG_ERROR, TAG_VCW, "fail dbus_bus_request_name()");
 346                 __vc_mgr_dbus_connection_free();
 347                 return -2;
 348         }
 349
 350         if (NULL != g_w_fd_handler) {
 351                 SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
 352                 __vc_mgr_dbus_connection_free();
 353                 return 0;
 354         }
 355
 356         char rule[128] = {0, };
 357         snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
 358
 359         /* add a rule for which messages we want to see */
 360         dbus_bus_add_match(g_w_conn_listener, rule, &err);
 361         dbus_connection_flush(g_w_conn_listener);
 362
 363         if (dbus_error_is_set(&err)) {
 364                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 365                 dbus_error_free(&err);
 366                 __vc_mgr_dbus_connection_free();
 367                 return VC_ERROR_OPERATION_FAILED;
 368         }
 369
 370         int fd = 0;
 371         if (1 != dbus_connection_get_unix_fd(g_w_conn_listener, &fd)) {
 372                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd from dbus ");
 373                 __vc_mgr_dbus_connection_free();
 374                 return VC_ERROR_OPERATION_FAILED;
 375         } else {
 376                 SLOG(LOG_DEBUG, TAG_VCW, "Get fd from dbus : %d", fd);
 377         }
 378
 379         g_w_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)widget_listener_event_callback, g_w_conn_listener, NULL, NULL);
 380
 381         if (NULL == g_w_fd_handler) {
 382                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd handler from ecore ");
 383                 __vc_mgr_dbus_connection_free();
 384                 return VC_ERROR_OPERATION_FAILED;
 385         }
 386
 387         return 0;
 388 }
 389
 390 int vc_widget_dbus_close_connection()
 391 {
 392         DBusError err;
 393         dbus_error_init(&err);
 394
 395         if (NULL != g_w_fd_handler) {
 396                 ecore_main_fd_handler_del(g_w_fd_handler);
 397                 g_w_fd_handler = NULL;
 398         }
 399
 400         int pid = getpid();
 401
 402         char service_name[64];
 403         memset(service_name, '\0', 64);
 404         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 405
 406         dbus_bus_release_name(g_w_conn_listener, service_name, &err);
 407
 408         if (dbus_error_is_set(&err)) {
 409                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 410                 dbus_error_free(&err);
 411         }
 412
 413         __vc_mgr_dbus_connection_free();
 414
 415         return 0;
 416 }
 417
 418 int vc_widget_dbus_reconnect()
 419 {
 420         if (!g_w_conn_sender || !g_w_conn_listener) {
 421                 vc_widget_dbus_close_connection();
 422
 423                 if (0 != vc_widget_dbus_open_connection()) {
 424                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to reconnect");
 425                         return -1;
 426                 }
 427
 428                 SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
 429                 return 0;
 430         }
 431
 432         bool sender_connected = dbus_connection_get_is_connected(g_w_conn_sender);
 433         bool listener_connected = dbus_connection_get_is_connected(g_w_conn_listener);
 434         SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Sender(%s) Listener(%s)",
 435                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 436
 437         if (false == sender_connected || false == listener_connected) {
 438                 vc_widget_dbus_close_connection();
 439
 440                 if (0 != vc_widget_dbus_open_connection()) {
 441                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to reconnect");
 442                         return -1;
 443                 }
 444
 445                 SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
 446         }
 447
 448         return 0;
 449 }
 450
 451 static int __dbus_check()
 452 {
 453         if (NULL == g_w_conn_sender) {
 454                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NULL connection");
 455                 return vc_widget_dbus_reconnect();
 456         }
 457         return 0;
 458 }
 459
 460 int vc_widget_dbus_request_hello()
 461 {
 462         if (0 != __dbus_check()) {
 463                 return VC_ERROR_OPERATION_FAILED;
 464         }
 465
 466         DBusMessage* msg;
 467
 468         msg = dbus_message_new_method_call(
 469                           VC_SERVER_SERVICE_NAME,
 470                           VC_SERVER_SERVICE_OBJECT_PATH,
 471                           VC_SERVER_SERVICE_INTERFACE,
 472                           VC_METHOD_HELLO);
 473
 474         if (NULL == msg) {
 475                 SLOG(LOG_ERROR, TAG_VCW, "@@ Request vc hello : Fail to make message");
 476                 return VC_ERROR_OPERATION_FAILED;
 477         }
 478
 479         DBusError err;
 480         dbus_error_init(&err);
 481
 482         DBusMessage* result_msg = NULL;
 483         int result = 0;
 484
 485         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, 500, &err);
 486
 487         if (dbus_error_is_set(&err)) {
 488                 dbus_error_free(&err);
 489         }
 490
 491         dbus_message_unref(msg);
 492
 493         if (NULL != result_msg) {
 494                 dbus_message_unref(result_msg);
 495                 result = 0;
 496         } else {
 497                 result = VC_ERROR_TIMED_OUT;
 498         }
 499
 500         return result;
 501 }
 502
 503
 504 int vc_widget_dbus_request_initialize(int pid, int* service_state, int* daemon_pid)
 505 {
 506         if (0 != __dbus_check()) {
 507                 return VC_ERROR_OPERATION_FAILED;
 508         }
 509
 510         DBusMessage* msg;
 511
 512         msg = dbus_message_new_method_call(
 513                           VC_SERVER_SERVICE_NAME,
 514                           VC_SERVER_SERVICE_OBJECT_PATH,
 515                           VC_SERVER_SERVICE_INTERFACE,
 516                           VC_WIDGET_METHOD_INITIALIZE);
 517
 518         if (NULL == msg) {
 519                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget initialize : Fail to make message ");
 520                 return VC_ERROR_OPERATION_FAILED;
 521         } else {
 522                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget initialize : pid(%d)", pid);
 523         }
 524
 525         dbus_message_append_args(msg,
 526                                                          DBUS_TYPE_INT32, &pid,
 527                                                          DBUS_TYPE_INVALID);
 528
 529         DBusError err;
 530         dbus_error_init(&err);
 531
 532         DBusMessage* result_msg;
 533         int result = VC_ERROR_OPERATION_FAILED;
 534
 535         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 536         dbus_message_unref(msg);
 537
 538         if (dbus_error_is_set(&err)) {
 539                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 540                 dbus_error_free(&err);
 541         }
 542
 543         if (NULL != result_msg) {
 544                 int tmp_service_state = 0;
 545                 int tmp_daemon_pid = 0;
 546                 dbus_message_get_args(result_msg, &err,
 547                         DBUS_TYPE_INT32, &result,
 548                         DBUS_TYPE_INT32, &tmp_service_state,
 549                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 550                         DBUS_TYPE_INVALID);
 551
 552                 if (dbus_error_is_set(&err)) {
 553                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 554                         dbus_error_free(&err);
 555                         result = VC_ERROR_OPERATION_FAILED;
 556                 }
 557
 558                 dbus_message_unref(result_msg);
 559
 560                 if (0 == result) {
 561                         *service_state = tmp_service_state;
 562                         *daemon_pid = tmp_daemon_pid;
 563
 564                         /* add a rule for daemon error */
 565                         char rule_err[256] = {0, };
 566                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
 567                         dbus_bus_add_match(g_w_conn_listener, rule_err, &err);
 568                         dbus_connection_flush(g_w_conn_listener);
 569
 570                         if (dbus_error_is_set(&err)) {
 571                                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 572                                 dbus_error_free(&err);
 573                                 return VC_ERROR_OPERATION_FAILED;
 574                         }
 575
 576                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget initialize : result = %d service = %d daemon_pid = %d", result, *service_state, *daemon_pid);
 577                 } else {
 578                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget initialize : result = %d", result);
 579                 }
 580         } else {
 581                 SLOG(LOG_ERROR, TAG_VCW, "@@ Result message is NULL ");
 582                 vc_widget_dbus_reconnect();
 583                 result = VC_ERROR_TIMED_OUT;
 584         }
 585
 586         return result;
 587 }
 588
 589 int vc_widget_dbus_request_finalize(int pid)
 590 {
 591         if (0 != __dbus_check()) {
 592                 return VC_ERROR_OPERATION_FAILED;
 593         }
 594
 595         DBusError err;
 596         dbus_error_init(&err);
 597
 598         /* remove a rule for daemon error */
 599         char rule_err[256] = {0, };
 600         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
 601         dbus_bus_remove_match(g_w_conn_listener, rule_err, &err);
 602         dbus_connection_flush(g_w_conn_listener);
 603
 604         if (dbus_error_is_set(&err)) {
 605                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 606                 dbus_error_free(&err);
 607                 return VC_ERROR_OPERATION_FAILED;
 608         }
 609
 610         DBusMessage* msg;
 611
 612         msg = dbus_message_new_method_call(
 613                           VC_SERVER_SERVICE_NAME,
 614                           VC_SERVER_SERVICE_OBJECT_PATH,
 615                           VC_SERVER_SERVICE_INTERFACE,
 616                           VC_WIDGET_METHOD_FINALIZE);
 617
 618         if (NULL == msg) {
 619                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget finalize : Fail to make message ");
 620                 return VC_ERROR_OPERATION_FAILED;
 621         } else {
 622                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget finalize : pid(%d)", pid);
 623         }
 624
 625         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 626
 627         DBusMessage* result_msg;
 628         int result = VC_ERROR_OPERATION_FAILED;
 629
 630         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 631         dbus_message_unref(msg);
 632
 633         if (dbus_error_is_set(&err)) {
 634                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 635                 dbus_error_free(&err);
 636         }
 637
 638         if (NULL != result_msg) {
 639                 dbus_message_get_args(result_msg, &err,
 640                                                           DBUS_TYPE_INT32, &result,
 641                                                           DBUS_TYPE_INVALID);
 642
 643                 if (dbus_error_is_set(&err)) {
 644                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 645                         dbus_error_free(&err);
 646                         result = VC_ERROR_OPERATION_FAILED;
 647                 }
 648
 649                 dbus_message_unref(result_msg);
 650
 651                 if (0 == result) {
 652                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget finalize : result = %d", result);
 653                 } else {
 654                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget finalize : result = %d", result);
 655                 }
 656         } else {
 657                 SLOG(LOG_ERROR, TAG_VCW, "@@ Result message is NULL ");
 658                 vc_widget_dbus_reconnect();
 659                 result = VC_ERROR_TIMED_OUT;
 660         }
 661
 662         return result;
 663 }
 664
 665 int vc_widget_dbus_request_start_recording(int pid, bool command)
 666 {
 667         if (0 != __dbus_check()) {
 668                 return VC_ERROR_OPERATION_FAILED;
 669         }
 670
 671         DBusMessage* msg;
 672
 673         msg = dbus_message_new_method_call(
 674                           VC_SERVER_SERVICE_NAME,
 675                           VC_SERVER_SERVICE_OBJECT_PATH,
 676                           VC_SERVER_SERVICE_INTERFACE,
 677                           VC_WIDGET_METHOD_START_RECORDING);
 678
 679         if (NULL == msg) {
 680                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget start recording : Fail to make message");
 681                 return VC_ERROR_OPERATION_FAILED;
 682         } else {
 683                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget start recording : pid(%d)", pid);
 684         }
 685
 686         int temp = (int)command;
 687
 688         dbus_message_append_args(msg,
 689                                                          DBUS_TYPE_INT32, &pid,
 690                                                          DBUS_TYPE_INT32, &temp,
 691                                                          DBUS_TYPE_INVALID);
 692
 693         DBusError err;
 694         dbus_error_init(&err);
 695
 696         DBusMessage* result_msg;
 697         int result = VC_ERROR_OPERATION_FAILED;
 698
 699         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 700         dbus_message_unref(msg);
 701
 702         if (dbus_error_is_set(&err)) {
 703                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 704                 dbus_error_free(&err);
 705         }
 706
 707         if (NULL != result_msg) {
 708                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 709
 710                 if (dbus_error_is_set(&err)) {
 711                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 712                         dbus_error_free(&err);
 713                         result = VC_ERROR_OPERATION_FAILED;
 714                 }
 715                 dbus_message_unref(result_msg);
 716
 717                 if (0 == result) {
 718                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget start recording : result = %d", result);
 719                 } else {
 720                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget start recording : result = %d", result);
 721                 }
 722         } else {
 723                 SLOG(LOG_ERROR, TAG_VCW, "@@ Result message is NULL");
 724                 vc_widget_dbus_reconnect();
 725                 result = VC_ERROR_TIMED_OUT;
 726         }
 727
 728         return result;
 729 }
 730
 731 int vc_widget_dbus_set_foreground(int pid, bool value)
 732 {
 733         if (0 != __dbus_check()) {
 734                 return VC_ERROR_OPERATION_FAILED;
 735         }
 736
 737         DBusMessage* msg = NULL;
 738         int tmp_value = 0;
 739
 740         tmp_value = (int)value;
 741
 742         msg = dbus_message_new_signal(
 743                 VC_MANAGER_SERVICE_OBJECT_PATH,
 744                 VC_MANAGER_SERVICE_INTERFACE,
 745                 VCC_MANAGER_METHOD_SET_FOREGROUND);
 746
 747         if (NULL == msg) {
 748                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget set foreground to manager : Fail to make message");
 749                 return VC_ERROR_OPERATION_FAILED;
 750         } else {
 751                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 752         }
 753
 754         dbus_message_append_args(msg,
 755                 DBUS_TYPE_INT32, &pid,
 756                 DBUS_TYPE_INT32, &tmp_value,
 757                 DBUS_TYPE_INVALID);
 758
 759         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 760                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 761                 return VC_ERROR_OPERATION_FAILED;
 762         }
 763
 764         dbus_message_unref(msg);
 765
 766         msg = NULL;
 767         msg = dbus_message_new_method_call(
 768                 VC_SERVER_SERVICE_NAME,
 769                 VC_SERVER_SERVICE_OBJECT_PATH,
 770                 VC_SERVER_SERVICE_INTERFACE,
 771                 VC_METHOD_SET_FOREGROUND);
 772
 773         if (NULL == msg) {
 774                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget set foreground to daemon : Fail to make message");
 775                 return VC_ERROR_OPERATION_FAILED;
 776         } else {
 777                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 778         }
 779
 780         dbus_message_append_args(msg,
 781                 DBUS_TYPE_INT32, &pid,
 782                 DBUS_TYPE_INT32, &tmp_value,
 783                 DBUS_TYPE_INVALID);
 784
 785         dbus_message_set_no_reply(msg, TRUE);
 786
 787         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 788                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 789                 return VC_ERROR_OPERATION_FAILED;
 790         }
 791
 792         dbus_connection_flush(g_w_conn_sender);
 793
 794         dbus_message_unref(msg);
 795
 796         return 0;
 797 }
 798
 799 int vc_widget_dbus_request_enable_asr_result(int pid, bool enable)
 800 {
 801         if (0 != __dbus_check()) {
 802                 return VC_ERROR_OPERATION_FAILED;
 803         }
 804
 805         DBusMessage* msg;
 806
 807         /* create a signal & check for errors */
 808         msg = dbus_message_new_method_call(
 809                           VC_SERVER_SERVICE_NAME,
 810                           VC_SERVER_SERVICE_OBJECT_PATH,
 811                           VC_SERVER_SERVICE_INTERFACE,
 812                           VC_WIDGET_METHOD_ENABLE_ASR_RESULT);
 813
 814         if (NULL == msg) {
 815                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget enable asr result : Fail to make message ");
 816                 return VC_ERROR_OPERATION_FAILED;
 817         } else {
 818                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget enable asr result : pid(%d), enable(%d)", pid, enable);
 819         }
 820
 821         DBusMessageIter args;
 822         dbus_message_iter_init_append(msg, &args);
 823
 824         /* Append result*/
 825         int temp;
 826         if (false == enable)    temp = 0;
 827         else                    temp = 1;
 828         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 829         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
 830
 831         DBusError err;
 832         dbus_error_init(&err);
 833
 834         DBusMessage* result_msg;
 835         int result = VC_ERROR_OPERATION_FAILED;
 836
 837         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 838         dbus_message_unref(msg);
 839
 840         if (dbus_error_is_set(&err)) {
 841                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 842                 dbus_error_free(&err);
 843         }
 844
 845         if (NULL != result_msg) {
 846                 dbus_message_get_args(result_msg, &err,
 847                                                           DBUS_TYPE_INT32, &result,
 848                                                           DBUS_TYPE_INVALID);
 849
 850                 if (dbus_error_is_set(&err)) {
 851                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 852                         dbus_error_free(&err);
 853                         result = VC_ERROR_OPERATION_FAILED;
 854                 }
 855                 dbus_message_unref(result_msg);
 856
 857                 if (0 == result) {
 858                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget enable asr result : result = %d", result);
 859                 } else {
 860                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget enable asr result : result = %d", result);
 861                 }
 862         } else {
 863                 SLOG(LOG_DEBUG, TAG_VCW, "@@ Result Message is NULL");
 864                 vc_widget_dbus_reconnect();
 865                 result = VC_ERROR_TIMED_OUT;
 866         }
 867
 868         return result;
 869 }
 870
 871 int vc_widget_dbus_request_start(int pid, int silence)
 872 {
 873         if (0 != __dbus_check()) {
 874                 return VC_ERROR_OPERATION_FAILED;
 875         }
 876
 877         DBusMessage* msg;
 878
 879         /* create a signal & check for errors */
 880         msg = dbus_message_new_method_call(
 881                           VC_SERVER_SERVICE_NAME,
 882                           VC_SERVER_SERVICE_OBJECT_PATH,
 883                           VC_SERVER_SERVICE_INTERFACE,
 884                           VC_WIDGET_METHOD_START);
 885
 886         if (NULL == msg) {
 887                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget start : Fail to make message ");
 888                 return VC_ERROR_OPERATION_FAILED;
 889         } else {
 890                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget start : pid(%d), silence(%d)", pid, silence);
 891         }
 892
 893         DBusMessageIter args;
 894         dbus_message_iter_init_append(msg, &args);
 895
 896         /* Append result*/
 897         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 898         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 899
 900         DBusError err;
 901         dbus_error_init(&err);
 902
 903         DBusMessage* result_msg;
 904         int result = VC_ERROR_OPERATION_FAILED;
 905
 906         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 907         dbus_message_unref(msg);
 908
 909         if (dbus_error_is_set(&err)) {
 910                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 911                 dbus_error_free(&err);
 912         }
 913
 914         if (NULL != result_msg) {
 915                 dbus_message_get_args(result_msg, &err,
 916                                                           DBUS_TYPE_INT32, &result,
 917                                                           DBUS_TYPE_INVALID);
 918
 919                 if (dbus_error_is_set(&err)) {
 920                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 921                         dbus_error_free(&err);
 922                         result = VC_ERROR_OPERATION_FAILED;
 923                 }
 924                 dbus_message_unref(result_msg);
 925
 926                 if (0 == result) {
 927                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget start : result = %d", result);
 928                 } else {
 929                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget start : result = %d", result);
 930                 }
 931         } else {
 932                 SLOG(LOG_DEBUG, TAG_VCW, "@@ Result Message is NULL");
 933                 vc_widget_dbus_reconnect();
 934                 result = VC_ERROR_TIMED_OUT;
 935         }
 936
 937         return result;
 938 }
 939
 940 int vc_widget_dbus_request_stop(int pid)
 941 {
 942         if (0 != __dbus_check()) {
 943                 return VC_ERROR_OPERATION_FAILED;
 944         }
 945
 946         DBusMessage* msg;
 947
 948         /* create a signal & check for errors */
 949         msg = dbus_message_new_method_call(
 950                           VC_SERVER_SERVICE_NAME,
 951                           VC_SERVER_SERVICE_OBJECT_PATH,
 952                           VC_SERVER_SERVICE_INTERFACE,
 953                           VC_WIDGET_METHOD_STOP);
 954
 955         if (NULL == msg) {
 956                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget stop : Fail to make message ");
 957                 return VC_ERROR_OPERATION_FAILED;
 958         } else {
 959                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget stop : pid(%d)", pid);
 960         }
 961
 962         dbus_message_append_args(msg,
 963                                                          DBUS_TYPE_INT32, &pid,
 964                                                          DBUS_TYPE_INVALID);
 965
 966         DBusError err;
 967         dbus_error_init(&err);
 968
 969         DBusMessage* result_msg;
 970         int result = VC_ERROR_OPERATION_FAILED;
 971
 972         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 973         dbus_message_unref(msg);
 974
 975         if (dbus_error_is_set(&err)) {
 976                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 977                 dbus_error_free(&err);
 978         }
 979
 980         if (NULL != result_msg) {
 981                 dbus_message_get_args(result_msg, &err,
 982                                                           DBUS_TYPE_INT32, &result,
 983                                                           DBUS_TYPE_INVALID);
 984
 985                 if (dbus_error_is_set(&err)) {
 986                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
 987                         dbus_error_free(&err);
 988                         result = VC_ERROR_OPERATION_FAILED;
 989                 }
 990                 dbus_message_unref(result_msg);
 991
 992                 if (0 == result) {
 993                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget stop : result = %d", result);
 994                 } else {
 995                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget stop : result = %d", result);
 996                 }
 997         } else {
 998                 SLOG(LOG_DEBUG, TAG_VCW, "@@ Result Message is NULL");
 999                 vc_widget_dbus_reconnect();
1000                 result = VC_ERROR_TIMED_OUT;
1001         }
1002
1003         return result;
1004 }
1005
1006 int vc_widget_dbus_request_cancel(int pid)
1007 {
1008         if (0 != __dbus_check()) {
1009                 return VC_ERROR_OPERATION_FAILED;
1010         }
1011
1012         DBusMessage* msg;
1013
1014         /* create a signal & check for errors */
1015         msg = dbus_message_new_method_call(
1016                           VC_SERVER_SERVICE_NAME,
1017                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1018                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1019                           VC_WIDGET_METHOD_CANCEL);     /* name of the signal */
1020
1021         if (NULL == msg) {
1022                 SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget cancel : Fail to make message ");
1023                 return VC_ERROR_OPERATION_FAILED;
1024         } else {
1025                 SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget cancel : pid(%d)", pid);
1026         }
1027
1028         dbus_message_append_args(msg,
1029                                                          DBUS_TYPE_INT32, &pid,
1030                                                          DBUS_TYPE_INVALID);
1031
1032         DBusError err;
1033         dbus_error_init(&err);
1034
1035         DBusMessage* result_msg;
1036         int result = VC_ERROR_OPERATION_FAILED;
1037
1038         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
1039         dbus_message_unref(msg);
1040
1041         if (dbus_error_is_set(&err)) {
1042                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
1043                 dbus_error_free(&err);
1044         }
1045
1046         if (NULL != result_msg) {
1047                 dbus_message_get_args(result_msg, &err,
1048                                                           DBUS_TYPE_INT32, &result,
1049                                                           DBUS_TYPE_INVALID);
1050
1051                 if (dbus_error_is_set(&err)) {
1052                         SLOG(LOG_ERROR, TAG_VCW, "@@ Get arguments error (%s)", err.message);
1053                         dbus_error_free(&err);
1054                         result = VC_ERROR_OPERATION_FAILED;
1055                 }
1056                 dbus_message_unref(result_msg);
1057
1058                 if (0 == result) {
1059                         SLOG(LOG_DEBUG, TAG_VCW, "@@ vc widget cancel : result = %d", result);
1060                 } else {
1061                         SLOG(LOG_ERROR, TAG_VCW, "@@ vc widget cancel : result = %d", result);
1062                 }
1063         } else {
1064                 SLOG(LOG_DEBUG, TAG_VCW, "@@ Result Message is NULL");
1065                 vc_widget_dbus_reconnect();
1066                 result = VC_ERROR_TIMED_OUT;
1067         }
1068
1069         return result;
1070 }