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