client/vc_mgr_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_mgr_client.h"
  20 #include "vc_mgr_dbus.h"
  21 #include "vc_command.h"
  22
  23
  24 static int g_m_waiting_time = 3000;
  25
  26 static Ecore_Fd_Handler* g_m_fd_handler = NULL;
  27
  28 static DBusConnection* g_m_conn_sender = NULL;
  29 static DBusConnection* g_m_conn_listener = NULL;
  30
  31
  32 extern void __vc_mgr_cb_all_result(vc_result_type_e type);
  33
  34 extern void __vc_mgr_cb_system_result();
  35
  36 extern void __vc_mgr_cb_speech_detected();
  37
  38 extern int __vc_mgr_cb_error(int pid, int reason);
  39
  40 extern int __vc_mgr_cb_set_volume(float volume);
  41
  42 extern int __vc_mgr_cb_service_state(int state);
  43
  44 /* Authority */
  45 extern int __vc_mgr_request_auth_enable(int pid);
  46
  47 extern int __vc_mgr_request_auth_disable(int pid);
  48
  49 extern int __vc_mgr_request_auth_start(int pid);
  50
  51 extern int __vc_mgr_request_auth_stop(int pid);
  52
  53 extern int __vc_mgr_request_auth_cancel(int pid);
  54
  55 static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  56 {
  57         if (NULL == g_m_conn_listener)  return ECORE_CALLBACK_RENEW;
  58
  59         dbus_connection_read_write_dispatch(g_m_conn_listener, 50);
  60
  61         while (1) {
  62                 DBusMessage* msg = NULL;
  63                 msg = dbus_connection_pop_message(g_m_conn_listener);
  64
  65                 /* loop again if we haven't read a message */
  66                 if (NULL == msg) {
  67                         break;
  68                 }
  69
  70                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Message is arrived");
  71
  72                 DBusError err;
  73                 dbus_error_init(&err);
  74
  75                 char if_name[64];
  76                 snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE);
  77
  78                 if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
  79                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Hello");
  80                         int pid = 0;
  81                         int response = -1;
  82
  83                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  84                         if (dbus_error_is_set(&err)) {
  85                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
  86                                 dbus_error_free(&err);
  87                         }
  88
  89                         if (pid > 0) {
  90                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get hello : pid(%d) ", pid);
  91                                 response = 1;
  92                         } else {
  93                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get hello : invalid pid ");
  94                         }
  95
  96                         DBusMessage *reply = NULL;
  97                         reply = dbus_message_new_method_return(msg);
  98
  99                         if (NULL != reply) {
 100                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 101
 102                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 103                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc get hello : fail to send reply");
 104                                 else
 105                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc get hello : result(%d)", response);
 106
 107                                 dbus_connection_flush(g_m_conn_listener);
 108                                 dbus_message_unref(reply);
 109                         } else {
 110                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get hello : fail to create reply message");
 111                         }
 112
 113                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 114                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 115                 } /* VCD_METHOD_HELLO */
 116
 117                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_VOLUME)) {
 118                         /* SLOG(LOG_DEBUG, TAG_VCM, "===== Set volume"); */
 119                         float volume = 0;
 120
 121                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
 122
 123                         if (dbus_error_is_set(&err)) {
 124                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
 125                                 dbus_error_free(&err);
 126                         }
 127
 128                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set volume : volume(%f)", volume);
 129                         __vc_mgr_cb_set_volume(volume);
 130
 131                         /* SLOG(LOG_DEBUG, TAG_VCM, "====="); */
 132                         /* SLOG(LOG_DEBUG, TAG_VCM, " "); */
 133                 } /* VCD_MANAGER_METHOD_SET_VOLUME */
 134
 135                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_SERVICE_STATE)) {
 136                         int state = 0;
 137
 138                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 139                         if (dbus_error_is_set(&err)) {
 140                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
 141                                 dbus_error_free(&err);
 142                         }
 143
 144                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< state changed : %d", state);
 145
 146                         __vc_mgr_cb_service_state(state);
 147
 148                 } /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
 149
 150                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
 151                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Speech detected");
 152
 153                         __vc_mgr_cb_speech_detected();
 154
 155                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 156                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 157
 158                 } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
 159
 160                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
 161                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get All Result");
 162                         int result_type = 0;
 163
 164                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 165
 166                         __vc_mgr_cb_all_result((vc_result_type_e)result_type);
 167
 168                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 169                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 170
 171                 } /* VCD_MANAGER_METHOD_ALL_RESULT */
 172
 173                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
 174                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get System Result");
 175
 176                         __vc_mgr_cb_system_result();
 177
 178                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 179                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 180
 181                 } /* VCD_MANAGER_METHOD_RESULT */
 182
 183                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
 184                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Error");
 185                         int pid;
 186                         int reason;
 187                         char* err_msg;
 188
 189                         dbus_message_get_args(msg, &err,
 190                                 DBUS_TYPE_INT32, &pid,
 191                                 DBUS_TYPE_INT32, &reason,
 192                                 DBUS_TYPE_STRING, &err_msg,
 193                                 DBUS_TYPE_INVALID);
 194
 195                         if (dbus_error_is_set(&err)) {
 196                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
 197                                 dbus_error_free(&err);
 198                         } else {
 199                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
 200                                 __vc_mgr_cb_error(pid, reason);
 201                         }
 202
 203                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 204                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 205                 } /* VCD_MANAGER_METHOD_ERROR */
 206
 207                 /* Authority */
 208                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) {
 209                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth enable");
 210                         int pid;
 211                         int ret = 0;
 212
 213                         dbus_message_get_args(msg, &err,
 214                                 DBUS_TYPE_INT32, &pid,
 215                                 DBUS_TYPE_INVALID);
 216
 217                         if (dbus_error_is_set(&err)) {
 218                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth enable : Get arguments error (%s)", err.message);
 219                                 dbus_error_free(&err);
 220                         } else {
 221                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth enable : pid(%d)", pid);
 222                                 ret = __vc_mgr_request_auth_enable(pid);
 223                         }
 224
 225                         DBusMessage *reply = NULL;
 226                         reply = dbus_message_new_method_return(msg);
 227
 228                         if (NULL != reply) {
 229                                 dbus_message_append_args(reply,
 230                                         DBUS_TYPE_INT32, &ret,
 231                                         DBUS_TYPE_INVALID);
 232                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 233                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to send reply");
 234                                 else
 235                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth enable : ret(%d)", ret);
 236                                 dbus_connection_flush(g_m_conn_listener);
 237                                 dbus_message_unref(reply);
 238                         } else {
 239                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to create reply message");
 240                         }
 241
 242                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 243                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 244                 } /* VC_METHOD_AUTH_ENABLE */
 245
 246                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_DISABLE)) {
 247                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth disable");
 248                         int pid;
 249                         int ret = 0;
 250
 251                         dbus_message_get_args(msg, &err,
 252                                 DBUS_TYPE_INT32, &pid,
 253                                 DBUS_TYPE_INVALID);
 254
 255                         if (dbus_error_is_set(&err)) {
 256                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth disable : Get arguments error (%s)", err.message);
 257                                 dbus_error_free(&err);
 258                         } else {
 259                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth disable : pid(%d)", pid);
 260                                 ret = __vc_mgr_request_auth_disable(pid);
 261                         }
 262
 263                         DBusMessage *reply = NULL;
 264                         reply = dbus_message_new_method_return(msg);
 265
 266                         if (NULL != reply) {
 267                                 dbus_message_append_args(reply,
 268                                         DBUS_TYPE_INT32, &ret,
 269                                         DBUS_TYPE_INVALID);
 270                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 271                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to send reply");
 272                                 else
 273                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth disable : ret(%d)", ret);
 274                                 dbus_connection_flush(g_m_conn_listener);
 275                                 dbus_message_unref(reply);
 276                         } else {
 277                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to create reply message");
 278                         }
 279
 280                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 281                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 282                 } /* VC_METHOD_AUTH_DISABLE */
 283
 284                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_START)) {
 285                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth start");
 286                         int pid;
 287                         int ret = 0;
 288
 289                         dbus_message_get_args(msg, &err,
 290                                 DBUS_TYPE_INT32, &pid,
 291                                 DBUS_TYPE_INVALID);
 292
 293                         if (dbus_error_is_set(&err)) {
 294                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth start : Get arguments error (%s)", err.message);
 295                                 dbus_error_free(&err);
 296                         } else {
 297                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth start : pid(%d)", pid);
 298                                 ret = __vc_mgr_request_auth_start(pid);
 299                         }
 300
 301                         DBusMessage *reply = NULL;
 302                         reply = dbus_message_new_method_return(msg);
 303
 304                         if (NULL != reply) {
 305                                 dbus_message_append_args(reply,
 306                                         DBUS_TYPE_INT32, &ret,
 307                                         DBUS_TYPE_INVALID);
 308                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 309                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to send reply");
 310                                 else
 311                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth start : ret(%d)", ret);
 312                                 dbus_connection_flush(g_m_conn_listener);
 313                                 dbus_message_unref(reply);
 314                         } else {
 315                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to create reply message");
 316                         }
 317
 318                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 319                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 320                 } /* VC_METHOD_AUTH_START */
 321
 322                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_STOP)) {
 323                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth stop");
 324                         int pid;
 325                         int ret = 0;
 326
 327                         dbus_message_get_args(msg, &err,
 328                                 DBUS_TYPE_INT32, &pid,
 329                                 DBUS_TYPE_INVALID);
 330
 331                         if (dbus_error_is_set(&err)) {
 332                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth stop : Get arguments error (%s)", err.message);
 333                                 dbus_error_free(&err);
 334                         } else {
 335                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth stop : pid(%d)", pid);
 336                                 ret = __vc_mgr_request_auth_stop(pid);
 337                         }
 338
 339                         DBusMessage *reply = NULL;
 340                         reply = dbus_message_new_method_return(msg);
 341
 342                         if (NULL != reply) {
 343                                 dbus_message_append_args(reply,
 344                                         DBUS_TYPE_INT32, &ret,
 345                                         DBUS_TYPE_INVALID);
 346                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 347                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to send reply");
 348                                 else
 349                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth stop : ret(%d)", ret);
 350                                 dbus_connection_flush(g_m_conn_listener);
 351                                 dbus_message_unref(reply);
 352                         } else {
 353                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to create reply message");
 354                         }
 355
 356                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 357                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 358                 } /* VC_METHOD_AUTH_STOP */
 359
 360                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_CANCEL)) {
 361                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth cancel");
 362                         int pid;
 363                         int ret = 0;
 364
 365                         dbus_message_get_args(msg, &err,
 366                                 DBUS_TYPE_INT32, &pid,
 367                                 DBUS_TYPE_INVALID);
 368
 369                         if (dbus_error_is_set(&err)) {
 370                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth cancel : Get arguments error (%s)", err.message);
 371                                 dbus_error_free(&err);
 372                         } else {
 373                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth cancel : pid(%d)", pid);
 374                                 ret = __vc_mgr_request_auth_cancel(pid);
 375                         }
 376
 377                         DBusMessage *reply = NULL;
 378                         reply = dbus_message_new_method_return(msg);
 379
 380                         if (NULL != reply) {
 381                                 dbus_message_append_args(reply,
 382                                         DBUS_TYPE_INT32, &ret,
 383                                         DBUS_TYPE_INVALID);
 384                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 385                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth cancel : fail to send reply");
 386                                 else
 387                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth cancel : ret(%d)", ret);
 388                                 dbus_connection_flush(g_m_conn_listener);
 389                                 dbus_message_unref(reply);
 390                         } else {
 391                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth cancel : fail to create reply message");
 392                         }
 393
 394                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 395                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 396                 } /* VC_METHOD_AUTH_CANCEL */
 397
 398                 else {
 399                         SLOG(LOG_DEBUG, TAG_VCM, "Message is NOT valid");
 400                         dbus_message_unref(msg);
 401                         break;
 402                 }
 403
 404                 /* free the message */
 405                 dbus_message_unref(msg);
 406         } /* while(1) */
 407
 408         return ECORE_CALLBACK_PASS_ON;
 409 }
 410
 411 int vc_mgr_dbus_open_connection()
 412 {
 413         if (NULL != g_m_conn_sender && NULL != g_m_conn_listener) {
 414                 SLOG(LOG_WARN, TAG_VCM, "already existed connection ");
 415                 return 0;
 416         }
 417
 418         DBusError err;
 419         int ret;
 420
 421         /* initialise the error value */
 422         dbus_error_init(&err);
 423
 424         /* connect to the DBUS system bus, and check for errors */
 425         g_m_conn_sender = dbus_bus_get(DBUS_BUS_SESSION, &err);
 426
 427         if (dbus_error_is_set(&err)) {
 428                 SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
 429                 dbus_error_free(&err);
 430         }
 431
 432         if (NULL == g_m_conn_sender) {
 433                 SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
 434                 return VC_ERROR_OPERATION_FAILED;
 435         }
 436
 437         /* connect to the DBUS system bus, and check for errors */
 438         g_m_conn_listener = dbus_bus_get(DBUS_BUS_SESSION, &err);
 439
 440         if (dbus_error_is_set(&err)) {
 441                 SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
 442                 dbus_error_free(&err);
 443         }
 444
 445         if (NULL == g_m_conn_listener) {
 446                 SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
 447                 return VC_ERROR_OPERATION_FAILED;
 448         }
 449
 450         SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", VC_MANAGER_SERVICE_NAME);
 451
 452         /* register our name on the bus, and check for errors */
 453         ret = dbus_bus_request_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 454
 455         if (dbus_error_is_set(&err)) {
 456                 SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
 457                 dbus_error_free(&err);
 458         }
 459
 460         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 461                 SLOG(LOG_ERROR, TAG_VCM, "fail dbus_bus_request_name()");
 462                 return -2;
 463         }
 464
 465         if (NULL != g_m_fd_handler) {
 466                 SLOG(LOG_WARN, TAG_VCM, "The handler already exists.");
 467                 return 0;
 468         }
 469
 470         char rule[128] = {0, };
 471         snprintf(rule, 128, "type='signal',interface='%s'", VC_MANAGER_SERVICE_INTERFACE);
 472
 473         /* add a rule for which messages we want to see */
 474         dbus_bus_add_match(g_m_conn_listener, rule, &err);
 475         dbus_connection_flush(g_m_conn_listener);
 476
 477         if (dbus_error_is_set(&err)) {
 478                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 479                 dbus_error_free(&err);
 480                 return VC_ERROR_OPERATION_FAILED;
 481         }
 482
 483         int fd = 0;
 484         if (1 != dbus_connection_get_unix_fd(g_m_conn_listener, &fd)) {
 485                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd from dbus ");
 486                 return VC_ERROR_OPERATION_FAILED;
 487         } else {
 488                 SLOG(LOG_DEBUG, TAG_VCM, "Get fd from dbus : %d", fd);
 489         }
 490
 491         g_m_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)vc_mgr_listener_event_callback, g_m_conn_listener, NULL, NULL);
 492
 493         if (NULL == g_m_fd_handler) {
 494                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd handler from ecore ");
 495                 return VC_ERROR_OPERATION_FAILED;
 496         }
 497
 498         return 0;
 499 }
 500
 501 int vc_mgr_dbus_close_connection()
 502 {
 503         DBusError err;
 504         dbus_error_init(&err);
 505
 506         if (NULL != g_m_fd_handler) {
 507                 ecore_main_fd_handler_del(g_m_fd_handler);
 508                 g_m_fd_handler = NULL;
 509         }
 510
 511         dbus_bus_release_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, &err);
 512
 513         if (dbus_error_is_set(&err)) {
 514                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 515                 dbus_error_free(&err);
 516         }
 517
 518         g_m_conn_sender = NULL;
 519         g_m_conn_listener = NULL;
 520
 521         return 0;
 522 }
 523
 524 int vc_mgr_dbus_reconnect()
 525 {
 526         bool sender_connected = dbus_connection_get_is_connected(g_m_conn_sender);
 527         bool listener_connected = dbus_connection_get_is_connected(g_m_conn_listener);
 528
 529         SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Sender(%s) Listener(%s)",
 530                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 531
 532         if (false == sender_connected || false == listener_connected) {
 533                 vc_mgr_dbus_close_connection();
 534
 535                 if (0 != vc_mgr_dbus_open_connection()) {
 536                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to reconnect");
 537                         return -1;
 538                 }
 539
 540                 SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
 541         }
 542
 543         return 0;
 544 }
 545
 546 int vc_mgr_dbus_request_hello()
 547 {
 548         DBusMessage* msg;
 549
 550         msg = dbus_message_new_method_call(
 551                           VC_SERVER_SERVICE_NAME,
 552                           VC_SERVER_SERVICE_OBJECT_PATH,
 553                           VC_SERVER_SERVICE_INTERFACE,
 554                           VC_METHOD_HELLO);
 555
 556         if (NULL == msg) {
 557                 SLOG(LOG_ERROR, TAG_VCM, ">>>> Request vc hello : Fail to make message");
 558                 return VC_ERROR_OPERATION_FAILED;
 559         }
 560
 561         DBusError err;
 562         dbus_error_init(&err);
 563
 564         DBusMessage* result_msg = NULL;
 565         int result = 0;
 566
 567         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, 500, &err);
 568
 569         if (dbus_error_is_set(&err)) {
 570                 dbus_error_free(&err);
 571         }
 572
 573         dbus_message_unref(msg);
 574
 575         if (NULL != result_msg) {
 576                 dbus_message_unref(result_msg);
 577                 result = 0;
 578         } else {
 579                 result = VC_ERROR_TIMED_OUT;
 580         }
 581
 582         return result;
 583 }
 584
 585
 586 int vc_mgr_dbus_request_initialize(int pid, int* service_state)
 587 {
 588         DBusMessage* msg;
 589
 590         msg = dbus_message_new_method_call(
 591                           VC_SERVER_SERVICE_NAME,
 592                           VC_SERVER_SERVICE_OBJECT_PATH,
 593                           VC_SERVER_SERVICE_INTERFACE,
 594                           VC_MANAGER_METHOD_INITIALIZE);
 595
 596         if (NULL == msg) {
 597                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr initialize : Fail to make message ");
 598                 return VC_ERROR_OPERATION_FAILED;
 599         } else {
 600                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr initialize : pid(%d)", pid);
 601         }
 602
 603         dbus_message_append_args(msg,
 604                 DBUS_TYPE_INT32, &pid,
 605                 DBUS_TYPE_INVALID);
 606
 607         DBusError err;
 608         dbus_error_init(&err);
 609
 610         DBusMessage* result_msg;
 611         int result = VC_ERROR_OPERATION_FAILED;
 612
 613         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 614         dbus_message_unref(msg);
 615
 616         if (dbus_error_is_set(&err)) {
 617                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 618                 dbus_error_free(&err);
 619         }
 620
 621         if (NULL != result_msg) {
 622                 dbus_message_get_args(result_msg, &err,
 623                         DBUS_TYPE_INT32, &result,
 624                         DBUS_TYPE_INT32, service_state,
 625                         DBUS_TYPE_INVALID);
 626
 627                 if (dbus_error_is_set(&err)) {
 628                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 629                         dbus_error_free(&err);
 630                         result = VC_ERROR_OPERATION_FAILED;
 631                 }
 632
 633                 dbus_message_unref(result_msg);
 634
 635                 if (0 == result) {
 636                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d", result, *service_state);
 637                 } else {
 638                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
 639                 }
 640         } else {
 641                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL ");
 642                 vc_mgr_dbus_reconnect();
 643                 result = VC_ERROR_TIMED_OUT;
 644         }
 645
 646         return result;
 647 }
 648
 649 int vc_mgr_dbus_request_finalize(int pid)
 650 {
 651         DBusMessage* msg;
 652
 653         msg = dbus_message_new_method_call(
 654                           VC_SERVER_SERVICE_NAME,
 655                           VC_SERVER_SERVICE_OBJECT_PATH,
 656                           VC_SERVER_SERVICE_INTERFACE,
 657                           VC_MANAGER_METHOD_FINALIZE);
 658
 659         if (NULL == msg) {
 660                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr finalize : Fail to make message ");
 661                 return VC_ERROR_OPERATION_FAILED;
 662         } else {
 663                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr finalize : pid(%d)", pid);
 664         }
 665
 666         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 667
 668         DBusError err;
 669         dbus_error_init(&err);
 670
 671         DBusMessage* result_msg;
 672         int result = VC_ERROR_OPERATION_FAILED;
 673
 674         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 675         dbus_message_unref(msg);
 676
 677         if (dbus_error_is_set(&err)) {
 678                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 679                 dbus_error_free(&err);
 680         }
 681
 682         if (NULL != result_msg) {
 683                 dbus_message_get_args(result_msg, &err,
 684                                                           DBUS_TYPE_INT32, &result,
 685                                                           DBUS_TYPE_INVALID);
 686
 687                 if (dbus_error_is_set(&err)) {
 688                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 689                         dbus_error_free(&err);
 690                         result = VC_ERROR_OPERATION_FAILED;
 691                 }
 692
 693                 dbus_message_unref(result_msg);
 694
 695                 if (0 == result) {
 696                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr finalize : result = %d", result);
 697                 } else {
 698                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr finalize : result = %d", result);
 699                 }
 700         } else {
 701                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL ");
 702                 vc_mgr_dbus_reconnect();
 703                 result = VC_ERROR_TIMED_OUT;
 704         }
 705
 706         return result;
 707 }
 708
 709 int vc_mgr_dbus_request_set_command(int pid)
 710 {
 711         DBusMessage* msg;
 712
 713         msg = dbus_message_new_method_call(
 714                           VC_SERVER_SERVICE_NAME,
 715                           VC_SERVER_SERVICE_OBJECT_PATH,
 716                           VC_SERVER_SERVICE_INTERFACE,
 717                           VC_MANAGER_METHOD_SET_COMMAND);
 718
 719         if (NULL == msg) {
 720                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set command : Fail to make message");
 721                 return VC_ERROR_OPERATION_FAILED;
 722         } else {
 723                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set command : pid(%d)", pid);
 724         }
 725
 726         dbus_message_append_args(msg,
 727                                                          DBUS_TYPE_INT32, &pid,
 728                                                          DBUS_TYPE_INVALID);
 729
 730         DBusError err;
 731         dbus_error_init(&err);
 732
 733         DBusMessage* result_msg;
 734         int result = VC_ERROR_OPERATION_FAILED;
 735
 736         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 737         dbus_message_unref(msg);
 738
 739         if (dbus_error_is_set(&err)) {
 740                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 741                 dbus_error_free(&err);
 742         }
 743
 744         if (NULL != result_msg) {
 745                 dbus_message_get_args(result_msg, &err,
 746                                                           DBUS_TYPE_INT32, &result,
 747                                                           DBUS_TYPE_INVALID);
 748
 749                 if (dbus_error_is_set(&err)) {
 750                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 751                         dbus_error_free(&err);
 752                         result = VC_ERROR_OPERATION_FAILED;
 753                 }
 754                 dbus_message_unref(result_msg);
 755
 756                 if (0 == result) {
 757                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set command : result = %d", result);
 758                 } else {
 759                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set command : result = %d", result);
 760                 }
 761         } else {
 762                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
 763                 vc_mgr_dbus_reconnect();
 764                 result = VC_ERROR_TIMED_OUT;
 765         }
 766
 767         return result;
 768 }
 769
 770 int vc_mgr_dbus_request_unset_command(int pid)
 771 {
 772         DBusMessage* msg;
 773
 774         msg = dbus_message_new_method_call(
 775                           VC_SERVER_SERVICE_NAME,
 776                           VC_SERVER_SERVICE_OBJECT_PATH,
 777                           VC_SERVER_SERVICE_INTERFACE,
 778                           VC_MANAGER_METHOD_UNSET_COMMAND);
 779
 780         if (NULL == msg) {
 781                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr unset command : Fail to make message");
 782                 return VC_ERROR_OPERATION_FAILED;
 783         } else {
 784                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr unset command : pid(%d)", pid);
 785         }
 786
 787         dbus_message_append_args(msg,
 788                                                          DBUS_TYPE_INT32, &pid,
 789                                                          DBUS_TYPE_INVALID);
 790
 791         DBusError err;
 792         dbus_error_init(&err);
 793
 794         DBusMessage* result_msg;
 795         int result = VC_ERROR_OPERATION_FAILED;
 796
 797         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 798         dbus_message_unref(msg);
 799
 800         if (dbus_error_is_set(&err)) {
 801                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 802                 dbus_error_free(&err);
 803         }
 804
 805         if (NULL != result_msg) {
 806                 dbus_message_get_args(result_msg, &err,
 807                                                           DBUS_TYPE_INT32, &result,
 808                                                           DBUS_TYPE_INVALID);
 809
 810                 if (dbus_error_is_set(&err)) {
 811                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 812                         dbus_error_free(&err);
 813                         result = VC_ERROR_OPERATION_FAILED;
 814                 }
 815                 dbus_message_unref(result_msg);
 816
 817                 if (0 == result) {
 818                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr unset command : result = %d", result);
 819                 } else {
 820                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr unset command : result = %d", result);
 821                 }
 822         } else {
 823                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
 824                 vc_mgr_dbus_reconnect();
 825                 result = VC_ERROR_TIMED_OUT;
 826         }
 827
 828         return result;
 829 }
 830
 831 int vc_mgr_dbus_request_demandable_client(int pid)
 832 {
 833         DBusMessage* msg;
 834
 835         msg = dbus_message_new_method_call(
 836                           VC_SERVER_SERVICE_NAME,
 837                           VC_SERVER_SERVICE_OBJECT_PATH,
 838                           VC_SERVER_SERVICE_INTERFACE,
 839                           VC_MANAGER_METHOD_SET_DEMANDABLE);
 840
 841         if (NULL == msg) {
 842                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set demandable client : Fail to make message");
 843                 return VC_ERROR_OPERATION_FAILED;
 844         } else {
 845                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set demandable client : pid(%d)", pid);
 846         }
 847
 848         dbus_message_append_args(msg,
 849                                                          DBUS_TYPE_INT32, &pid,
 850                                                          DBUS_TYPE_INVALID);
 851
 852         DBusError err;
 853         dbus_error_init(&err);
 854
 855         DBusMessage* result_msg;
 856         int result = VC_ERROR_OPERATION_FAILED;
 857
 858         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 859         dbus_message_unref(msg);
 860
 861         if (dbus_error_is_set(&err)) {
 862                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 863                 dbus_error_free(&err);
 864         }
 865
 866         if (NULL != result_msg) {
 867                 dbus_message_get_args(result_msg, &err,
 868                                                           DBUS_TYPE_INT32, &result,
 869                                                           DBUS_TYPE_INVALID);
 870
 871                 if (dbus_error_is_set(&err)) {
 872                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 873                         dbus_error_free(&err);
 874                         result = VC_ERROR_OPERATION_FAILED;
 875                 }
 876                 dbus_message_unref(result_msg);
 877
 878                 if (0 == result) {
 879                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set demandable client : result = %d", result);
 880                 } else {
 881                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set demandable client : result = %d", result);
 882                 }
 883         } else {
 884                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
 885                 vc_mgr_dbus_reconnect();
 886                 result = VC_ERROR_TIMED_OUT;
 887         }
 888
 889         return result;
 890 }
 891
 892 int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type)
 893 {
 894         DBusMessage* msg;
 895
 896         /* create a signal & check for errors */
 897         msg = dbus_message_new_method_call(
 898                           VC_SERVER_SERVICE_NAME,
 899                           VC_SERVER_SERVICE_OBJECT_PATH,
 900                           VC_SERVER_SERVICE_INTERFACE,
 901                           VC_MANAGER_METHOD_SET_AUDIO_TYPE);
 902
 903         if (NULL == msg) {
 904                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set audio type : Fail to make message ");
 905                 return VC_ERROR_OPERATION_FAILED;
 906         } else {
 907                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
 908         }
 909
 910         dbus_message_append_args(msg,
 911                                                          DBUS_TYPE_INT32, &pid,
 912                                                          DBUS_TYPE_STRING, &(audio_type),
 913                                                          DBUS_TYPE_INVALID);
 914
 915         DBusError err;
 916         dbus_error_init(&err);
 917
 918         DBusMessage* result_msg;
 919         int result = VC_ERROR_OPERATION_FAILED;
 920
 921         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 922         dbus_message_unref(msg);
 923
 924         if (dbus_error_is_set(&err)) {
 925                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 926                 dbus_error_free(&err);
 927         }
 928
 929         if (NULL != result_msg) {
 930                 dbus_message_get_args(result_msg, &err,
 931                                                           DBUS_TYPE_INT32, &result,
 932                                                           DBUS_TYPE_INVALID);
 933
 934                 if (dbus_error_is_set(&err)) {
 935                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 936                         dbus_error_free(&err);
 937                         result = VC_ERROR_OPERATION_FAILED;
 938                 }
 939                 dbus_message_unref(result_msg);
 940
 941                 if (0 == result) {
 942                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set audio type : result = %d", result);
 943                 } else {
 944                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set audio type : result = %d", result);
 945                 }
 946         } else {
 947                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
 948                 vc_mgr_dbus_reconnect();
 949                 result = VC_ERROR_TIMED_OUT;
 950         }
 951
 952         return result;
 953 }
 954
 955 int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type)
 956 {
 957         DBusMessage* msg;
 958
 959         /* create a signal & check for errors */
 960         msg = dbus_message_new_method_call(
 961                           VC_SERVER_SERVICE_NAME,
 962                           VC_SERVER_SERVICE_OBJECT_PATH,
 963                           VC_SERVER_SERVICE_INTERFACE,
 964                           VC_MANAGER_METHOD_GET_AUDIO_TYPE);
 965
 966         if (NULL == msg) {
 967                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get audio type : Fail to make message ");
 968                 return VC_ERROR_OPERATION_FAILED;
 969         } else {
 970                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get audio type : pid(%d)", pid);
 971         }
 972
 973         dbus_message_append_args(msg,
 974                                                          DBUS_TYPE_INT32, &pid,
 975                                                          DBUS_TYPE_INVALID);
 976
 977         DBusError err;
 978         dbus_error_init(&err);
 979
 980         DBusMessage* result_msg;
 981         int result = VC_ERROR_OPERATION_FAILED;
 982         char* temp = NULL;
 983
 984         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 985         dbus_message_unref(msg);
 986
 987         if (dbus_error_is_set(&err)) {
 988                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 989                 dbus_error_free(&err);
 990         }
 991
 992         if (NULL != result_msg) {
 993                 dbus_message_get_args(result_msg, &err,
 994                                                           DBUS_TYPE_INT32, &result,
 995                                                           DBUS_TYPE_STRING, &temp,
 996                                                           DBUS_TYPE_INVALID);
 997
 998                 if (dbus_error_is_set(&err)) {
 999                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1000                         dbus_error_free(&err);
1001                         result = VC_ERROR_OPERATION_FAILED;
1002                 }
1003                 dbus_message_unref(result_msg);
1004
1005                 if (0 == result) {
1006                         if (NULL != audio_type && NULL != temp) {
1007                                 *audio_type = strdup(temp);
1008                         }
1009                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get audio type : result = %d audio type = %s", result, temp);
1010                 } else {
1011                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get audio type : result = %d", result);
1012                 }
1013         } else {
1014                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1015                 vc_mgr_dbus_reconnect();
1016                 result = VC_ERROR_TIMED_OUT;
1017         }
1018
1019         return result;
1020 }
1021
1022 int vc_mgr_dbus_request_set_client_info(int pid)
1023 {
1024         DBusMessage* msg;
1025
1026         /* create a signal & check for errors */
1027         msg = dbus_message_new_method_call(
1028                           VC_SERVER_SERVICE_NAME,
1029                           VC_SERVER_SERVICE_OBJECT_PATH,
1030                           VC_SERVER_SERVICE_INTERFACE,
1031                           VC_MANAGER_METHOD_SET_CLIENT_INFO);
1032
1033         if (NULL == msg) {
1034                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set client info : Fail to make message ");
1035                 return VC_ERROR_OPERATION_FAILED;
1036         } else {
1037                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set client info : pid(%d)", pid);
1038         }
1039
1040         dbus_message_append_args(msg,
1041                                                          DBUS_TYPE_INT32, &pid,
1042                                                          DBUS_TYPE_INVALID);
1043
1044         DBusError err;
1045         dbus_error_init(&err);
1046
1047         DBusMessage* result_msg;
1048         int result = VC_ERROR_OPERATION_FAILED;
1049
1050         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1051         dbus_message_unref(msg);
1052
1053         if (dbus_error_is_set(&err)) {
1054                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1055                 dbus_error_free(&err);
1056         }
1057
1058         if (NULL != result_msg) {
1059                 dbus_message_get_args(result_msg, &err,
1060                                                           DBUS_TYPE_INT32, &result,
1061                                                           DBUS_TYPE_INVALID);
1062
1063                 if (dbus_error_is_set(&err)) {
1064                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1065                         dbus_error_free(&err);
1066                         result = VC_ERROR_OPERATION_FAILED;
1067                 }
1068                 dbus_message_unref(result_msg);
1069
1070                 if (0 == result) {
1071                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set client info : result = %d", result);
1072                 } else {
1073                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set client info : result = %d", result);
1074                 }
1075         } else {
1076                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1077                 vc_mgr_dbus_reconnect();
1078                 result = VC_ERROR_TIMED_OUT;
1079         }
1080
1081         return result;
1082 }
1083
1084 int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
1085 {
1086         DBusMessage* msg;
1087
1088         /* create a signal & check for errors */
1089         msg = dbus_message_new_method_call(
1090                           VC_SERVER_SERVICE_NAME,
1091                           VC_SERVER_SERVICE_OBJECT_PATH,
1092                           VC_SERVER_SERVICE_INTERFACE,
1093                           VC_MANAGER_METHOD_START);
1094
1095         if (NULL == msg) {
1096                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr start : Fail to make message ");
1097                 return VC_ERROR_OPERATION_FAILED;
1098         } else {
1099                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
1100                          pid, recognition_mode, exclusive_command_option, start_by_client);
1101         }
1102
1103         int exclusive = exclusive_command_option;
1104         int by = start_by_client;
1105
1106         dbus_message_append_args(msg,
1107                                                          DBUS_TYPE_INT32, &pid,
1108                                                          DBUS_TYPE_INT32, &(recognition_mode),
1109                                                          DBUS_TYPE_INT32, &(exclusive),
1110                                                          DBUS_TYPE_INT32, &(by),
1111                                                          DBUS_TYPE_INVALID);
1112
1113         DBusError err;
1114         dbus_error_init(&err);
1115
1116         DBusMessage* result_msg;
1117         int result = VC_ERROR_OPERATION_FAILED;
1118
1119         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1120         dbus_message_unref(msg);
1121
1122         if (dbus_error_is_set(&err)) {
1123                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1124                 dbus_error_free(&err);
1125         }
1126
1127         if (NULL != result_msg) {
1128                 dbus_message_get_args(result_msg, &err,
1129                                                           DBUS_TYPE_INT32, &result,
1130                                                           DBUS_TYPE_INVALID);
1131
1132                 if (dbus_error_is_set(&err)) {
1133                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1134                         dbus_error_free(&err);
1135                         result = VC_ERROR_OPERATION_FAILED;
1136                 }
1137                 dbus_message_unref(result_msg);
1138
1139                 if (0 == result) {
1140                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr start : result = %d", result);
1141                 } else {
1142                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr start : result = %d", result);
1143                 }
1144         } else {
1145                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1146                 vc_mgr_dbus_reconnect();
1147                 result = VC_ERROR_TIMED_OUT;
1148         }
1149
1150         return result;
1151 }
1152
1153 int vc_mgr_dbus_request_stop(int pid)
1154 {
1155         DBusMessage* msg;
1156
1157         /* create a signal & check for errors */
1158         msg = dbus_message_new_method_call(
1159                           VC_SERVER_SERVICE_NAME,
1160                           VC_SERVER_SERVICE_OBJECT_PATH,
1161                           VC_SERVER_SERVICE_INTERFACE,
1162                           VC_MANAGER_METHOD_STOP);
1163
1164         if (NULL == msg) {
1165                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr stop : Fail to make message ");
1166                 return VC_ERROR_OPERATION_FAILED;
1167         } else {
1168                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr stop : pid(%d)", pid);
1169         }
1170
1171         dbus_message_append_args(msg,
1172                                                          DBUS_TYPE_INT32, &pid,
1173                                                          DBUS_TYPE_INVALID);
1174
1175         DBusError err;
1176         dbus_error_init(&err);
1177
1178         DBusMessage* result_msg;
1179         int result = VC_ERROR_OPERATION_FAILED;
1180
1181         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1182         dbus_message_unref(msg);
1183
1184         if (dbus_error_is_set(&err)) {
1185                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1186                 dbus_error_free(&err);
1187         }
1188
1189         if (NULL != result_msg) {
1190                 dbus_message_get_args(result_msg, &err,
1191                                                           DBUS_TYPE_INT32, &result,
1192                                                           DBUS_TYPE_INVALID);
1193
1194                 if (dbus_error_is_set(&err)) {
1195                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1196                         dbus_error_free(&err);
1197                         result = VC_ERROR_OPERATION_FAILED;
1198                 }
1199                 dbus_message_unref(result_msg);
1200
1201                 if (0 == result) {
1202                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr stop : result = %d", result);
1203                 } else {
1204                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr stop : result = %d", result);
1205                 }
1206         } else {
1207                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1208                 vc_mgr_dbus_reconnect();
1209                 result = VC_ERROR_TIMED_OUT;
1210         }
1211
1212         return result;
1213 }
1214
1215 int vc_mgr_dbus_request_cancel(int pid)
1216 {
1217         DBusMessage* msg;
1218
1219         /* create a signal & check for errors */
1220         msg = dbus_message_new_method_call(
1221                           VC_SERVER_SERVICE_NAME,
1222                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1223                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1224                           VC_MANAGER_METHOD_CANCEL);    /* name of the signal */
1225
1226         if (NULL == msg) {
1227                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc cancel : Fail to make message ");
1228                 return VC_ERROR_OPERATION_FAILED;
1229         } else {
1230                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc cancel : pid(%d)", pid);
1231         }
1232
1233         dbus_message_append_args(msg,
1234                                                          DBUS_TYPE_INT32, &pid,
1235                                                          DBUS_TYPE_INVALID);
1236
1237         DBusError err;
1238         dbus_error_init(&err);
1239
1240         DBusMessage* result_msg;
1241         int result = VC_ERROR_OPERATION_FAILED;
1242
1243         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1244         dbus_message_unref(msg);
1245
1246         if (dbus_error_is_set(&err)) {
1247                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1248                 dbus_error_free(&err);
1249         }
1250
1251         if (NULL != result_msg) {
1252                 dbus_message_get_args(result_msg, &err,
1253                                                           DBUS_TYPE_INT32, &result,
1254                                                           DBUS_TYPE_INVALID);
1255
1256                 if (dbus_error_is_set(&err)) {
1257                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1258                         dbus_error_free(&err);
1259                         result = VC_ERROR_OPERATION_FAILED;
1260                 }
1261                 dbus_message_unref(result_msg);
1262
1263                 if (0 == result) {
1264                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc cancel : result = %d", result);
1265                 } else {
1266                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc cancel : result = %d", result);
1267                 }
1268         } else {
1269                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1270                 vc_mgr_dbus_reconnect();
1271                 result = VC_ERROR_TIMED_OUT;
1272         }
1273
1274         return result;
1275 }
1276
1277 static DBusMessage* __get_message(int pid, const char* method, int type)
1278 {
1279         char service_name[64];
1280         char object_path[64];
1281         char target_if_name[128];
1282
1283         memset(service_name, '\0', 64);
1284         memset(object_path, '\0', 64);
1285         memset(target_if_name, '\0', 128);
1286
1287         if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
1288                 snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
1289                 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
1290                 snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_NAME);
1291
1292         } else if (VC_COMMAND_TYPE_WIDGET == type) {
1293                 snprintf(service_name, 64, "%s", VC_WIDGET_SERVICE_NAME);
1294                 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
1295                 snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
1296         } else {
1297                 return NULL;
1298         }
1299
1300         SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name);
1301
1302         return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
1303 }
1304
1305 int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id)
1306 {
1307         DBusMessage* msg = NULL;
1308
1309         switch (cmd_type) {
1310         case VC_COMMAND_TYPE_FOREGROUND:
1311         case VC_COMMAND_TYPE_BACKGROUND:
1312                 msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type);
1313                 break;
1314         case VC_COMMAND_TYPE_WIDGET:
1315                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, cmd_type);
1316                 break;
1317         default:
1318                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
1319                 return -1;
1320         }
1321
1322         if (NULL == msg)
1323                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Message is NULL");
1324
1325         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_id, DBUS_TYPE_INVALID);
1326
1327         dbus_message_set_no_reply(msg, TRUE);
1328
1329         /* send the message and flush the connection */
1330         if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
1331                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
1332         } else {
1333                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Success to send result");
1334
1335                 dbus_connection_flush(g_m_conn_sender);
1336         }
1337
1338         dbus_message_unref(msg);
1339
1340         return 0;
1341 }
1342
1343 int vc_mgr_dbus_send_result_selection(int pid)
1344 {
1345         DBusMessage* msg;
1346
1347         /* create a signal & check for errors */
1348         msg = dbus_message_new_method_call(
1349                           VC_SERVER_SERVICE_NAME,
1350                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1351                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1352                           VC_MANAGER_METHOD_RESULT_SELECTION);  /* name of the signal */
1353
1354         if (NULL == msg) {
1355                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc result selection : Fail to make message ");
1356                 return VC_ERROR_OPERATION_FAILED;
1357         } else {
1358                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc result selection : pid(%d)", pid);
1359         }
1360
1361         dbus_message_append_args(msg,
1362                                                          DBUS_TYPE_INT32, &pid,
1363                                                          DBUS_TYPE_INVALID);
1364
1365         dbus_message_set_no_reply(msg, TRUE);
1366
1367         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
1368                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
1369                 return -1;
1370         } else {
1371                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
1372                 dbus_connection_flush(g_m_conn_sender);
1373         }
1374
1375         return 0;
1376 }