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