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