client/vc_widget_dbus.c

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