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 pid, int reason);
  31
  32 extern void __vc_widget_cb_show_tooltip(int pid, bool show);
  33
  34 extern void __vc_widget_cb_result();
  35
  36
  37 static Eina_Bool widget_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  38 {
  39         if (NULL == g_w_conn_listener)  return ECORE_CALLBACK_RENEW;
  40
  41         dbus_connection_read_write_dispatch(g_w_conn_listener, 50);
  42
  43         DBusMessage* msg = NULL;
  44         msg = dbus_connection_pop_message(g_w_conn_listener);
  45
  46         /* loop again if we haven't read a message */
  47         if (NULL == msg) {
  48                 return ECORE_CALLBACK_RENEW;
  49         }
  50
  51         DBusError err;
  52         dbus_error_init(&err);
  53
  54         char if_name[64];
  55         snprintf(if_name, 64, "%s", VC_WIDGET_SERVICE_INTERFACE);
  56
  57         if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_HELLO)) {
  58                 SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget hello");
  59                 int pid = 0;
  60                 int response = -1;
  61
  62                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  63
  64                 if (dbus_error_is_set(&err)) {
  65                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
  66                         dbus_error_free(&err);
  67                 }
  68
  69                 if (pid > 0) {
  70                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget get hello : pid(%d) ", pid);
  71                         response = 1;
  72                 } else {
  73                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get hello : invalid pid ");
  74                 }
  75
  76                 DBusMessage* reply = NULL;
  77                 reply = dbus_message_new_method_return(msg);
  78
  79                 if (NULL != reply) {
  80                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  81
  82                         if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
  83                                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get hello : fail to send reply");
  84                         else
  85                                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget get hello : result(%d)", response);
  86
  87                         dbus_connection_flush(g_w_conn_listener);
  88                         dbus_message_unref(reply);
  89                 } else {
  90                         SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get hello : fail to create reply message");
  91                 }
  92
  93                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
  94                 SLOG(LOG_DEBUG, TAG_VCW, " ");
  95         } /* VCD_WIDGET_METHOD_HELLO */
  96
  97         else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_SHOW_TOOLTIP)) {
  98                 SLOG(LOG_DEBUG, TAG_VCW, "===== Show / Hide tooltip");
  99                 int pid = 0;
 100                 int show = 0;
 101
 102                 dbus_message_get_args(msg, &err,
 103                         DBUS_TYPE_INT32, &pid,
 104                         DBUS_TYPE_INT32, &show,
 105                         DBUS_TYPE_INVALID);
 106
 107                 if (dbus_error_is_set(&err)) {
 108                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 109                         dbus_error_free(&err);
 110                 }
 111
 112                 if (pid > 0) {
 113                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget show tooltip : pid(%d), show(%d)", pid, show);
 114
 115                         __vc_widget_cb_show_tooltip(pid, (bool)show);
 116                 } else {
 117                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget show tooltip : invalid pid");
 118                 }
 119
 120                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 121                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 122         } /* VCD_WIDGET_METHOD_SHOW_TOOLTIP */
 123
 124         else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
 125                 SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget result");
 126
 127                 __vc_widget_cb_result();
 128
 129                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 130                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 131
 132         } /* VCD_WIDGET_METHOD_RESULT */
 133
 134         else if (dbus_message_is_method_call(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
 135                 SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget error");
 136                 int pid;
 137                 int reason;
 138                 char* err_msg;
 139
 140                 dbus_message_get_args(msg, &err,
 141                         DBUS_TYPE_INT32, &pid,
 142                         DBUS_TYPE_INT32, &reason,
 143                         DBUS_TYPE_STRING, &err_msg,
 144                         DBUS_TYPE_INVALID);
 145
 146                 if (dbus_error_is_set(&err)) {
 147                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get error message : Get arguments error (%s)", err.message);
 148                         dbus_error_free(&err);
 149                 } else {
 150                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget get error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
 151                         __vc_widget_cb_error(pid, reason);
 152                 }
 153
 154                 SLOG(LOG_DEBUG, TAG_VCW, "=====");
 155                 SLOG(LOG_DEBUG, TAG_VCW, " ");
 156         } /* VCD_WIDGET_METHOD_ERROR */
 157
 158         /* free the message */
 159         dbus_message_unref(msg);
 160
 161         return ECORE_CALLBACK_PASS_ON;
 162 }
 163
 164 int vc_widget_dbus_open_connection()
 165 {
 166         if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
 167                 SLOG(LOG_WARN, TAG_VCW, "Already existed connection ");
 168                 return 0;
 169         }
 170
 171         DBusError err;
 172         int ret;
 173
 174         /* initialise the error value */
 175         dbus_error_init(&err);
 176
 177         /* connect to the DBUS system bus, and check for errors */
 178         g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 179
 180         if (dbus_error_is_set(&err)) {
 181                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 182                 dbus_error_free(&err);
 183         }
 184
 185         if (NULL == g_w_conn_sender) {
 186                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 187                 return VC_ERROR_OPERATION_FAILED;
 188         }
 189
 190         g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 191
 192         if (dbus_error_is_set(&err)) {
 193                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 194                 dbus_error_free(&err);
 195         }
 196
 197         if (NULL == g_w_conn_listener) {
 198                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 199                 return VC_ERROR_OPERATION_FAILED;
 200         }
 201
 202         int pid = getpid();
 203
 204         char service_name[64];
 205         memset(service_name, '\0', 64);
 206         snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
 207
 208         SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
 209
 210         /* register our name on the bus, and check for errors */
 211         ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 212
 213         if (dbus_error_is_set(&err)) {
 214                 SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
 215                 dbus_error_free(&err);
 216         }
 217
 218         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 219                 SLOG(LOG_ERROR, TAG_VCW, "fail dbus_bus_request_name()");
 220                 return -2;
 221         }
 222
 223         if( NULL != g_w_fd_handler ) {
 224                 SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
 225                 return 0;
 226         }
 227
 228         char rule[128];
 229         snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
 230
 231         /* add a rule for which messages we want to see */
 232         dbus_bus_add_match(g_w_conn_listener, rule, &err);
 233         dbus_connection_flush(g_w_conn_listener);
 234
 235         if (dbus_error_is_set(&err))
 236         {
 237                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 238                 dbus_error_free(&err);
 239                 return VC_ERROR_OPERATION_FAILED;
 240         }
 241
 242         int fd = 0;
 243         if (1 != dbus_connection_get_unix_fd(g_w_conn_listener, &fd)) {
 244                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd from dbus ");
 245                 return VC_ERROR_OPERATION_FAILED;
 246         } else {
 247                 SLOG(LOG_DEBUG, TAG_VCW, "Get fd from dbus : %d", fd);
 248         }
 249
 250         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);
 251
 252         if (NULL == g_w_fd_handler) {
 253                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd handler from ecore ");
 254                 return VC_ERROR_OPERATION_FAILED;
 255         }
 256
 257         return 0;
 258 }
 259
 260 int vc_widget_dbus_close_connection()
 261 {
 262         DBusError err;
 263         dbus_error_init(&err);
 264
 265         if (NULL != g_w_fd_handler) {
 266                 ecore_main_fd_handler_del(g_w_fd_handler);
 267                 g_w_fd_handler = NULL;
 268         }
 269
 270         int pid = getpid();
 271
 272         char service_name[64];
 273         memset(service_name, '\0', 64);
 274         snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
 275
 276         dbus_bus_release_name(g_w_conn_listener, service_name, &err);
 277
 278         if (dbus_error_is_set(&err)) {
 279                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 280                 dbus_error_free(&err);
 281         }
 282
 283         g_w_conn_sender = NULL;
 284         g_w_conn_listener = NULL;
 285
 286         return 0;
 287 }
 288
 289 int vc_widget_dbus_reconnect()
 290 {
 291         bool sender_connected = dbus_connection_get_is_connected(g_w_conn_sender);
 292         bool listener_connected = dbus_connection_get_is_connected(g_w_conn_listener);
 293         SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Sender(%s) Listener(%s)",
 294                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 295
 296         if (false == sender_connected || false == listener_connected) {
 297                 vc_widget_dbus_close_connection();
 298
 299                 if (0 != vc_widget_dbus_open_connection()) {
 300                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to reconnect");
 301                         return -1;
 302                 }
 303
 304                 SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
 305         }
 306
 307         return 0;
 308 }
 309
 310 int vc_widget_dbus_request_hello()
 311 {
 312         DBusMessage* msg;
 313
 314         msg = dbus_message_new_method_call(
 315                 VC_SERVER_SERVICE_NAME,
 316                 VC_SERVER_SERVICE_OBJECT_PATH,
 317                 VC_SERVER_SERVICE_INTERFACE,
 318                 VC_METHOD_HELLO);
 319
 320         if (NULL == msg) {
 321                 SLOG(LOG_ERROR, TAG_VCW, ">>>> Request vc hello : Fail to make message");
 322                 return VC_ERROR_OPERATION_FAILED;
 323         }
 324
 325         DBusError err;
 326         dbus_error_init(&err);
 327
 328         DBusMessage* result_msg = NULL;
 329         int result = 0;
 330
 331         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, 500, &err);
 332
 333         if (dbus_error_is_set(&err)) {
 334                 dbus_error_free(&err);
 335         }
 336
 337         dbus_message_unref(msg);
 338
 339         if (NULL != result_msg) {
 340                 dbus_message_unref(result_msg);
 341                 result = 0;
 342         } else {
 343                 result = VC_ERROR_TIMED_OUT;
 344         }
 345
 346         return result;
 347 }
 348
 349
 350 int vc_widget_dbus_request_initialize(int pid)
 351 {
 352         DBusMessage* msg;
 353
 354         msg = dbus_message_new_method_call(
 355                 VC_SERVER_SERVICE_NAME,
 356                 VC_SERVER_SERVICE_OBJECT_PATH,
 357                 VC_SERVER_SERVICE_INTERFACE,
 358                 VC_WIDGET_METHOD_INITIALIZE);
 359
 360         if (NULL == msg) {
 361                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget initialize : Fail to make message ");
 362                 return VC_ERROR_OPERATION_FAILED;
 363         } else {
 364                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget initialize : pid(%d)", pid);
 365         }
 366
 367         dbus_message_append_args( msg,
 368                 DBUS_TYPE_INT32, &pid,
 369                 DBUS_TYPE_INVALID);
 370
 371         DBusError err;
 372         dbus_error_init(&err);
 373
 374         DBusMessage* result_msg;
 375         int result = VC_ERROR_OPERATION_FAILED;
 376
 377         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 378         dbus_message_unref(msg);
 379
 380         if (dbus_error_is_set(&err)) {
 381                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 382                 dbus_error_free(&err);
 383         }
 384
 385         if (NULL != result_msg) {
 386                 dbus_message_get_args(result_msg, &err,
 387                         DBUS_TYPE_INT32, &result,
 388                         DBUS_TYPE_INVALID);
 389
 390                 if (dbus_error_is_set(&err)) {
 391                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 392                         dbus_error_free(&err);
 393                         result = VC_ERROR_OPERATION_FAILED;
 394                 }
 395
 396                 dbus_message_unref(result_msg);
 397
 398                 if (0 == result) {
 399                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
 400                 } else {
 401                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
 402                 }
 403         } else {
 404                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 405                 vc_widget_dbus_reconnect();
 406                 result = VC_ERROR_TIMED_OUT;
 407         }
 408
 409         return result;
 410 }
 411
 412 int vc_widget_dbus_request_finalize(int pid)
 413 {
 414         DBusMessage* msg;
 415
 416         msg = dbus_message_new_method_call(
 417                 VC_SERVER_SERVICE_NAME,
 418                 VC_SERVER_SERVICE_OBJECT_PATH,
 419                 VC_SERVER_SERVICE_INTERFACE,
 420                 VC_WIDGET_METHOD_FINALIZE);
 421
 422         if (NULL == msg) {
 423                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget finalize : Fail to make message ");
 424                 return VC_ERROR_OPERATION_FAILED;
 425         } else {
 426                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget finalize : pid(%d)", pid);
 427         }
 428
 429         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 430
 431         DBusError err;
 432         dbus_error_init(&err);
 433
 434         DBusMessage* result_msg;
 435         int result = VC_ERROR_OPERATION_FAILED;
 436
 437         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 438         dbus_message_unref(msg);
 439
 440         if (dbus_error_is_set(&err)) {
 441                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 442                 dbus_error_free(&err);
 443         }
 444
 445         if (NULL != result_msg) {
 446                 dbus_message_get_args(result_msg, &err,
 447                                 DBUS_TYPE_INT32, &result,
 448                                 DBUS_TYPE_INVALID);
 449
 450                 if (dbus_error_is_set(&err)) {
 451                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 452                         dbus_error_free(&err);
 453                         result = VC_ERROR_OPERATION_FAILED;
 454                 }
 455
 456                 dbus_message_unref(result_msg);
 457
 458                 if (0 == result) {
 459                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 460                 } else {
 461                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 462                 }
 463         } else {
 464                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 465                 vc_widget_dbus_reconnect();
 466                 result = VC_ERROR_TIMED_OUT;
 467         }
 468
 469         return result;
 470 }
 471
 472 int vc_widget_dbus_request_start_recording(int pid, bool command)
 473 {
 474         DBusMessage* msg;
 475
 476         msg = dbus_message_new_method_call(
 477                 VC_SERVER_SERVICE_NAME,
 478                 VC_SERVER_SERVICE_OBJECT_PATH,
 479                 VC_SERVER_SERVICE_INTERFACE,
 480                 VC_WIDGET_METHOD_START_RECORDING);
 481
 482         if (NULL == msg) {
 483                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start recording : Fail to make message");
 484                 return VC_ERROR_OPERATION_FAILED;
 485         } else {
 486                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start recording : pid(%d)", pid);
 487         }
 488
 489         int temp = (int)command;
 490
 491         dbus_message_append_args(msg,
 492                 DBUS_TYPE_INT32, &pid,
 493                 DBUS_TYPE_INT32, &temp,
 494                 DBUS_TYPE_INVALID);
 495
 496         DBusError err;
 497         dbus_error_init(&err);
 498
 499         DBusMessage* result_msg;
 500         int result = VC_ERROR_OPERATION_FAILED;
 501
 502         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 503         dbus_message_unref(msg);
 504
 505         if (dbus_error_is_set(&err)) {
 506                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 507                 dbus_error_free(&err);
 508         }
 509
 510         if (NULL != result_msg) {
 511                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 512
 513                 if (dbus_error_is_set(&err)) {
 514                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 515                         dbus_error_free(&err);
 516                         result = VC_ERROR_OPERATION_FAILED;
 517                 }
 518                 dbus_message_unref(result_msg);
 519
 520                 if (0 == result) {
 521                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 522                 } else {
 523                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 524                 }
 525         } else {
 526                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL");
 527                 vc_widget_dbus_reconnect();
 528                 result = VC_ERROR_TIMED_OUT;
 529         }
 530
 531         return result;
 532 }
 533
 534 int vc_widget_dbus_request_start(int pid, int silence)
 535 {
 536         DBusMessage* msg;
 537
 538         /* create a signal & check for errors */
 539         msg = dbus_message_new_method_call(
 540                 VC_SERVER_SERVICE_NAME,
 541                 VC_SERVER_SERVICE_OBJECT_PATH,
 542                 VC_SERVER_SERVICE_INTERFACE,
 543                 VC_WIDGET_METHOD_START);
 544
 545         if (NULL == msg) {
 546                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start : Fail to make message ");
 547                 return VC_ERROR_OPERATION_FAILED;
 548         } else {
 549                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start : pid(%d), silence(%d)", pid, silence);
 550         }
 551
 552         DBusMessageIter args;
 553         dbus_message_iter_init_append(msg, &args);
 554
 555         /* Append result*/
 556         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 557         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 558
 559         DBusError err;
 560         dbus_error_init(&err);
 561
 562         DBusMessage* result_msg;
 563         int result = VC_ERROR_OPERATION_FAILED;
 564
 565         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 566         dbus_message_unref(msg);
 567
 568         if (dbus_error_is_set(&err)) {
 569                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 570                 dbus_error_free(&err);
 571         }
 572
 573         if (NULL != result_msg) {
 574                 dbus_message_get_args(result_msg, &err,
 575                         DBUS_TYPE_INT32, &result,
 576                         DBUS_TYPE_INVALID);
 577
 578                 if (dbus_error_is_set(&err)) {
 579                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 580                         dbus_error_free(&err);
 581                         result = VC_ERROR_OPERATION_FAILED;
 582                 }
 583                 dbus_message_unref(result_msg);
 584
 585                 if (0 == result) {
 586                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start : result = %d", result);
 587                 } else {
 588                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start : result = %d", result);
 589                 }
 590         } else {
 591                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 592                 vc_widget_dbus_reconnect();
 593                 result = VC_ERROR_TIMED_OUT;
 594         }
 595
 596         return result;
 597 }
 598
 599 int vc_widget_dbus_request_stop(int pid)
 600 {
 601         DBusMessage* msg;
 602
 603         /* create a signal & check for errors */
 604         msg = dbus_message_new_method_call(
 605                 VC_SERVER_SERVICE_NAME,
 606                 VC_SERVER_SERVICE_OBJECT_PATH,
 607                 VC_SERVER_SERVICE_INTERFACE,
 608                 VC_WIDGET_METHOD_STOP);
 609
 610         if (NULL == msg) {
 611                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget stop : Fail to make message ");
 612                 return VC_ERROR_OPERATION_FAILED;
 613         } else {
 614                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget stop : pid(%d)", pid);
 615         }
 616
 617         dbus_message_append_args(msg,
 618                 DBUS_TYPE_INT32, &pid,
 619                 DBUS_TYPE_INVALID);
 620
 621         DBusError err;
 622         dbus_error_init(&err);
 623
 624         DBusMessage* result_msg;
 625         int result = VC_ERROR_OPERATION_FAILED;
 626
 627         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 628         dbus_message_unref(msg);
 629
 630         if (dbus_error_is_set(&err)) {
 631                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 632                 dbus_error_free(&err);
 633         }
 634
 635         if (NULL != result_msg) {
 636                 dbus_message_get_args(result_msg, &err,
 637                         DBUS_TYPE_INT32, &result,
 638                         DBUS_TYPE_INVALID);
 639
 640                 if (dbus_error_is_set(&err)) {
 641                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 642                         dbus_error_free(&err);
 643                         result = VC_ERROR_OPERATION_FAILED;
 644                 }
 645                 dbus_message_unref(result_msg);
 646
 647                 if (0 == result) {
 648                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 649                 } else {
 650                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 651                 }
 652         } else {
 653                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 654                 vc_widget_dbus_reconnect();
 655                 result = VC_ERROR_TIMED_OUT;
 656         }
 657
 658         return result;
 659 }
 660
 661 int vc_widget_dbus_request_cancel(int pid)
 662 {
 663         DBusMessage* msg;
 664
 665         /* create a signal & check for errors */
 666         msg = dbus_message_new_method_call(
 667                 VC_SERVER_SERVICE_NAME,
 668                 VC_SERVER_SERVICE_OBJECT_PATH,  /* object name of the signal */
 669                 VC_SERVER_SERVICE_INTERFACE,    /* interface name of the signal */
 670                 VC_WIDGET_METHOD_CANCEL);       /* name of the signal */
 671
 672         if (NULL == msg) {
 673                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget cancel : Fail to make message ");
 674                 return VC_ERROR_OPERATION_FAILED;
 675         } else {
 676                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget cancel : pid(%d)", pid);
 677         }
 678
 679         dbus_message_append_args(msg,
 680                 DBUS_TYPE_INT32, &pid,
 681                 DBUS_TYPE_INVALID);
 682
 683         DBusError err;
 684         dbus_error_init(&err);
 685
 686         DBusMessage* result_msg;
 687         int result = VC_ERROR_OPERATION_FAILED;
 688
 689         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 690         dbus_message_unref(msg);
 691
 692         if (dbus_error_is_set(&err)) {
 693                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 694                 dbus_error_free(&err);
 695         }
 696
 697         if (NULL != result_msg) {
 698                 dbus_message_get_args(result_msg, &err,
 699                         DBUS_TYPE_INT32, &result,
 700                         DBUS_TYPE_INVALID);
 701
 702                 if (dbus_error_is_set(&err)) {
 703                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 704                         dbus_error_free(&err);
 705                         result = VC_ERROR_OPERATION_FAILED;
 706                 }
 707                 dbus_message_unref(result_msg);
 708
 709                 if (0 == result) {
 710                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
 711                 } else {
 712                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
 713                 }
 714         } else {
 715                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 716                 vc_widget_dbus_reconnect();
 717                 result = VC_ERROR_TIMED_OUT;
 718         }
 719
 720         return result;
 721 }