client/vc_widget_dbus.c

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