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