client/vc_widget_dbus.c

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