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                         DBusError err;
 241                         dbus_error_init(&err);
 242
 243                         /* remove a rule for daemon error */
 244                         char rule_err[256] = {0, };
 245                         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);
 246                         dbus_bus_remove_match(g_w_conn_listener, rule_err, &err);
 247                         dbus_connection_flush(g_w_conn_listener);
 248
 249                         if (dbus_error_is_set(&err)) {
 250                                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 251                                 dbus_error_free(&err);
 252                         }
 253                         __vc_widget_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
 254                         SLOG(LOG_DEBUG, TAG_VCW, "=====");
 255                         SLOG(LOG_DEBUG, TAG_VCW, " ");
 256                 } /* NameOwnerChanged */
 257
 258                 else {
 259                         SLOG(LOG_ERROR, TAG_VCW, "Message is NOT valid");
 260                         dbus_message_unref(msg);
 261                         break;
 262                 }
 263
 264                 /* free the message */
 265                 dbus_message_unref(msg);
 266         } /* while(1) */
 267
 268         return ECORE_CALLBACK_PASS_ON;
 269 }
 270
 271 int vc_widget_dbus_open_connection()
 272 {
 273         if (NULL != g_w_conn_sender && NULL != g_w_conn_listener) {
 274                 SLOG(LOG_WARN, TAG_VCW, "Already existed connection ");
 275                 return 0;
 276         }
 277
 278         DBusError err;
 279         int ret;
 280
 281         /* initialise the error value */
 282         dbus_error_init(&err);
 283
 284         /* connect to the DBUS system bus, and check for errors */
 285         g_w_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 286
 287         if (dbus_error_is_set(&err)) {
 288                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 289                 dbus_error_free(&err);
 290         }
 291
 292         if (NULL == g_w_conn_sender) {
 293                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 294                 return VC_ERROR_OPERATION_FAILED;
 295         }
 296
 297         g_w_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 298
 299         if (dbus_error_is_set(&err)) {
 300                 SLOG(LOG_ERROR, TAG_VCW, "Dbus Connection Error (%s)", err.message);
 301                 dbus_error_free(&err);
 302         }
 303
 304         if (NULL == g_w_conn_listener) {
 305                 SLOG(LOG_ERROR, TAG_VCW, "Fail to get dbus connection ");
 306                 return VC_ERROR_OPERATION_FAILED;
 307         }
 308
 309         int pid = getpid();
 310
 311         char service_name[64];
 312         memset(service_name, '\0', 64);
 313         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 314
 315         SLOG(LOG_DEBUG, TAG_VCW, "service name is %s", service_name);
 316
 317         /* register our name on the bus, and check for errors */
 318         ret = dbus_bus_request_name(g_w_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 319
 320         if (dbus_error_is_set(&err)) {
 321                 SLOG(LOG_ERROR, TAG_VCW, "Name Error (%s)", err.message);
 322                 dbus_error_free(&err);
 323         }
 324
 325         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 326                 SLOG(LOG_ERROR, TAG_VCW, "fail dbus_bus_request_name()");
 327                 return -2;
 328         }
 329
 330         if (NULL != g_w_fd_handler) {
 331                 SLOG(LOG_WARN, TAG_VCW, "The handler already exists.");
 332                 return 0;
 333         }
 334
 335         char rule[128] = {0, };
 336         snprintf(rule, 128, "type='signal',interface='%s'", VC_WIDGET_SERVICE_INTERFACE);
 337
 338         /* add a rule for which messages we want to see */
 339         dbus_bus_add_match(g_w_conn_listener, rule, &err);
 340         dbus_connection_flush(g_w_conn_listener);
 341
 342         if (dbus_error_is_set(&err)) {
 343                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 344                 dbus_error_free(&err);
 345                 return VC_ERROR_OPERATION_FAILED;
 346         }
 347
 348         int fd = 0;
 349         if (1 != dbus_connection_get_unix_fd(g_w_conn_listener, &fd)) {
 350                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd from dbus ");
 351                 return VC_ERROR_OPERATION_FAILED;
 352         } else {
 353                 SLOG(LOG_DEBUG, TAG_VCW, "Get fd from dbus : %d", fd);
 354         }
 355
 356         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);
 357
 358         if (NULL == g_w_fd_handler) {
 359                 SLOG(LOG_ERROR, TAG_VCW, "fail to get fd handler from ecore ");
 360                 return VC_ERROR_OPERATION_FAILED;
 361         }
 362
 363         return 0;
 364 }
 365
 366 int vc_widget_dbus_close_connection()
 367 {
 368         DBusError err;
 369         dbus_error_init(&err);
 370
 371         if (NULL != g_w_fd_handler) {
 372                 ecore_main_fd_handler_del(g_w_fd_handler);
 373                 g_w_fd_handler = NULL;
 374         }
 375
 376         int pid = getpid();
 377
 378         char service_name[64];
 379         memset(service_name, '\0', 64);
 380         snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
 381
 382         dbus_bus_release_name(g_w_conn_listener, service_name, &err);
 383
 384         if (dbus_error_is_set(&err)) {
 385                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 386                 dbus_error_free(&err);
 387         }
 388
 389         dbus_connection_close(g_w_conn_sender);
 390         dbus_connection_close(g_w_conn_listener);
 391
 392         dbus_connection_unref(g_w_conn_sender);
 393         dbus_connection_unref(g_w_conn_listener);
 394
 395         g_w_conn_sender = NULL;
 396         g_w_conn_listener = NULL;
 397
 398         return 0;
 399 }
 400
 401 int vc_widget_dbus_reconnect()
 402 {
 403         bool sender_connected = dbus_connection_get_is_connected(g_w_conn_sender);
 404         bool listener_connected = dbus_connection_get_is_connected(g_w_conn_listener);
 405         SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Sender(%s) Listener(%s)",
 406                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 407
 408         if (false == sender_connected || false == listener_connected) {
 409                 vc_widget_dbus_close_connection();
 410
 411                 if (0 != vc_widget_dbus_open_connection()) {
 412                         SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Fail to reconnect");
 413                         return -1;
 414                 }
 415
 416                 SLOG(LOG_DEBUG, TAG_VCW, "[DBUS] Reconnect");
 417         }
 418
 419         return 0;
 420 }
 421
 422 static int __dbus_check()
 423 {
 424         if (NULL == g_w_conn_sender) {
 425                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] NULL connection");
 426                 return vc_widget_dbus_reconnect();
 427         }
 428         return 0;
 429 }
 430
 431 int vc_widget_dbus_request_hello()
 432 {
 433         if (0 != __dbus_check()) {
 434                 return VC_ERROR_OPERATION_FAILED;
 435         }
 436
 437         DBusMessage* msg;
 438
 439         msg = dbus_message_new_method_call(
 440                           VC_SERVER_SERVICE_NAME,
 441                           VC_SERVER_SERVICE_OBJECT_PATH,
 442                           VC_SERVER_SERVICE_INTERFACE,
 443                           VC_METHOD_HELLO);
 444
 445         if (NULL == msg) {
 446                 SLOG(LOG_ERROR, TAG_VCW, ">>>> Request vc hello : Fail to make message");
 447                 return VC_ERROR_OPERATION_FAILED;
 448         }
 449
 450         DBusError err;
 451         dbus_error_init(&err);
 452
 453         DBusMessage* result_msg = NULL;
 454         int result = 0;
 455
 456         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, 500, &err);
 457
 458         if (dbus_error_is_set(&err)) {
 459                 dbus_error_free(&err);
 460         }
 461
 462         dbus_message_unref(msg);
 463
 464         if (NULL != result_msg) {
 465                 dbus_message_unref(result_msg);
 466                 result = 0;
 467         } else {
 468                 result = VC_ERROR_TIMED_OUT;
 469         }
 470
 471         return result;
 472 }
 473
 474
 475 int vc_widget_dbus_request_initialize(int pid, int* service_state, int* daemon_pid)
 476 {
 477         if (0 != __dbus_check()) {
 478                 return VC_ERROR_OPERATION_FAILED;
 479         }
 480
 481         DBusMessage* msg;
 482
 483         msg = dbus_message_new_method_call(
 484                           VC_SERVER_SERVICE_NAME,
 485                           VC_SERVER_SERVICE_OBJECT_PATH,
 486                           VC_SERVER_SERVICE_INTERFACE,
 487                           VC_WIDGET_METHOD_INITIALIZE);
 488
 489         if (NULL == msg) {
 490                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget initialize : Fail to make message ");
 491                 return VC_ERROR_OPERATION_FAILED;
 492         } else {
 493                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget initialize : pid(%d)", pid);
 494         }
 495
 496         dbus_message_append_args(msg,
 497                                                          DBUS_TYPE_INT32, &pid,
 498                                                          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                 int tmp_service_state = 0;
 516                 int tmp_daemon_pid = 0;
 517                 dbus_message_get_args(result_msg, &err,
 518                         DBUS_TYPE_INT32, &result,
 519                         DBUS_TYPE_INT32, &tmp_service_state,
 520                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 521                         DBUS_TYPE_INVALID);
 522
 523                 if (dbus_error_is_set(&err)) {
 524                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 525                         dbus_error_free(&err);
 526                         result = VC_ERROR_OPERATION_FAILED;
 527                 }
 528
 529                 dbus_message_unref(result_msg);
 530
 531                 if (0 == result) {
 532                         *service_state = tmp_service_state;
 533                         *daemon_pid = tmp_daemon_pid;
 534
 535                         /* add 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_add_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                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget initialize : result = %d service = %d daemon_pid = %d", result, *service_state, *daemon_pid);
 548                 } else {
 549                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget initialize : result = %d", result);
 550                 }
 551         } else {
 552                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 553                 vc_widget_dbus_reconnect();
 554                 result = VC_ERROR_TIMED_OUT;
 555         }
 556
 557         return result;
 558 }
 559
 560 int vc_widget_dbus_request_finalize(int pid)
 561 {
 562         if (0 != __dbus_check()) {
 563                 return VC_ERROR_OPERATION_FAILED;
 564         }
 565
 566         DBusError err;
 567         dbus_error_init(&err);
 568
 569         /* remove a rule for daemon error */
 570         char rule_err[256] = {0, };
 571         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);
 572         dbus_bus_remove_match(g_w_conn_listener, rule_err, &err);
 573         dbus_connection_flush(g_w_conn_listener);
 574
 575         if (dbus_error_is_set(&err)) {
 576                 SLOG(LOG_ERROR, TAG_VCW, "Match Error (%s)", err.message);
 577                 dbus_error_free(&err);
 578                 return VC_ERROR_OPERATION_FAILED;
 579         }
 580
 581         DBusMessage* msg;
 582
 583         msg = dbus_message_new_method_call(
 584                           VC_SERVER_SERVICE_NAME,
 585                           VC_SERVER_SERVICE_OBJECT_PATH,
 586                           VC_SERVER_SERVICE_INTERFACE,
 587                           VC_WIDGET_METHOD_FINALIZE);
 588
 589         if (NULL == msg) {
 590                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget finalize : Fail to make message ");
 591                 return VC_ERROR_OPERATION_FAILED;
 592         } else {
 593                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget finalize : pid(%d)", pid);
 594         }
 595
 596         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 597
 598         DBusMessage* result_msg;
 599         int result = VC_ERROR_OPERATION_FAILED;
 600
 601         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 602         dbus_message_unref(msg);
 603
 604         if (dbus_error_is_set(&err)) {
 605                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 606                 dbus_error_free(&err);
 607         }
 608
 609         if (NULL != result_msg) {
 610                 dbus_message_get_args(result_msg, &err,
 611                                                           DBUS_TYPE_INT32, &result,
 612                                                           DBUS_TYPE_INVALID);
 613
 614                 if (dbus_error_is_set(&err)) {
 615                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 616                         dbus_error_free(&err);
 617                         result = VC_ERROR_OPERATION_FAILED;
 618                 }
 619
 620                 dbus_message_unref(result_msg);
 621
 622                 if (0 == result) {
 623                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 624                 } else {
 625                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget finalize : result = %d", result);
 626                 }
 627         } else {
 628                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL ");
 629                 vc_widget_dbus_reconnect();
 630                 result = VC_ERROR_TIMED_OUT;
 631         }
 632
 633         return result;
 634 }
 635
 636 int vc_widget_dbus_request_start_recording(int pid, bool command)
 637 {
 638         if (0 != __dbus_check()) {
 639                 return VC_ERROR_OPERATION_FAILED;
 640         }
 641
 642         DBusMessage* msg;
 643
 644         msg = dbus_message_new_method_call(
 645                           VC_SERVER_SERVICE_NAME,
 646                           VC_SERVER_SERVICE_OBJECT_PATH,
 647                           VC_SERVER_SERVICE_INTERFACE,
 648                           VC_WIDGET_METHOD_START_RECORDING);
 649
 650         if (NULL == msg) {
 651                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start recording : Fail to make message");
 652                 return VC_ERROR_OPERATION_FAILED;
 653         } else {
 654                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start recording : pid(%d)", pid);
 655         }
 656
 657         int temp = (int)command;
 658
 659         dbus_message_append_args(msg,
 660                                                          DBUS_TYPE_INT32, &pid,
 661                                                          DBUS_TYPE_INT32, &temp,
 662                                                          DBUS_TYPE_INVALID);
 663
 664         DBusError err;
 665         dbus_error_init(&err);
 666
 667         DBusMessage* result_msg;
 668         int result = VC_ERROR_OPERATION_FAILED;
 669
 670         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 671         dbus_message_unref(msg);
 672
 673         if (dbus_error_is_set(&err)) {
 674                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 675                 dbus_error_free(&err);
 676         }
 677
 678         if (NULL != result_msg) {
 679                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 680
 681                 if (dbus_error_is_set(&err)) {
 682                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 683                         dbus_error_free(&err);
 684                         result = VC_ERROR_OPERATION_FAILED;
 685                 }
 686                 dbus_message_unref(result_msg);
 687
 688                 if (0 == result) {
 689                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 690                 } else {
 691                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start recording : result = %d", result);
 692                 }
 693         } else {
 694                 SLOG(LOG_ERROR, TAG_VCW, "<<<< Result message is NULL");
 695                 vc_widget_dbus_reconnect();
 696                 result = VC_ERROR_TIMED_OUT;
 697         }
 698
 699         return result;
 700 }
 701
 702 int vc_widget_dbus_set_foreground(int pid, bool value)
 703 {
 704         if (0 != __dbus_check()) {
 705                 return VC_ERROR_OPERATION_FAILED;
 706         }
 707
 708         DBusMessage* msg = NULL;
 709         int tmp_value = 0;
 710
 711         tmp_value = (int)value;
 712
 713         msg = dbus_message_new_signal(
 714                 VC_MANAGER_SERVICE_OBJECT_PATH,
 715                 VC_MANAGER_SERVICE_INTERFACE,
 716                 VCC_MANAGER_METHOD_SET_FOREGROUND);
 717
 718         if (NULL == msg) {
 719                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to manager : Fail to make message");
 720                 return VC_ERROR_OPERATION_FAILED;
 721         } else {
 722                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 723         }
 724
 725         dbus_message_append_args(msg,
 726                 DBUS_TYPE_INT32, &pid,
 727                 DBUS_TYPE_INT32, &tmp_value,
 728                 DBUS_TYPE_INVALID);
 729
 730         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 731                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 732                 return VC_ERROR_OPERATION_FAILED;
 733         }
 734
 735         dbus_message_unref(msg);
 736
 737         msg = NULL;
 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_METHOD_SET_FOREGROUND);
 743
 744         if (NULL == msg) {
 745                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget set foreground to daemon : Fail to make message");
 746                 return VC_ERROR_OPERATION_FAILED;
 747         } else {
 748                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 749         }
 750
 751         dbus_message_append_args(msg,
 752                 DBUS_TYPE_INT32, &pid,
 753                 DBUS_TYPE_INT32, &tmp_value,
 754                 DBUS_TYPE_INVALID);
 755
 756         dbus_message_set_no_reply(msg, TRUE);
 757
 758         if (1 != dbus_connection_send(g_w_conn_sender, msg, NULL)) {
 759                 SLOG(LOG_ERROR, TAG_VCW, "[Dbus ERROR] Fail to Send");
 760                 return VC_ERROR_OPERATION_FAILED;
 761         }
 762
 763         dbus_connection_flush(g_w_conn_sender);
 764
 765         dbus_message_unref(msg);
 766
 767         return 0;
 768 }
 769
 770 int vc_widget_dbus_request_enable_asr_result(int pid, bool enable)
 771 {
 772         if (0 != __dbus_check()) {
 773                 return VC_ERROR_OPERATION_FAILED;
 774         }
 775
 776         DBusMessage* msg;
 777
 778         /* create a signal & check for errors */
 779         msg = dbus_message_new_method_call(
 780                           VC_SERVER_SERVICE_NAME,
 781                           VC_SERVER_SERVICE_OBJECT_PATH,
 782                           VC_SERVER_SERVICE_INTERFACE,
 783                           VC_WIDGET_METHOD_ENABLE_ASR_RESULT);
 784
 785         if (NULL == msg) {
 786                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget enable asr result : Fail to make message ");
 787                 return VC_ERROR_OPERATION_FAILED;
 788         } else {
 789                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget enable asr result : pid(%d), enable(%d)", pid, enable);
 790         }
 791
 792         DBusMessageIter args;
 793         dbus_message_iter_init_append(msg, &args);
 794
 795         /* Append result*/
 796         int temp;
 797         if (false == enable)    temp = 0;
 798         else                    temp = 1;
 799         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 800         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
 801
 802         DBusError err;
 803         dbus_error_init(&err);
 804
 805         DBusMessage* result_msg;
 806         int result = VC_ERROR_OPERATION_FAILED;
 807
 808         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 809         dbus_message_unref(msg);
 810
 811         if (dbus_error_is_set(&err)) {
 812                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 813                 dbus_error_free(&err);
 814         }
 815
 816         if (NULL != result_msg) {
 817                 dbus_message_get_args(result_msg, &err,
 818                                                           DBUS_TYPE_INT32, &result,
 819                                                           DBUS_TYPE_INVALID);
 820
 821                 if (dbus_error_is_set(&err)) {
 822                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 823                         dbus_error_free(&err);
 824                         result = VC_ERROR_OPERATION_FAILED;
 825                 }
 826                 dbus_message_unref(result_msg);
 827
 828                 if (0 == result) {
 829                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget enable asr result : result = %d", result);
 830                 } else {
 831                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget enable asr result : result = %d", result);
 832                 }
 833         } else {
 834                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 835                 vc_widget_dbus_reconnect();
 836                 result = VC_ERROR_TIMED_OUT;
 837         }
 838
 839         return result;
 840 }
 841
 842 int vc_widget_dbus_request_start(int pid, int silence)
 843 {
 844         if (0 != __dbus_check()) {
 845                 return VC_ERROR_OPERATION_FAILED;
 846         }
 847
 848         DBusMessage* msg;
 849
 850         /* create a signal & check for errors */
 851         msg = dbus_message_new_method_call(
 852                           VC_SERVER_SERVICE_NAME,
 853                           VC_SERVER_SERVICE_OBJECT_PATH,
 854                           VC_SERVER_SERVICE_INTERFACE,
 855                           VC_WIDGET_METHOD_START);
 856
 857         if (NULL == msg) {
 858                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget start : Fail to make message ");
 859                 return VC_ERROR_OPERATION_FAILED;
 860         } else {
 861                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget start : pid(%d), silence(%d)", pid, silence);
 862         }
 863
 864         DBusMessageIter args;
 865         dbus_message_iter_init_append(msg, &args);
 866
 867         /* Append result*/
 868         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 869         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 870
 871         DBusError err;
 872         dbus_error_init(&err);
 873
 874         DBusMessage* result_msg;
 875         int result = VC_ERROR_OPERATION_FAILED;
 876
 877         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 878         dbus_message_unref(msg);
 879
 880         if (dbus_error_is_set(&err)) {
 881                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 882                 dbus_error_free(&err);
 883         }
 884
 885         if (NULL != result_msg) {
 886                 dbus_message_get_args(result_msg, &err,
 887                                                           DBUS_TYPE_INT32, &result,
 888                                                           DBUS_TYPE_INVALID);
 889
 890                 if (dbus_error_is_set(&err)) {
 891                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 892                         dbus_error_free(&err);
 893                         result = VC_ERROR_OPERATION_FAILED;
 894                 }
 895                 dbus_message_unref(result_msg);
 896
 897                 if (0 == result) {
 898                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget start : result = %d", result);
 899                 } else {
 900                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget start : result = %d", result);
 901                 }
 902         } else {
 903                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 904                 vc_widget_dbus_reconnect();
 905                 result = VC_ERROR_TIMED_OUT;
 906         }
 907
 908         return result;
 909 }
 910
 911 int vc_widget_dbus_request_stop(int pid)
 912 {
 913         if (0 != __dbus_check()) {
 914                 return VC_ERROR_OPERATION_FAILED;
 915         }
 916
 917         DBusMessage* msg;
 918
 919         /* create a signal & check for errors */
 920         msg = dbus_message_new_method_call(
 921                           VC_SERVER_SERVICE_NAME,
 922                           VC_SERVER_SERVICE_OBJECT_PATH,
 923                           VC_SERVER_SERVICE_INTERFACE,
 924                           VC_WIDGET_METHOD_STOP);
 925
 926         if (NULL == msg) {
 927                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget stop : Fail to make message ");
 928                 return VC_ERROR_OPERATION_FAILED;
 929         } else {
 930                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget stop : pid(%d)", pid);
 931         }
 932
 933         dbus_message_append_args(msg,
 934                                                          DBUS_TYPE_INT32, &pid,
 935                                                          DBUS_TYPE_INVALID);
 936
 937         DBusError err;
 938         dbus_error_init(&err);
 939
 940         DBusMessage* result_msg;
 941         int result = VC_ERROR_OPERATION_FAILED;
 942
 943         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
 944         dbus_message_unref(msg);
 945
 946         if (dbus_error_is_set(&err)) {
 947                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
 948                 dbus_error_free(&err);
 949         }
 950
 951         if (NULL != result_msg) {
 952                 dbus_message_get_args(result_msg, &err,
 953                                                           DBUS_TYPE_INT32, &result,
 954                                                           DBUS_TYPE_INVALID);
 955
 956                 if (dbus_error_is_set(&err)) {
 957                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
 958                         dbus_error_free(&err);
 959                         result = VC_ERROR_OPERATION_FAILED;
 960                 }
 961                 dbus_message_unref(result_msg);
 962
 963                 if (0 == result) {
 964                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 965                 } else {
 966                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget stop : result = %d", result);
 967                 }
 968         } else {
 969                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
 970                 vc_widget_dbus_reconnect();
 971                 result = VC_ERROR_TIMED_OUT;
 972         }
 973
 974         return result;
 975 }
 976
 977 int vc_widget_dbus_request_cancel(int pid)
 978 {
 979         if (0 != __dbus_check()) {
 980                 return VC_ERROR_OPERATION_FAILED;
 981         }
 982
 983         DBusMessage* msg;
 984
 985         /* create a signal & check for errors */
 986         msg = dbus_message_new_method_call(
 987                           VC_SERVER_SERVICE_NAME,
 988                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
 989                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
 990                           VC_WIDGET_METHOD_CANCEL);     /* name of the signal */
 991
 992         if (NULL == msg) {
 993                 SLOG(LOG_ERROR, TAG_VCW, ">>>> vc widget cancel : Fail to make message ");
 994                 return VC_ERROR_OPERATION_FAILED;
 995         } else {
 996                 SLOG(LOG_DEBUG, TAG_VCW, ">>>> vc widget cancel : pid(%d)", pid);
 997         }
 998
 999         dbus_message_append_args(msg,
1000                                                          DBUS_TYPE_INT32, &pid,
1001                                                          DBUS_TYPE_INVALID);
1002
1003         DBusError err;
1004         dbus_error_init(&err);
1005
1006         DBusMessage* result_msg;
1007         int result = VC_ERROR_OPERATION_FAILED;
1008
1009         result_msg = dbus_connection_send_with_reply_and_block(g_w_conn_sender, msg, g_w_waiting_time, &err);
1010         dbus_message_unref(msg);
1011
1012         if (dbus_error_is_set(&err)) {
1013                 SLOG(LOG_ERROR, TAG_VCW, "[ERROR] Dbus Error (%s)", err.message);
1014                 dbus_error_free(&err);
1015         }
1016
1017         if (NULL != result_msg) {
1018                 dbus_message_get_args(result_msg, &err,
1019                                                           DBUS_TYPE_INT32, &result,
1020                                                           DBUS_TYPE_INVALID);
1021
1022                 if (dbus_error_is_set(&err)) {
1023                         SLOG(LOG_ERROR, TAG_VCW, "<<<< Get arguments error (%s)", err.message);
1024                         dbus_error_free(&err);
1025                         result = VC_ERROR_OPERATION_FAILED;
1026                 }
1027                 dbus_message_unref(result_msg);
1028
1029                 if (0 == result) {
1030                         SLOG(LOG_DEBUG, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
1031                 } else {
1032                         SLOG(LOG_ERROR, TAG_VCW, "<<<< vc widget cancel : result = %d", result);
1033                 }
1034         } else {
1035                 SLOG(LOG_DEBUG, TAG_VCW, "<<<< Result Message is NULL");
1036                 vc_widget_dbus_reconnect();
1037                 result = VC_ERROR_TIMED_OUT;
1038         }
1039
1040         return result;
1041 }