client/vc_widget_dbus.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 #include "vc_main.h"
  19 #include "vc_widget_client.h"
  20 #include "vc_widget_dbus.h"
  21
  22
  23 static int g_w_waiting_time = 3000;
  24
  25 static Ecore_Fd_Handler* g_w_fd_handler = NULL;
  26
  27 static DBusConnection* g_w_conn_sender = NULL;
  28 static DBusConnection* g_w_conn_listener = NULL;
  29
  30 extern int __vc_widget_cb_error(int reason, int daemon_pid, char* msg);
  31
  32 extern void __vc_widget_cb_show_tooltip(int pid, bool show);
  33
  34 extern void __vc_widget_cb_result();
  35
  36 extern 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                                 __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_method_call(msg, if_name, VCD_WIDGET_METHOD_RESULT)) {
 144                         SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget result");
 145
 146                         __vc_widget_cb_result();
 147
 148                         /*
 149                         reply = dbus_message_new_method_return(msg);
 150
 151                         if (NULL != reply) {
 152                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
 153                                         SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get result : fail to send reply");
 154                                 else
 155                                         SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget get result");
 156
 157                                 dbus_connection_flush(g_w_conn_listener);
 158                                 dbus_message_unref(reply);
 159                         } else {
 160                                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget get result : fail to create reply message");
 161
 162                         */
 163
 164                         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 165                         SLOG(LOG_DEBUG, TAG_VCW, " ");
 166
 167                 } /* VCD_WIDGET_METHOD_RESULT */
 168
 169                 else if (dbus_message_is_signal(msg, if_name, VCD_WIDGET_METHOD_ERROR)) {
 170                         SLOG(LOG_DEBUG, TAG_VCW, "===== Get widget error");
 171                         int reason;
 172                         int daemon_pid;
 173                         char* err_msg;
 174
 175                         dbus_message_get_args(msg, &err,
 176                                 DBUS_TYPE_INT32, &reason,
 177                                 DBUS_TYPE_INT32, &daemon_pid,
 178                                 DBUS_TYPE_STRING, &err_msg,
 179                                 DBUS_TYPE_INVALID);
 180
 181                         if (dbus_error_is_set(&err)) {
 182                                 SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget get error message : Get arguments error (%s)", err.message);
 183                                 dbus_error_free(&err);
 184                         } else {
 185                                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget get error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
 186                                 __vc_widget_cb_error(reason, daemon_pid, err_msg);
 187                         }
 188
 189                         /*
 190                         reply = dbus_message_new_method_return(msg);
 191
 192                         if (NULL != reply) {
 193                                 if (!dbus_connection_send(g_w_conn_listener, reply, NULL))
 194                                         SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget error message : fail to send reply");
 195                                 else
 196                                         SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget error message");
 197
 198                                 dbus_connection_flush(g_w_conn_listener);
 199                                 dbus_message_unref(reply);
 200                         } else {
 201                                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget error message : fail to create reply message");
 202                         }
 203                         */
 204
 205                         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 206                         SLOG(LOG_DEBUG, TAG_VCW, " ");
 207                 } /* VCD_WIDGET_METHOD_ERROR */
 208
 209                 else {
 210                         SLOG(LOG_ERROR, TAG_VCW, "Message is NOT valid");
 211                         dbus_message_unref(msg);
 212                         break;
 213                 }
 214
 215                 /* free the message */
 216                 dbus_message_unref(msg);
 217         } /* while(1) */
 218
 219         return ECORE_CALLBACK_PASS_ON;
 220 }
 221
 222 int vc_widget_dbus_open_connection()
 223 {
 224         if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
 225                 SLOG(LOG_WARN, TAG_VCW, "Already existed connection ");
 226                 return 0;
 227         }
 228
 229         DBusError err;
 230         int ret;
 231
 232         /* initialise the error value */
 233         dbus_error_init(&err);
 234
 235         /* connect to the DBUS system bus, and check for errors */
 236         g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 237
 238         if (dbus_error_is_set(&err)) {
 239                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 240                 dbus_error_free(&err);
 241         }
 242
 243         if (NULL == g_w_conn_sender) {
 244                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 245                 return VC_ERROR_OPERATION_FAILED;
 246         }
 247
 248         g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 249
 250         if (dbus_error_is_set(&err)) {
 251                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 252                 dbus_error_free(&err);
 253         }
 254
 255         if (NULL == g_w_conn_listener) {
 256                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 257                 return VC_ERROR_OPERATION_FAILED;
 258         }
 259
 260         int pid = getpid();
 261
 262         char service_name[64];
 263         memset(service_name, '\0', 64);
 264         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 265
 266         SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
 267
 268         /* register our name on the bus, and check for errors */
 269         ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 270
 271         if (dbus_error_is_set(&err)) {
 272                 SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
 273                 dbus_error_free(&err);
 274         }
 275
 276         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 277                 SLOG(LOG_ERROR, TAG_VCW, "fail dbus_bus_request_name()");
 278                 return -2;
 279         }
 280
 281         if (NULL != g_w_fd_handler) {
 282                 SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
 283                 return 0;
 284         }
 285
 286         char rule[128] = {0, };
 287         snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
 288
 289         /* add a rule for which messages we want to see */
 290         dbus_bus_add_match(g_w_conn_listener, rule, &err);
 291         dbus_connection_flush(g_w_conn_listener);
 292
 293         if (dbus_error_is_set(&err)) {
 294                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 295                 dbus_error_free(&err);
 296                 return VC_ERROR_OPERATION_FAILED;
 297         }
 298
 299         int fd = 0;
 300         if (1 != dbus_connection_get_unix_fd(g_w_conn_listener, &fd)) {
 301                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd from dbus ");
 302                 return VC_ERROR_OPERATION_FAILED;
 303         } else {
 304                 SLOG(LOG_DEBUG, TAG_VCW, "Get fd from dbus : %d", fd);
 305         }
 306
 307         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);
 308
 309         if (NULL == g_w_fd_handler) {
 310                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd handler from ecore ");
 311                 return VC_ERROR_OPERATION_FAILED;
 312         }
 313
 314         return 0;
 315 }
 316
 317 int vc_widget_dbus_close_connection()
 318 {
 319         DBusError err;
 320         dbus_error_init(&err);
 321
 322         if (NULL != g_w_fd_handler) {
 323                 ecore_main_fd_handler_del(g_w_fd_handler);
 324                 g_w_fd_handler = NULL;
 325         }
 326
 327         int pid = getpid();
 328
 329         char service_name[64];
 330         memset(service_name, '\0', 64);
 331         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 332
 333         dbus_bus_release_name(g_w_conn_listener, service_name, &err);
 334
 335         if (dbus_error_is_set(&err)) {
 336                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 337                 dbus_error_free(&err);
 338         }
 339
 340         dbus_connection_close(g_w_conn_sender);
 341         dbus_connection_close(g_w_conn_listener);
 342
 343         dbus_connection_unref(g_w_conn_sender);
 344         dbus_connection_unref(g_w_conn_listener);
 345
 346         g_w_conn_sender = NULL;
 347         g_w_conn_listener = NULL;
 348
 349         return 0;
 350 }
 351
 352 int vc_widget_dbus_reconnect()
 353 {
 354         bool sender_connected = dbus_connection_get_is_connected(g_w_conn_sender);
 355         bool listener_connected = dbus_connection_get_is_connected(g_w_conn_listener);
 356         SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Sender(%s) Listener(%s)",
 357                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 358
 359         if (false == sender_connected || false == listener_connected) {
 360                 vc_widget_dbus_close_connection();
 361
 362                 if (0 != vc_widget_dbus_open_connection()) {
 363                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to reconnect");
 364                         return -1;
 365                 }
 366
 367                 SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
 368         }
 369
 370         return 0;
 371 }
 372
 373 int vc_widget_dbus_request_hello()
 374 {
 375         DBusMessage* msg;
 376
 377         msg = dbus_message_new_method_call(
 378                           VC_SERVER_SERVICE_NAME,
 379                           VC_SERVER_SERVICE_OBJECT_PATH,
 380                           VC_SERVER_SERVICE_INTERFACE,
 381                           VC_METHOD_HELLO);
 382
 383         if (NULL == msg) {
 384                 SLOG(LOG_ERROR, TAG_VCW, ">>>> Request vc hello : Fail to make message");
 385                 return VC_ERROR_OPERATION_FAILED;
 386         }
 387
 388         DBusError err;
 389         dbus_error_init(&err);
 390
 391         DBusMessage* result_msg = NULL;
 392         int result = 0;
 393
 394         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, 500, &err);
 395
 396         if (dbus_error_is_set(&err)) {
 397                 dbus_error_free(&err);
 398         }
 399
 400         dbus_message_unref(msg);
 401
 402         if (NULL != result_msg) {
 403                 dbus_message_unref(result_msg);
 404                 result = 0;
 405         } else {
 406                 result = VC_ERROR_TIMED_OUT;
 407         }
 408
 409         return result;
 410 }
 411
 412
 413 int vc_widget_dbus_request_initialize(int pid, int* service_state, int* daemon_pid)
 414 {
 415         DBusMessage* msg;
 416
 417         msg = dbus_message_new_method_call(
 418                           VC_SERVER_SERVICE_NAME,
 419                           VC_SERVER_SERVICE_OBJECT_PATH,
 420                           VC_SERVER_SERVICE_INTERFACE,
 421                           VC_WIDGET_METHOD_INITIALIZE);
 422
 423         if (NULL == msg) {
 424                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget initialize : Fail to make message ");
 425                 return VC_ERROR_OPERATION_FAILED;
 426         } else {
 427                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget initialize : pid(%d)", pid);
 428         }
 429
 430         dbus_message_append_args(msg,
 431                                                          DBUS_TYPE_INT32, &pid,
 432                                                          DBUS_TYPE_INVALID);
 433
 434         DBusError err;
 435         dbus_error_init(&err);
 436
 437         DBusMessage* result_msg;
 438         int result = VC_ERROR_OPERATION_FAILED;
 439
 440         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 441         dbus_message_unref(msg);
 442
 443         if (dbus_error_is_set(&err)) {
 444                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 445                 dbus_error_free(&err);
 446         }
 447
 448         if (NULL != result_msg) {
 449                 int tmp_service_state = 0;
 450                 int tmp_daemon_pid = 0;
 451                 dbus_message_get_args(result_msg, &err,
 452                         DBUS_TYPE_INT32, &result,
 453                         DBUS_TYPE_INT32, &tmp_service_state,
 454                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 455                         DBUS_TYPE_INVALID);
 456
 457                 if (dbus_error_is_set(&err)) {
 458                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 459                         dbus_error_free(&err);
 460                         result = VC_ERROR_OPERATION_FAILED;
 461                 }
 462
 463                 dbus_message_unref(result_msg);
 464
 465                 if (0 == result) {
 466                         *service_state = tmp_service_state;
 467                         *daemon_pid = tmp_daemon_pid;
 468                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget initialize : result = %d service = %d daemon_pid = %d", result, *service_state, *daemon_pid);
 469                 } else {
 470                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
 471                 }
 472         } else {
 473                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 474                 vc_widget_dbus_reconnect();
 475                 result = VC_ERROR_TIMED_OUT;
 476         }
 477
 478         return result;
 479 }
 480
 481 int vc_widget_dbus_request_finalize(int pid)
 482 {
 483         DBusMessage* msg;
 484
 485         msg = dbus_message_new_method_call(
 486                           VC_SERVER_SERVICE_NAME,
 487                           VC_SERVER_SERVICE_OBJECT_PATH,
 488                           VC_SERVER_SERVICE_INTERFACE,
 489                           VC_WIDGET_METHOD_FINALIZE);
 490
 491         if (NULL == msg) {
 492                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget finalize : Fail to make message ");
 493                 return VC_ERROR_OPERATION_FAILED;
 494         } else {
 495                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget finalize : pid(%d)", pid);
 496         }
 497
 498         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 499
 500         DBusError err;
 501         dbus_error_init(&err);
 502
 503         DBusMessage* result_msg;
 504         int result = VC_ERROR_OPERATION_FAILED;
 505
 506         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 507         dbus_message_unref(msg);
 508
 509         if (dbus_error_is_set(&err)) {
 510                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 511                 dbus_error_free(&err);
 512         }
 513
 514         if (NULL != result_msg) {
 515                 dbus_message_get_args(result_msg, &err,
 516                                                           DBUS_TYPE_INT32, &result,
 517                                                           DBUS_TYPE_INVALID);
 518
 519                 if (dbus_error_is_set(&err)) {
 520                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 521                         dbus_error_free(&err);
 522                         result = VC_ERROR_OPERATION_FAILED;
 523                 }
 524
 525                 dbus_message_unref(result_msg);
 526
 527                 if (0 == result) {
 528                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 529                 } else {
 530                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 531                 }
 532         } else {
 533                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 534                 vc_widget_dbus_reconnect();
 535                 result = VC_ERROR_TIMED_OUT;
 536         }
 537
 538         return result;
 539 }
 540
 541 int vc_widget_dbus_request_start_recording(int pid, bool command)
 542 {
 543         DBusMessage* msg;
 544
 545         msg = dbus_message_new_method_call(
 546                           VC_SERVER_SERVICE_NAME,
 547                           VC_SERVER_SERVICE_OBJECT_PATH,
 548                           VC_SERVER_SERVICE_INTERFACE,
 549                           VC_WIDGET_METHOD_START_RECORDING);
 550
 551         if (NULL == msg) {
 552                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start recording : Fail to make message");
 553                 return VC_ERROR_OPERATION_FAILED;
 554         } else {
 555                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start recording : pid(%d)", pid);
 556         }
 557
 558         int temp = (int)command;
 559
 560         dbus_message_append_args(msg,
 561                                                          DBUS_TYPE_INT32, &pid,
 562                                                          DBUS_TYPE_INT32, &temp,
 563                                                          DBUS_TYPE_INVALID);
 564
 565         DBusError err;
 566         dbus_error_init(&err);
 567
 568         DBusMessage* result_msg;
 569         int result = VC_ERROR_OPERATION_FAILED;
 570
 571         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 572         dbus_message_unref(msg);
 573
 574         if (dbus_error_is_set(&err)) {
 575                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 576                 dbus_error_free(&err);
 577         }
 578
 579         if (NULL != result_msg) {
 580                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 581
 582                 if (dbus_error_is_set(&err)) {
 583                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 584                         dbus_error_free(&err);
 585                         result = VC_ERROR_OPERATION_FAILED;
 586                 }
 587                 dbus_message_unref(result_msg);
 588
 589                 if (0 == result) {
 590                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 591                 } else {
 592                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 593                 }
 594         } else {
 595                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL");
 596                 vc_widget_dbus_reconnect();
 597                 result = VC_ERROR_TIMED_OUT;
 598         }
 599
 600         return result;
 601 }
 602
 603 int vc_widget_dbus_set_foreground(int pid, bool value)
 604 {
 605         DBusMessage* msg = NULL;
 606         int tmp_value = 0;
 607
 608         tmp_value = (int)value;
 609
 610         msg = dbus_message_new_signal(
 611                 VC_MANAGER_SERVICE_OBJECT_PATH,
 612                 VC_MANAGER_SERVICE_INTERFACE,
 613                 VCC_MANAGER_METHOD_SET_FOREGROUND);
 614
 615         if (NULL == msg) {
 616                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to manager : Fail to make message");
 617                 return VC_ERROR_OPERATION_FAILED;
 618         } else {
 619                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 620         }
 621
 622         dbus_message_append_args(msg,
 623                 DBUS_TYPE_INT32, &pid,
 624                 DBUS_TYPE_INT32, &tmp_value,
 625                 DBUS_TYPE_INVALID);
 626
 627         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 628                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 629                 return VC_ERROR_OPERATION_FAILED;
 630         }
 631
 632         dbus_message_unref(msg);
 633
 634         msg = NULL;
 635         msg = dbus_message_new_method_call(
 636                 VC_SERVER_SERVICE_NAME,
 637                 VC_SERVER_SERVICE_OBJECT_PATH,
 638                 VC_SERVER_SERVICE_INTERFACE,
 639                 VC_METHOD_SET_FOREGROUND);
 640
 641         if (NULL == msg) {
 642                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to daemon : Fail to make message");
 643                 return VC_ERROR_OPERATION_FAILED;
 644         } else {
 645                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 646         }
 647
 648         dbus_message_append_args(msg,
 649                 DBUS_TYPE_INT32, &pid,
 650                 DBUS_TYPE_INT32, &tmp_value,
 651                 DBUS_TYPE_INVALID);
 652
 653         dbus_message_set_no_reply(msg, TRUE);
 654
 655         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 656                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 657                 return VC_ERROR_OPERATION_FAILED;
 658         }
 659
 660         dbus_connection_flush(g_w_conn_sender);
 661
 662         dbus_message_unref(msg);
 663
 664         return 0;
 665 }
 666
 667
 668 int vc_widget_dbus_request_start(int pid, int silence)
 669 {
 670         DBusMessage* msg;
 671
 672         /* create a signal & check for errors */
 673         msg = dbus_message_new_method_call(
 674                           VC_SERVER_SERVICE_NAME,
 675                           VC_SERVER_SERVICE_OBJECT_PATH,
 676                           VC_SERVER_SERVICE_INTERFACE,
 677                           VC_WIDGET_METHOD_START);
 678
 679         if (NULL == msg) {
 680                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start : Fail to make message ");
 681                 return VC_ERROR_OPERATION_FAILED;
 682         } else {
 683                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start : pid(%d), silence(%d)", pid, silence);
 684         }
 685
 686         DBusMessageIter args;
 687         dbus_message_iter_init_append(msg, &args);
 688
 689         /* Append result*/
 690         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 691         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 692
 693         DBusError err;
 694         dbus_error_init(&err);
 695
 696         DBusMessage* result_msg;
 697         int result = VC_ERROR_OPERATION_FAILED;
 698
 699         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 700         dbus_message_unref(msg);
 701
 702         if (dbus_error_is_set(&err)) {
 703                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 704                 dbus_error_free(&err);
 705         }
 706
 707         if (NULL != result_msg) {
 708                 dbus_message_get_args(result_msg, &err,
 709                                                           DBUS_TYPE_INT32, &result,
 710                                                           DBUS_TYPE_INVALID);
 711
 712                 if (dbus_error_is_set(&err)) {
 713                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 714                         dbus_error_free(&err);
 715                         result = VC_ERROR_OPERATION_FAILED;
 716                 }
 717                 dbus_message_unref(result_msg);
 718
 719                 if (0 == result) {
 720                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start : result = %d", result);
 721                 } else {
 722                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start : result = %d", result);
 723                 }
 724         } else {
 725                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 726                 vc_widget_dbus_reconnect();
 727                 result = VC_ERROR_TIMED_OUT;
 728         }
 729
 730         return result;
 731 }
 732
 733 int vc_widget_dbus_request_stop(int pid)
 734 {
 735         DBusMessage* msg;
 736
 737         /* create a signal & check for errors */
 738         msg = dbus_message_new_method_call(
 739                           VC_SERVER_SERVICE_NAME,
 740                           VC_SERVER_SERVICE_OBJECT_PATH,
 741                           VC_SERVER_SERVICE_INTERFACE,
 742                           VC_WIDGET_METHOD_STOP);
 743
 744         if (NULL == msg) {
 745                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget stop : Fail to make message ");
 746                 return VC_ERROR_OPERATION_FAILED;
 747         } else {
 748                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget stop : pid(%d)", pid);
 749         }
 750
 751         dbus_message_append_args(msg,
 752                                                          DBUS_TYPE_INT32, &pid,
 753                                                          DBUS_TYPE_INVALID);
 754
 755         DBusError err;
 756         dbus_error_init(&err);
 757
 758         DBusMessage* result_msg;
 759         int result = VC_ERROR_OPERATION_FAILED;
 760
 761         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 762         dbus_message_unref(msg);
 763
 764         if (dbus_error_is_set(&err)) {
 765                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 766                 dbus_error_free(&err);
 767         }
 768
 769         if (NULL != result_msg) {
 770                 dbus_message_get_args(result_msg, &err,
 771                                                           DBUS_TYPE_INT32, &result,
 772                                                           DBUS_TYPE_INVALID);
 773
 774                 if (dbus_error_is_set(&err)) {
 775                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 776                         dbus_error_free(&err);
 777                         result = VC_ERROR_OPERATION_FAILED;
 778                 }
 779                 dbus_message_unref(result_msg);
 780
 781                 if (0 == result) {
 782                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 783                 } else {
 784                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 785                 }
 786         } else {
 787                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 788                 vc_widget_dbus_reconnect();
 789                 result = VC_ERROR_TIMED_OUT;
 790         }
 791
 792         return result;
 793 }
 794
 795 int vc_widget_dbus_request_cancel(int pid)
 796 {
 797         DBusMessage* msg;
 798
 799         /* create a signal & check for errors */
 800         msg = dbus_message_new_method_call(
 801                           VC_SERVER_SERVICE_NAME,
 802                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
 803                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
 804                           VC_WIDGET_METHOD_CANCEL);     /* name of the signal */
 805
 806         if (NULL == msg) {
 807                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget cancel : Fail to make message ");
 808                 return VC_ERROR_OPERATION_FAILED;
 809         } else {
 810                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget cancel : pid(%d)", pid);
 811         }
 812
 813         dbus_message_append_args(msg,
 814                                                          DBUS_TYPE_INT32, &pid,
 815                                                          DBUS_TYPE_INVALID);
 816
 817         DBusError err;
 818         dbus_error_init(&err);
 819
 820         DBusMessage* result_msg;
 821         int result = VC_ERROR_OPERATION_FAILED;
 822
 823         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 824         dbus_message_unref(msg);
 825
 826         if (dbus_error_is_set(&err)) {
 827                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 828                 dbus_error_free(&err);
 829         }
 830
 831         if (NULL != result_msg) {
 832                 dbus_message_get_args(result_msg, &err,
 833                                                           DBUS_TYPE_INT32, &result,
 834                                                           DBUS_TYPE_INVALID);
 835
 836                 if (dbus_error_is_set(&err)) {
 837                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 838                         dbus_error_free(&err);
 839                         result = VC_ERROR_OPERATION_FAILED;
 840                 }
 841                 dbus_message_unref(result_msg);
 842
 843                 if (0 == result) {
 844                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
 845                 } else {
 846                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
 847                 }
 848         } else {
 849                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 850                 vc_widget_dbus_reconnect();
 851                 result = VC_ERROR_TIMED_OUT;
 852         }
 853
 854         return result;
 855 }