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 static int g_volume_count = 0;
  32
  33
  34 extern void __vc_mgr_cb_all_result(vc_result_type_e type);
  35
  36 extern void __vc_mgr_cb_pre_result(int event, const char* pre_result);
  37
  38 extern void __vc_mgr_cb_system_result();
  39
  40 extern void __vc_mgr_cb_speech_detected();
  41
  42 extern int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg);
  43
  44 extern int __vc_mgr_cb_set_volume(float volume);
  45
  46 extern int __vc_mgr_cb_service_state(int state);
  47
  48 extern int __vc_mgr_cb_set_foreground(int pid, bool value);
  49
  50 /* Authority */
  51 extern int __vc_mgr_request_auth_enable(int pid);
  52
  53 extern int __vc_mgr_request_auth_disable(int pid);
  54
  55 extern int __vc_mgr_request_auth_start(int pid);
  56
  57 extern int __vc_mgr_request_auth_stop(int pid);
  58
  59 extern int __vc_mgr_request_auth_cancel(int pid);
  60
  61 extern int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous);
  62
  63 static Eina_Bool vc_mgr_listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  64 {
  65         if (NULL == g_m_conn_listener)  return ECORE_CALLBACK_RENEW;
  66
  67         dbus_connection_read_write_dispatch(g_m_conn_listener, 50);
  68
  69         while (1) {
  70                 DBusMessage* msg = NULL;
  71                 msg = dbus_connection_pop_message(g_m_conn_listener);
  72
  73                 /* loop again if we haven't read a message */
  74                 if (NULL == msg) {
  75                         break;
  76                 }
  77
  78                 /* SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Message is arrived"); */
  79
  80                 DBusError err;
  81                 dbus_error_init(&err);
  82
  83                 char if_name[64] = {0, };
  84                 snprintf(if_name, 64, "%s", VC_MANAGER_SERVICE_INTERFACE);
  85
  86                 if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_HELLO)) {
  87                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Hello");
  88                         int pid = 0;
  89                         int response = -1;
  90
  91                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  92                         if (dbus_error_is_set(&err)) {
  93                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
  94                                 dbus_error_free(&err);
  95                         }
  96
  97                         if (pid > 0) {
  98                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get hello : pid(%d) ", pid);
  99                                 response = 1;
 100                         } else {
 101                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get hello : invalid pid ");
 102                         }
 103
 104                         DBusMessage *reply = NULL;
 105                         reply = dbus_message_new_method_return(msg);
 106
 107                         if (NULL != reply) {
 108                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 109
 110                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 111                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc get hello : fail to send reply");
 112                                 else
 113                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc get hello : result(%d)", response);
 114
 115                                 dbus_connection_flush(g_m_conn_listener);
 116                                 dbus_message_unref(reply);
 117                         } else {
 118                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get hello : fail to create reply message");
 119                         }
 120
 121                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 122                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 123                 } /* VCD_METHOD_HELLO */
 124
 125                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_VOLUME)) {
 126                         float volume = 0;
 127
 128                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
 129
 130                         if (dbus_error_is_set(&err)) {
 131                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
 132                                 dbus_error_free(&err);
 133                         }
 134
 135                         if (10 == g_volume_count) {
 136                                 SLOG(LOG_DEBUG, TAG_VCM, "===== Set volume");
 137                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set volume : volume(%f)", volume);
 138                                 g_volume_count = 0;
 139                         }
 140
 141                         __vc_mgr_cb_set_volume(volume);
 142                         g_volume_count++;
 143
 144                 } /* VCD_MANAGER_METHOD_SET_VOLUME */
 145
 146                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_SET_SERVICE_STATE)) {
 147                         int state = 0;
 148
 149                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 150                         if (dbus_error_is_set(&err)) {
 151                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
 152                                 dbus_error_free(&err);
 153                         }
 154
 155                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< state changed : %d", state);
 156
 157                         __vc_mgr_cb_service_state(state);
 158
 159                 } /* VCD_MANAGER_METHOD_SET_SERVICE_STATE */
 160
 161                 else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_SPEECH_DETECTED)) {
 162                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Speech detected");
 163
 164                         __vc_mgr_cb_speech_detected();
 165
 166                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 167                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 168
 169                 } /* VCD_MANAGER_METHOD_SPEECH_DETECTED */
 170
 171                 else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_ALL_RESULT)) {
 172                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get All Result");
 173                         int result_type = 0;
 174
 175                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
 176
 177                         __vc_mgr_cb_all_result((vc_result_type_e)result_type);
 178
 179                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 180                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 181
 182                 } /* VCD_MANAGER_METHOD_ALL_RESULT */
 183
 184                 else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_PRE_RESULT)) {
 185                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Pre Result");
 186                         int event;
 187                         char* pre_result = NULL;
 188
 189                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
 190
 191                         if (NULL != pre_result) {
 192                                 __vc_mgr_cb_pre_result((vc_pre_result_event_e)event, pre_result);
 193                         }
 194
 195                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 196                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 197                 } /* VCD_MANAGER_METHOD_PRE_RESULT */
 198
 199                 else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_RESULT)) {
 200                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get System Result");
 201
 202                         __vc_mgr_cb_system_result();
 203
 204                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 205                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 206
 207                 } /* VCD_MANAGER_METHOD_RESULT */
 208
 209                 else if (dbus_message_is_signal(msg, if_name, VCC_MANAGER_METHOD_SET_FOREGROUND)) {
 210                         SLOG(LOG_DEBUG, TAG_VCM, "===== Set foreground");
 211                         int pid = 0;
 212                         int value = 0;
 213
 214                         dbus_message_get_args(msg, &err,
 215                                 DBUS_TYPE_INT32, &pid,
 216                                 DBUS_TYPE_INT32, &value,
 217                                 DBUS_TYPE_INVALID);
 218                         if (dbus_error_is_set(&err)) {
 219                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Get arguments error (%s)", err.message);
 220                                 dbus_error_free(&err);
 221                         }
 222
 223                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< foreground changed : pid(%d) value(%s)", pid, value ? "true" : "false");
 224
 225                         __vc_mgr_cb_set_foreground(pid, (bool)value);
 226                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 227                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 228                 } /* VCC_MANAGER_METHOD_SET_FOREGROUND */
 229
 230                 else if (dbus_message_is_method_call(msg, if_name, VCD_MANAGER_METHOD_DIALOG)) {
 231                         SLOG(LOG_DEBUG, TAG_VCM, "===== Request Dialog");
 232                         int pid = -1;
 233                         char* disp_text = NULL;
 234                         char* utt_text = NULL;
 235                         int tmp_continue;
 236
 237                         dbus_message_get_args(msg, &err,
 238                                                 DBUS_TYPE_INT32, &pid,
 239                                                 DBUS_TYPE_STRING, &disp_text,
 240                                                 DBUS_TYPE_STRING, &utt_text,
 241                                                 DBUS_TYPE_INT32, &tmp_continue,
 242                                                 DBUS_TYPE_INVALID);
 243
 244                         __vc_mgr_cb_dialog(pid, disp_text, utt_text, (bool)tmp_continue);
 245
 246                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 247                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 248
 249                 } /* VCD_MANAGER_METHOD_ALL_RESULT */
 250
 251                 else if (dbus_message_is_signal(msg, if_name, VCD_MANAGER_METHOD_ERROR)) {
 252                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get Error");
 253                         int reason;
 254                         int daemon_pid;
 255                         char* err_msg;
 256
 257                         dbus_message_get_args(msg, &err,
 258                                 DBUS_TYPE_INT32, &reason,
 259                                 DBUS_TYPE_INT32, &daemon_pid,
 260                                 DBUS_TYPE_STRING, &err_msg,
 261                                 DBUS_TYPE_INVALID);
 262
 263                         if (dbus_error_is_set(&err)) {
 264                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : Get arguments error (%s)", err.message);
 265                                 dbus_error_free(&err);
 266                         } else {
 267                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr Get Error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
 268                                 __vc_mgr_cb_error(reason, daemon_pid, err_msg);
 269                         }
 270
 271                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 272                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 273                 } /* VCD_MANAGER_METHOD_ERROR */
 274
 275                 /* Authority */
 276                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_ENABLE)) {
 277                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth enable");
 278                         int pid;
 279                         int ret = 0;
 280
 281                         dbus_message_get_args(msg, &err,
 282                                 DBUS_TYPE_INT32, &pid,
 283                                 DBUS_TYPE_INVALID);
 284
 285                         if (dbus_error_is_set(&err)) {
 286                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth enable : Get arguments error (%s)", err.message);
 287                                 dbus_error_free(&err);
 288                         } else {
 289                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth enable : pid(%d)", pid);
 290                                 ret = __vc_mgr_request_auth_enable(pid);
 291                         }
 292
 293                         DBusMessage *reply = NULL;
 294                         reply = dbus_message_new_method_return(msg);
 295
 296                         if (NULL != reply) {
 297                                 dbus_message_append_args(reply,
 298                                         DBUS_TYPE_INT32, &ret,
 299                                         DBUS_TYPE_INVALID);
 300                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 301                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to send reply");
 302                                 else
 303                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth enable : ret(%d)", ret);
 304                                 dbus_connection_flush(g_m_conn_listener);
 305                                 dbus_message_unref(reply);
 306                         } else {
 307                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth enable : fail to create reply message");
 308                         }
 309
 310                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 311                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 312                 } /* VC_METHOD_AUTH_ENABLE */
 313
 314                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_DISABLE)) {
 315                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth disable");
 316                         int pid;
 317                         int ret = 0;
 318
 319                         dbus_message_get_args(msg, &err,
 320                                 DBUS_TYPE_INT32, &pid,
 321                                 DBUS_TYPE_INVALID);
 322
 323                         if (dbus_error_is_set(&err)) {
 324                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth disable : Get arguments error (%s)", err.message);
 325                                 dbus_error_free(&err);
 326                         } else {
 327                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth disable : pid(%d)", pid);
 328                                 ret = __vc_mgr_request_auth_disable(pid);
 329                         }
 330
 331                         DBusMessage *reply = NULL;
 332                         reply = dbus_message_new_method_return(msg);
 333
 334                         if (NULL != reply) {
 335                                 dbus_message_append_args(reply,
 336                                         DBUS_TYPE_INT32, &ret,
 337                                         DBUS_TYPE_INVALID);
 338                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 339                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to send reply");
 340                                 else
 341                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth disable : ret(%d)", ret);
 342                                 dbus_connection_flush(g_m_conn_listener);
 343                                 dbus_message_unref(reply);
 344                         } else {
 345                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth disable : fail to create reply message");
 346                         }
 347
 348                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 349                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 350                 } /* VC_METHOD_AUTH_DISABLE */
 351
 352                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_START)) {
 353                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth start");
 354                         int pid;
 355                         int ret = 0;
 356
 357                         dbus_message_get_args(msg, &err,
 358                                 DBUS_TYPE_INT32, &pid,
 359                                 DBUS_TYPE_INVALID);
 360
 361                         if (dbus_error_is_set(&err)) {
 362                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth start : Get arguments error (%s)", err.message);
 363                                 dbus_error_free(&err);
 364                         } else {
 365                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth start : pid(%d)", pid);
 366                                 ret = __vc_mgr_request_auth_start(pid);
 367                         }
 368
 369                         DBusMessage *reply = NULL;
 370                         reply = dbus_message_new_method_return(msg);
 371
 372                         if (NULL != reply) {
 373                                 dbus_message_append_args(reply,
 374                                         DBUS_TYPE_INT32, &ret,
 375                                         DBUS_TYPE_INVALID);
 376                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 377                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to send reply");
 378                                 else
 379                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth start : ret(%d)", ret);
 380                                 dbus_connection_flush(g_m_conn_listener);
 381                                 dbus_message_unref(reply);
 382                         } else {
 383                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth start : fail to create reply message");
 384                         }
 385
 386                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 387                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 388                 } /* VC_METHOD_AUTH_START */
 389
 390                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_STOP)) {
 391                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth stop");
 392                         int pid;
 393                         int ret = 0;
 394
 395                         dbus_message_get_args(msg, &err,
 396                                 DBUS_TYPE_INT32, &pid,
 397                                 DBUS_TYPE_INVALID);
 398
 399                         if (dbus_error_is_set(&err)) {
 400                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth stop : Get arguments error (%s)", err.message);
 401                                 dbus_error_free(&err);
 402                         } else {
 403                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth stop : pid(%d)", pid);
 404                                 ret = __vc_mgr_request_auth_stop(pid);
 405                         }
 406
 407                         DBusMessage *reply = NULL;
 408                         reply = dbus_message_new_method_return(msg);
 409
 410                         if (NULL != reply) {
 411                                 dbus_message_append_args(reply,
 412                                         DBUS_TYPE_INT32, &ret,
 413                                         DBUS_TYPE_INVALID);
 414                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 415                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to send reply");
 416                                 else
 417                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr request auth stop : ret(%d)", ret);
 418                                 dbus_connection_flush(g_m_conn_listener);
 419                                 dbus_message_unref(reply);
 420                         } else {
 421                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth stop : fail to create reply message");
 422                         }
 423
 424                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 425                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 426                 } /* VC_METHOD_AUTH_STOP */
 427
 428                 else if (dbus_message_is_method_call(msg, if_name, VC_METHOD_AUTH_CANCEL)) {
 429                         SLOG(LOG_DEBUG, TAG_VCM, "===== Get request auth cancel");
 430                         int pid;
 431                         int ret = 0;
 432
 433                         dbus_message_get_args(msg, &err,
 434                                 DBUS_TYPE_INT32, &pid,
 435                                 DBUS_TYPE_INVALID);
 436
 437                         if (dbus_error_is_set(&err)) {
 438                                 SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr request auth cancel : Get arguments error (%s)", err.message);
 439                                 dbus_error_free(&err);
 440                         } else {
 441                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr request auth cancel : pid(%d)", pid);
 442                                 ret = __vc_mgr_request_auth_cancel(pid);
 443                         }
 444
 445                         DBusMessage *reply = NULL;
 446                         reply = dbus_message_new_method_return(msg);
 447
 448                         if (NULL != reply) {
 449                                 dbus_message_append_args(reply,
 450                                         DBUS_TYPE_INT32, &ret,
 451                                         DBUS_TYPE_INVALID);
 452                                 if (!dbus_connection_send(g_m_conn_listener, reply, NULL))
 453                                         SLOG(LOG_ERROR, TAG_VCM, ">>>> vc request auth cancel : fail to send reply");
 454                                 else
 455                                         SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc request auth cancel : ret(%d)", ret);
 456                                 dbus_connection_flush(g_m_conn_listener);
 457                                 dbus_message_unref(reply);
 458                         } else {
 459                                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr request auth cancel : fail to create reply message");
 460                         }
 461
 462                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 463                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 464                 } /* VC_METHOD_AUTH_CANCEL */
 465
 466                 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 467                         SLOG(LOG_DEBUG, TAG_VCM, "===== Owner Changed");
 468                         /* remove a rule for daemon error */
 469                         DBusError err;
 470                         /* initialise the error value */
 471                         dbus_error_init(&err);
 472                         char rule_err[256] = {0, };
 473                         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);
 474                         dbus_bus_remove_match(g_m_conn_listener, rule_err, &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                         }
 481                         __vc_mgr_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
 482                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 483                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 484                 } /* NameOwnerChanged */
 485
 486                 else {
 487                         SLOG(LOG_DEBUG, TAG_VCM, "Message is NOT valid");
 488                         dbus_message_unref(msg);
 489                         break;
 490                 }
 491
 492                 /* free the message */
 493                 dbus_message_unref(msg);
 494         } /* while(1) */
 495
 496         return ECORE_CALLBACK_PASS_ON;
 497 }
 498
 499 int vc_mgr_dbus_open_connection()
 500 {
 501         if (NULL != g_m_conn_sender && NULL != g_m_conn_listener) {
 502                 SLOG(LOG_WARN, TAG_VCM, "already existed connection ");
 503                 return 0;
 504         }
 505
 506         DBusError err;
 507         int ret;
 508
 509         /* initialise the error value */
 510         dbus_error_init(&err);
 511
 512         /* connect to the DBUS system bus, and check for errors */
 513         g_m_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 514
 515         if (dbus_error_is_set(&err)) {
 516                 SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
 517                 dbus_error_free(&err);
 518         }
 519
 520         if (NULL == g_m_conn_sender) {
 521                 SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
 522                 return VC_ERROR_OPERATION_FAILED;
 523         }
 524
 525         /* connect to the DBUS system bus, and check for errors */
 526         g_m_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 527
 528         if (dbus_error_is_set(&err)) {
 529                 SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
 530                 dbus_error_free(&err);
 531         }
 532
 533         if (NULL == g_m_conn_listener) {
 534                 SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
 535                 return VC_ERROR_OPERATION_FAILED;
 536         }
 537
 538         SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", VC_MANAGER_SERVICE_NAME);
 539
 540         /* register our name on the bus, and check for errors */
 541         ret = dbus_bus_request_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 542
 543         if (dbus_error_is_set(&err)) {
 544                 SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
 545                 dbus_error_free(&err);
 546         }
 547
 548         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 549                 SLOG(LOG_ERROR, TAG_VCM, "fail dbus_bus_request_name()");
 550                 return -2;
 551         }
 552
 553         if (NULL != g_m_fd_handler) {
 554                 SLOG(LOG_WARN, TAG_VCM, "The handler already exists.");
 555                 return 0;
 556         }
 557
 558         char rule[128] = {0, };
 559         snprintf(rule, 128, "type='signal',interface='%s'", VC_MANAGER_SERVICE_INTERFACE);
 560
 561         /* add a rule for which messages we want to see */
 562         dbus_bus_add_match(g_m_conn_listener, rule, &err);
 563         dbus_connection_flush(g_m_conn_listener);
 564
 565         if (dbus_error_is_set(&err)) {
 566                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 567                 dbus_error_free(&err);
 568                 return VC_ERROR_OPERATION_FAILED;
 569         }
 570
 571         int fd = 0;
 572         if (1 != dbus_connection_get_unix_fd(g_m_conn_listener, &fd)) {
 573                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd from dbus ");
 574                 return VC_ERROR_OPERATION_FAILED;
 575         } else {
 576                 SLOG(LOG_DEBUG, TAG_VCM, "Get fd from dbus : %d", fd);
 577         }
 578
 579         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);
 580
 581         if (NULL == g_m_fd_handler) {
 582                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd handler from ecore ");
 583                 return VC_ERROR_OPERATION_FAILED;
 584         }
 585
 586         return 0;
 587 }
 588
 589 int vc_mgr_dbus_close_connection()
 590 {
 591         DBusError err;
 592         dbus_error_init(&err);
 593
 594         if (NULL != g_m_fd_handler) {
 595                 ecore_main_fd_handler_del(g_m_fd_handler);
 596                 g_m_fd_handler = NULL;
 597         }
 598
 599         int pid = getpid();
 600
 601         char service_name[64];
 602         memset(service_name, '\0', 64);
 603         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
 604
 605         dbus_bus_release_name(g_m_conn_listener, service_name, &err);
 606
 607         if (dbus_error_is_set(&err)) {
 608                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 609                 dbus_error_free(&err);
 610         }
 611
 612         dbus_connection_close(g_m_conn_sender);
 613         dbus_connection_close(g_m_conn_listener);
 614
 615         dbus_connection_unref(g_m_conn_sender);
 616         dbus_connection_unref(g_m_conn_listener);
 617
 618         g_m_conn_sender = NULL;
 619         g_m_conn_listener = NULL;
 620
 621         return 0;
 622 }
 623
 624 int vc_mgr_dbus_reconnect()
 625 {
 626         bool sender_connected = dbus_connection_get_is_connected(g_m_conn_sender);
 627         bool listener_connected = dbus_connection_get_is_connected(g_m_conn_listener);
 628
 629         SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Sender(%s) Listener(%s)",
 630                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 631
 632         if (false == sender_connected || false == listener_connected) {
 633                 vc_mgr_dbus_close_connection();
 634
 635                 if (0 != vc_mgr_dbus_open_connection()) {
 636                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to reconnect");
 637                         return -1;
 638                 }
 639
 640                 SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
 641         }
 642
 643         return 0;
 644 }
 645
 646 int vc_mgr_dbus_request_hello()
 647 {
 648         DBusMessage* msg;
 649
 650         msg = dbus_message_new_method_call(
 651                           VC_SERVER_SERVICE_NAME,
 652                           VC_SERVER_SERVICE_OBJECT_PATH,
 653                           VC_SERVER_SERVICE_INTERFACE,
 654                           VC_METHOD_HELLO);
 655
 656         if (NULL == msg) {
 657                 SLOG(LOG_ERROR, TAG_VCM, ">>>> Request vc hello : Fail to make message");
 658                 return VC_ERROR_OPERATION_FAILED;
 659         }
 660
 661         DBusError err;
 662         dbus_error_init(&err);
 663
 664         DBusMessage* result_msg = NULL;
 665         int result = 0;
 666
 667         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, 500, &err);
 668
 669         if (dbus_error_is_set(&err)) {
 670                 dbus_error_free(&err);
 671         }
 672
 673         dbus_message_unref(msg);
 674
 675         if (NULL != result_msg) {
 676                 dbus_message_unref(result_msg);
 677                 result = 0;
 678         } else {
 679                 result = VC_ERROR_TIMED_OUT;
 680         }
 681
 682         return result;
 683 }
 684
 685 static int __dbus_restore_daemon()
 686 {
 687         int ret = -1;
 688         int count = 0;
 689         while (0 != ret) {
 690                 ret = vc_mgr_dbus_request_hello();
 691                 if (0 != ret) {
 692                         if (VC_ERROR_TIMED_OUT != ret) {
 693                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 694                                 break;
 695                         } else {
 696                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry restore daemon");
 697                                 usleep(10000);
 698                                 count++;
 699                                 if (VC_RETRY_COUNT == count) {
 700                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 701                                         break;
 702                                 }
 703                         }
 704                 } else {
 705                         SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] restore daemon");
 706                 }
 707         }
 708         return ret;
 709 }
 710
 711 int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid)
 712 {
 713         DBusError err;
 714         dbus_error_init(&err);
 715
 716         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 717         if (dbus_error_is_set(&err)) {
 718                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 719                 dbus_error_free(&err);
 720         }
 721
 722         int ret;
 723         if (false == exist) {
 724                 ret = __dbus_restore_daemon();
 725                 if (VC_ERROR_NONE != ret) {
 726                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 727                         return VC_ERROR_TIMED_OUT;
 728                 }
 729                 return VC_ERROR_OPERATION_FAILED;
 730         }
 731
 732         DBusMessage* msg;
 733
 734         msg = dbus_message_new_method_call(
 735                           VC_SERVER_SERVICE_NAME,
 736                           VC_SERVER_SERVICE_OBJECT_PATH,
 737                           VC_SERVER_SERVICE_INTERFACE,
 738                           VC_MANAGER_METHOD_INITIALIZE);
 739
 740         if (NULL == msg) {
 741                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr initialize : Fail to make message ");
 742                 return VC_ERROR_OPERATION_FAILED;
 743         } else {
 744                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr initialize : pid(%d)", pid);
 745         }
 746
 747         dbus_message_append_args(msg,
 748                 DBUS_TYPE_INT32, &pid,
 749                 DBUS_TYPE_INVALID);
 750
 751         DBusMessage* result_msg;
 752         int result = VC_ERROR_OPERATION_FAILED;
 753
 754         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 755         dbus_message_unref(msg);
 756
 757         if (dbus_error_is_set(&err)) {
 758                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 759                 dbus_error_free(&err);
 760         }
 761
 762         if (NULL != result_msg) {
 763                 int tmp_service_state = 0;
 764                 int tmp_foreground = 0;
 765                 int tmp_daemon_pid = 0;
 766                 dbus_message_get_args(result_msg, &err,
 767                         DBUS_TYPE_INT32, &result,
 768                         DBUS_TYPE_INT32, &tmp_service_state,
 769                         DBUS_TYPE_INT32, &tmp_foreground,
 770                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 771                         DBUS_TYPE_INVALID);
 772
 773                 if (dbus_error_is_set(&err)) {
 774                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 775                         dbus_error_free(&err);
 776                         result = VC_ERROR_OPERATION_FAILED;
 777                 }
 778
 779                 dbus_message_unref(result_msg);
 780
 781                 if (0 == result) {
 782                         *service_state = tmp_service_state;
 783                         *foreground = tmp_foreground;
 784                         *daemon_pid = tmp_daemon_pid;
 785
 786                         /* add a rule for daemon error */
 787                         char rule_err[256] = {0, };
 788                         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);
 789                         dbus_bus_add_match(g_m_conn_listener, rule_err, &err);
 790                         dbus_connection_flush(g_m_conn_listener);
 791
 792                         if (dbus_error_is_set(&err)) {
 793                                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 794                                 dbus_error_free(&err);
 795                         }
 796
 797                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr initialize : result = %d, service state = %d, foreground = %d, daemon_pid = %d",
 798                                 result, *service_state, *foreground, *daemon_pid);
 799                 } else {
 800                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr initialize : result = %d", result);
 801                 }
 802         } else {
 803                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL ");
 804                 vc_mgr_dbus_reconnect();
 805                 result = VC_ERROR_TIMED_OUT;
 806         }
 807
 808         return result;
 809 }
 810
 811 int vc_mgr_dbus_request_finalize(int pid)
 812 {
 813         DBusError err;
 814         dbus_error_init(&err);
 815
 816         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 817         if (dbus_error_is_set(&err)) {
 818                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 819                 dbus_error_free(&err);
 820         }
 821
 822         int ret;
 823         if (false == exist) {
 824                 ret = __dbus_restore_daemon();
 825                 if (VC_ERROR_NONE != ret) {
 826                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 827                         return VC_ERROR_TIMED_OUT;
 828                 }
 829                 return VC_ERROR_OPERATION_FAILED;
 830         }
 831
 832         /* remove a rule for daemon error */
 833         char rule_err[256] = {0, };
 834         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);
 835         dbus_bus_remove_match(g_m_conn_listener, rule_err, &err);
 836         dbus_connection_flush(g_m_conn_listener);
 837
 838         if (dbus_error_is_set(&err)) {
 839                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 840                 dbus_error_free(&err);
 841                 return VC_ERROR_OPERATION_FAILED;
 842         }
 843
 844         DBusMessage* msg;
 845
 846         msg = dbus_message_new_method_call(
 847                           VC_SERVER_SERVICE_NAME,
 848                           VC_SERVER_SERVICE_OBJECT_PATH,
 849                           VC_SERVER_SERVICE_INTERFACE,
 850                           VC_MANAGER_METHOD_FINALIZE);
 851
 852         if (NULL == msg) {
 853                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr finalize : Fail to make message ");
 854                 return VC_ERROR_OPERATION_FAILED;
 855         } else {
 856                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr finalize : pid(%d)", pid);
 857         }
 858
 859         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 860
 861         DBusMessage* result_msg;
 862         int result = VC_ERROR_OPERATION_FAILED;
 863
 864         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 865         dbus_message_unref(msg);
 866
 867         if (dbus_error_is_set(&err)) {
 868                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 869                 dbus_error_free(&err);
 870         }
 871
 872         if (NULL != result_msg) {
 873                 dbus_message_get_args(result_msg, &err,
 874                                                           DBUS_TYPE_INT32, &result,
 875                                                           DBUS_TYPE_INVALID);
 876
 877                 if (dbus_error_is_set(&err)) {
 878                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 879                         dbus_error_free(&err);
 880                         result = VC_ERROR_OPERATION_FAILED;
 881                 }
 882
 883                 dbus_message_unref(result_msg);
 884
 885                 if (0 == result) {
 886                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr finalize : result = %d", result);
 887                 } else {
 888                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr finalize : result = %d", result);
 889                 }
 890         } else {
 891                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL ");
 892                 vc_mgr_dbus_reconnect();
 893                 result = VC_ERROR_TIMED_OUT;
 894         }
 895
 896         return result;
 897 }
 898
 899 int vc_mgr_dbus_request_set_command(int pid)
 900 {
 901         DBusError err;
 902         dbus_error_init(&err);
 903
 904         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 905         if (dbus_error_is_set(&err)) {
 906                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 907                 dbus_error_free(&err);
 908         }
 909
 910         int ret;
 911         if (false == exist) {
 912                 ret = __dbus_restore_daemon();
 913                 if (VC_ERROR_NONE != ret) {
 914                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 915                         return VC_ERROR_TIMED_OUT;
 916                 }
 917                 return VC_ERROR_OPERATION_FAILED;
 918         }
 919
 920         DBusMessage* msg;
 921
 922         msg = dbus_message_new_method_call(
 923                           VC_SERVER_SERVICE_NAME,
 924                           VC_SERVER_SERVICE_OBJECT_PATH,
 925                           VC_SERVER_SERVICE_INTERFACE,
 926                           VC_MANAGER_METHOD_SET_COMMAND);
 927
 928         if (NULL == msg) {
 929                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set command : Fail to make message");
 930                 return VC_ERROR_OPERATION_FAILED;
 931         } else {
 932                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set command : pid(%d)", pid);
 933         }
 934
 935         dbus_message_append_args(msg,
 936                                                          DBUS_TYPE_INT32, &pid,
 937                                                          DBUS_TYPE_INVALID);
 938
 939         DBusMessage* result_msg;
 940         int result = VC_ERROR_OPERATION_FAILED;
 941
 942         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 943         dbus_message_unref(msg);
 944
 945         if (dbus_error_is_set(&err)) {
 946                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 947                 dbus_error_free(&err);
 948         }
 949
 950         if (NULL != result_msg) {
 951                 dbus_message_get_args(result_msg, &err,
 952                                                           DBUS_TYPE_INT32, &result,
 953                                                           DBUS_TYPE_INVALID);
 954
 955                 if (dbus_error_is_set(&err)) {
 956                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
 957                         dbus_error_free(&err);
 958                         result = VC_ERROR_OPERATION_FAILED;
 959                 }
 960                 dbus_message_unref(result_msg);
 961
 962                 if (0 == result) {
 963                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set command : result = %d", result);
 964                 } else {
 965                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set command : result = %d", result);
 966                 }
 967         } else {
 968                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
 969                 vc_mgr_dbus_reconnect();
 970                 result = VC_ERROR_TIMED_OUT;
 971         }
 972
 973         return result;
 974 }
 975
 976 int vc_mgr_dbus_request_unset_command(int pid)
 977 {
 978         DBusError err;
 979         dbus_error_init(&err);
 980
 981         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 982         if (dbus_error_is_set(&err)) {
 983                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 984                 dbus_error_free(&err);
 985         }
 986
 987         int ret;
 988         if (false == exist) {
 989                 ret = __dbus_restore_daemon();
 990                 if (VC_ERROR_NONE != ret) {
 991                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 992                         return VC_ERROR_TIMED_OUT;
 993                 }
 994                 return VC_ERROR_OPERATION_FAILED;
 995         }
 996
 997         DBusMessage* msg;
 998
 999         msg = dbus_message_new_method_call(
1000                           VC_SERVER_SERVICE_NAME,
1001                           VC_SERVER_SERVICE_OBJECT_PATH,
1002                           VC_SERVER_SERVICE_INTERFACE,
1003                           VC_MANAGER_METHOD_UNSET_COMMAND);
1004
1005         if (NULL == msg) {
1006                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr unset command : Fail to make message");
1007                 return VC_ERROR_OPERATION_FAILED;
1008         } else {
1009                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr unset command : pid(%d)", pid);
1010         }
1011
1012         dbus_message_append_args(msg,
1013                                                          DBUS_TYPE_INT32, &pid,
1014                                                          DBUS_TYPE_INVALID);
1015
1016         DBusMessage* result_msg;
1017         int result = VC_ERROR_OPERATION_FAILED;
1018
1019         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1020         dbus_message_unref(msg);
1021
1022         if (dbus_error_is_set(&err)) {
1023                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1024                 dbus_error_free(&err);
1025         }
1026
1027         if (NULL != result_msg) {
1028                 dbus_message_get_args(result_msg, &err,
1029                                                           DBUS_TYPE_INT32, &result,
1030                                                           DBUS_TYPE_INVALID);
1031
1032                 if (dbus_error_is_set(&err)) {
1033                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1034                         dbus_error_free(&err);
1035                         result = VC_ERROR_OPERATION_FAILED;
1036                 }
1037                 dbus_message_unref(result_msg);
1038
1039                 if (0 == result) {
1040                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr unset command : result = %d", result);
1041                 } else {
1042                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr unset command : result = %d", result);
1043                 }
1044         } else {
1045                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
1046                 vc_mgr_dbus_reconnect();
1047                 result = VC_ERROR_TIMED_OUT;
1048         }
1049
1050         return result;
1051 }
1052
1053 int vc_mgr_dbus_request_demandable_client(int pid)
1054 {
1055         DBusError err;
1056         dbus_error_init(&err);
1057
1058         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1059         if (dbus_error_is_set(&err)) {
1060                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1061                 dbus_error_free(&err);
1062         }
1063
1064         int ret;
1065         if (false == exist) {
1066                 ret = __dbus_restore_daemon();
1067                 if (VC_ERROR_NONE != ret) {
1068                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1069                         return VC_ERROR_TIMED_OUT;
1070                 }
1071                 return VC_ERROR_OPERATION_FAILED;
1072         }
1073
1074         DBusMessage* msg;
1075
1076         msg = dbus_message_new_method_call(
1077                           VC_SERVER_SERVICE_NAME,
1078                           VC_SERVER_SERVICE_OBJECT_PATH,
1079                           VC_SERVER_SERVICE_INTERFACE,
1080                           VC_MANAGER_METHOD_SET_DEMANDABLE);
1081
1082         if (NULL == msg) {
1083                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set demandable client : Fail to make message");
1084                 return VC_ERROR_OPERATION_FAILED;
1085         } else {
1086                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set demandable client : pid(%d)", pid);
1087         }
1088
1089         dbus_message_append_args(msg,
1090                                                          DBUS_TYPE_INT32, &pid,
1091                                                          DBUS_TYPE_INVALID);
1092
1093         DBusMessage* result_msg;
1094         int result = VC_ERROR_OPERATION_FAILED;
1095
1096         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1097         dbus_message_unref(msg);
1098
1099         if (dbus_error_is_set(&err)) {
1100                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1101                 dbus_error_free(&err);
1102         }
1103
1104         if (NULL != result_msg) {
1105                 dbus_message_get_args(result_msg, &err,
1106                                                           DBUS_TYPE_INT32, &result,
1107                                                           DBUS_TYPE_INVALID);
1108
1109                 if (dbus_error_is_set(&err)) {
1110                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1111                         dbus_error_free(&err);
1112                         result = VC_ERROR_OPERATION_FAILED;
1113                 }
1114                 dbus_message_unref(result_msg);
1115
1116                 if (0 == result) {
1117                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set demandable client : result = %d", result);
1118                 } else {
1119                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set demandable client : result = %d", result);
1120                 }
1121         } else {
1122                 SLOG(LOG_ERROR, TAG_VCM, "<<<< Result message is NULL");
1123                 vc_mgr_dbus_reconnect();
1124                 result = VC_ERROR_TIMED_OUT;
1125         }
1126
1127         return result;
1128 }
1129
1130 int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type)
1131 {
1132         DBusError err;
1133         dbus_error_init(&err);
1134
1135         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1136         if (dbus_error_is_set(&err)) {
1137                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1138                 dbus_error_free(&err);
1139         }
1140
1141         int ret;
1142         if (false == exist) {
1143                 ret = __dbus_restore_daemon();
1144                 if (VC_ERROR_NONE != ret) {
1145                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1146                         return VC_ERROR_TIMED_OUT;
1147                 }
1148                 return VC_ERROR_OPERATION_FAILED;
1149         }
1150
1151         DBusMessage* msg;
1152
1153         /* create a signal & check for errors */
1154         msg = dbus_message_new_method_call(
1155                           VC_SERVER_SERVICE_NAME,
1156                           VC_SERVER_SERVICE_OBJECT_PATH,
1157                           VC_SERVER_SERVICE_INTERFACE,
1158                           VC_MANAGER_METHOD_SET_AUDIO_TYPE);
1159
1160         if (NULL == msg) {
1161                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set audio type : Fail to make message ");
1162                 return VC_ERROR_OPERATION_FAILED;
1163         } else {
1164                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
1165         }
1166
1167         dbus_message_append_args(msg,
1168                                                          DBUS_TYPE_INT32, &pid,
1169                                                          DBUS_TYPE_STRING, &(audio_type),
1170                                                          DBUS_TYPE_INVALID);
1171
1172         DBusMessage* result_msg;
1173         int result = VC_ERROR_OPERATION_FAILED;
1174
1175         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1176         dbus_message_unref(msg);
1177
1178         if (dbus_error_is_set(&err)) {
1179                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1180                 dbus_error_free(&err);
1181         }
1182
1183         if (NULL != result_msg) {
1184                 dbus_message_get_args(result_msg, &err,
1185                                                           DBUS_TYPE_INT32, &result,
1186                                                           DBUS_TYPE_INVALID);
1187
1188                 if (dbus_error_is_set(&err)) {
1189                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1190                         dbus_error_free(&err);
1191                         result = VC_ERROR_OPERATION_FAILED;
1192                 }
1193                 dbus_message_unref(result_msg);
1194
1195                 if (0 == result) {
1196                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set audio type : result = %d", result);
1197                 } else {
1198                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set audio type : result = %d", result);
1199                 }
1200         } else {
1201                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1202                 vc_mgr_dbus_reconnect();
1203                 result = VC_ERROR_TIMED_OUT;
1204         }
1205
1206         return result;
1207 }
1208
1209 int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type)
1210 {
1211         DBusError err;
1212         dbus_error_init(&err);
1213
1214         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1215         if (dbus_error_is_set(&err)) {
1216                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1217                 dbus_error_free(&err);
1218         }
1219
1220         int ret;
1221         if (false == exist) {
1222                 ret = __dbus_restore_daemon();
1223                 if (VC_ERROR_NONE != ret) {
1224                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1225                         return VC_ERROR_TIMED_OUT;
1226                 }
1227                 return VC_ERROR_OPERATION_FAILED;
1228         }
1229
1230         DBusMessage* msg;
1231
1232         /* create a signal & check for errors */
1233         msg = dbus_message_new_method_call(
1234                           VC_SERVER_SERVICE_NAME,
1235                           VC_SERVER_SERVICE_OBJECT_PATH,
1236                           VC_SERVER_SERVICE_INTERFACE,
1237                           VC_MANAGER_METHOD_GET_AUDIO_TYPE);
1238
1239         if (NULL == msg) {
1240                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get audio type : Fail to make message ");
1241                 return VC_ERROR_OPERATION_FAILED;
1242         } else {
1243                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get audio type : pid(%d)", pid);
1244         }
1245
1246         dbus_message_append_args(msg,
1247                                                          DBUS_TYPE_INT32, &pid,
1248                                                          DBUS_TYPE_INVALID);
1249
1250
1251         DBusMessage* result_msg;
1252         int result = VC_ERROR_OPERATION_FAILED;
1253         char* temp = NULL;
1254
1255         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1256         dbus_message_unref(msg);
1257
1258         if (dbus_error_is_set(&err)) {
1259                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1260                 dbus_error_free(&err);
1261         }
1262
1263         if (NULL != result_msg) {
1264                 dbus_message_get_args(result_msg, &err,
1265                                                           DBUS_TYPE_INT32, &result,
1266                                                           DBUS_TYPE_STRING, &temp,
1267                                                           DBUS_TYPE_INVALID);
1268
1269                 if (dbus_error_is_set(&err)) {
1270                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1271                         dbus_error_free(&err);
1272                         result = VC_ERROR_OPERATION_FAILED;
1273                 }
1274                 dbus_message_unref(result_msg);
1275
1276                 if (0 == result) {
1277                         if (NULL != audio_type && NULL != temp) {
1278                                 *audio_type = strdup(temp);
1279                         }
1280                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get audio type : result = %d audio type = %s", result, temp);
1281                 } else {
1282                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get audio type : result = %d", result);
1283                 }
1284         } else {
1285                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1286                 vc_mgr_dbus_reconnect();
1287                 result = VC_ERROR_TIMED_OUT;
1288         }
1289
1290         return result;
1291 }
1292
1293 int vc_mgr_dbus_request_set_private_data(int pid, const char* key, const char* data)
1294 {
1295         DBusMessage* msg;
1296
1297         /* create a signal & check for errors */
1298         msg = dbus_message_new_method_call(
1299                           VC_SERVER_SERVICE_NAME,
1300                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1301                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1302                           VC_MANAGER_METHOD_SET_PRIVATE_DATA);  /* name of the signal */
1303
1304         if (NULL == msg) {
1305                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc set private data : Fail to make message ");
1306                 return VC_ERROR_OPERATION_FAILED;
1307         } else {
1308                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc set private data : pid(%d), data(%s)", pid, data);
1309         }
1310
1311         dbus_message_append_args(msg,
1312                                 DBUS_TYPE_INT32, &pid,
1313                                 DBUS_TYPE_STRING, &key,
1314                                 DBUS_TYPE_STRING, &data,
1315                                 DBUS_TYPE_INVALID);
1316
1317         DBusError err;
1318         dbus_error_init(&err);
1319
1320         DBusMessage* result_msg;
1321         int result = VC_ERROR_OPERATION_FAILED;
1322
1323         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1324         dbus_message_unref(msg);
1325
1326         if (dbus_error_is_set(&err)) {
1327                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1328                 dbus_error_free(&err);
1329         }
1330
1331         if (NULL != result_msg) {
1332                 dbus_message_get_args(result_msg, &err,
1333                                         DBUS_TYPE_INT32, &result,
1334                                         DBUS_TYPE_INVALID);
1335
1336                 if (dbus_error_is_set(&err)) {
1337                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1338                         dbus_error_free(&err);
1339                         result = VC_ERROR_OPERATION_FAILED;
1340                 }
1341                 dbus_message_unref(result_msg);
1342
1343                 if (0 == result) {
1344                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc set private data : result = %d", result);
1345                 } else {
1346                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc set private data : result = %d", result);
1347                 }
1348         } else {
1349                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1350                 vc_mgr_dbus_reconnect();
1351                 result = VC_ERROR_TIMED_OUT;
1352         }
1353
1354         return result;
1355 }
1356
1357 int vc_mgr_dbus_request_get_private_data(int pid, const char* key, char** data)
1358 {
1359         DBusMessage* msg;
1360
1361         /* create a signal & check for errors */
1362         msg = dbus_message_new_method_call(
1363                           VC_SERVER_SERVICE_NAME,
1364                           VC_SERVER_SERVICE_OBJECT_PATH,
1365                           VC_SERVER_SERVICE_INTERFACE,
1366                           VC_MANAGER_METHOD_GET_PRIVATE_DATA);
1367
1368         if (NULL == msg) {
1369                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr get private data : Fail to make message ");
1370                 return VC_ERROR_OPERATION_FAILED;
1371         } else {
1372                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr get private data : pid(%d), key(%s)", pid, key);
1373         }
1374
1375         dbus_message_append_args(msg,
1376                                 DBUS_TYPE_INT32, &pid,
1377                                 DBUS_TYPE_STRING, &key,
1378                                 DBUS_TYPE_INVALID);
1379
1380         DBusError err;
1381         dbus_error_init(&err);
1382
1383         DBusMessage* result_msg;
1384         int result = VC_ERROR_OPERATION_FAILED;
1385         char* temp = NULL;
1386
1387         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1388         dbus_message_unref(msg);
1389
1390         if (dbus_error_is_set(&err)) {
1391                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1392                 dbus_error_free(&err);
1393         }
1394
1395         if (NULL != result_msg) {
1396                 dbus_message_get_args(result_msg, &err,
1397                                         DBUS_TYPE_INT32, &result,
1398                                         DBUS_TYPE_STRING, &temp,
1399                                         DBUS_TYPE_INVALID);
1400
1401                 if (dbus_error_is_set(&err)) {
1402                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1403                         dbus_error_free(&err);
1404                         result = VC_ERROR_OPERATION_FAILED;
1405                 }
1406                 dbus_message_unref(result_msg);
1407
1408                 if (0 == result) {
1409                         if (NULL != data && NULL != temp) {
1410                                 *data = strdup(temp);
1411
1412                                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr get private data : result = %d private data = %s", result, *data);
1413                         }
1414                 } else {
1415                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr get private data : result = %d", result);
1416                 }
1417         } else {
1418                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1419                 vc_mgr_dbus_reconnect();
1420                 result = VC_ERROR_TIMED_OUT;
1421         }
1422
1423         return result;
1424 }
1425
1426 int vc_mgr_dbus_request_set_client_info(int pid)
1427 {
1428         DBusError err;
1429         dbus_error_init(&err);
1430
1431         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1432         if (dbus_error_is_set(&err)) {
1433                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1434                 dbus_error_free(&err);
1435         }
1436
1437         int ret;
1438         if (false == exist) {
1439                 ret = __dbus_restore_daemon();
1440                 if (VC_ERROR_NONE != ret) {
1441                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1442                         return VC_ERROR_TIMED_OUT;
1443                 }
1444                 return VC_ERROR_OPERATION_FAILED;
1445         }
1446
1447         DBusMessage* msg;
1448
1449         /* create a signal & check for errors */
1450         msg = dbus_message_new_method_call(
1451                           VC_SERVER_SERVICE_NAME,
1452                           VC_SERVER_SERVICE_OBJECT_PATH,
1453                           VC_SERVER_SERVICE_INTERFACE,
1454                           VC_MANAGER_METHOD_SET_CLIENT_INFO);
1455
1456         if (NULL == msg) {
1457                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr set client info : Fail to make message ");
1458                 return VC_ERROR_OPERATION_FAILED;
1459         } else {
1460                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr set client info : pid(%d)", pid);
1461         }
1462
1463         dbus_message_append_args(msg,
1464                                                          DBUS_TYPE_INT32, &pid,
1465                                                          DBUS_TYPE_INVALID);
1466
1467         DBusMessage* result_msg;
1468         int result = VC_ERROR_OPERATION_FAILED;
1469
1470         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1471         dbus_message_unref(msg);
1472
1473         if (dbus_error_is_set(&err)) {
1474                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1475                 dbus_error_free(&err);
1476         }
1477
1478         if (NULL != result_msg) {
1479                 dbus_message_get_args(result_msg, &err,
1480                                                           DBUS_TYPE_INT32, &result,
1481                                                           DBUS_TYPE_INVALID);
1482
1483                 if (dbus_error_is_set(&err)) {
1484                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1485                         dbus_error_free(&err);
1486                         result = VC_ERROR_OPERATION_FAILED;
1487                 }
1488                 dbus_message_unref(result_msg);
1489
1490                 if (0 == result) {
1491                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr set client info : result = %d", result);
1492                 } else {
1493                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr set client info : result = %d", result);
1494                 }
1495         } else {
1496                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1497                 vc_mgr_dbus_reconnect();
1498                 result = VC_ERROR_TIMED_OUT;
1499         }
1500
1501         return result;
1502 }
1503
1504 int vc_mgr_dbus_request_set_domain(int pid, const char* domain)
1505 {
1506         DBusMessage* msg;
1507
1508         /* create a signal & check for errors */
1509         msg = dbus_message_new_method_call(
1510                           VC_SERVER_SERVICE_NAME,
1511                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1512                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1513                           VC_MANAGER_METHOD_SET_DOMAIN);        /* name of the signal */
1514
1515         if (NULL == msg) {
1516                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc set domain : Fail to make message ");
1517                 return VC_ERROR_OPERATION_FAILED;
1518         } else {
1519                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc set domain : pid(%d), domain(%s)", pid, domain);
1520         }
1521
1522         dbus_message_append_args(msg,
1523                                 DBUS_TYPE_INT32, &pid,
1524                                 DBUS_TYPE_STRING, &domain,
1525                                 DBUS_TYPE_INVALID);
1526
1527         DBusError err;
1528         dbus_error_init(&err);
1529
1530         DBusMessage* result_msg;
1531         int result = VC_ERROR_OPERATION_FAILED;
1532
1533         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1534         dbus_message_unref(msg);
1535
1536         if (dbus_error_is_set(&err)) {
1537                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1538                 dbus_error_free(&err);
1539         }
1540
1541         if (NULL != result_msg) {
1542                 dbus_message_get_args(result_msg, &err,
1543                                         DBUS_TYPE_INT32, &result,
1544                                         DBUS_TYPE_INVALID);
1545
1546                 if (dbus_error_is_set(&err)) {
1547                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1548                         dbus_error_free(&err);
1549                         result = VC_ERROR_OPERATION_FAILED;
1550                 }
1551                 dbus_message_unref(result_msg);
1552
1553                 if (0 == result) {
1554                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc set domain : result = %d", result);
1555                 } else {
1556                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc set domain : result = %d", result);
1557                 }
1558         } else {
1559                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1560                 vc_mgr_dbus_reconnect();
1561                 result = VC_ERROR_TIMED_OUT;
1562         }
1563
1564         return result;
1565 }
1566
1567 int vc_mgr_dbus_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
1568 {
1569         DBusMessage* msg;
1570
1571         /* create a signal & check for errors */
1572         msg = dbus_message_new_method_call(
1573                           VC_SERVER_SERVICE_NAME,
1574                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1575                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1576                           VC_MANAGER_METHOD_DO_ACTION); /* name of the signal */
1577
1578         if (NULL == msg) {
1579                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc set domain : Fail to make message ");
1580                 return VC_ERROR_OPERATION_FAILED;
1581         } else {
1582                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc set domain : pid(%d), type(%d), send_event(%s)", pid, type, send_event);
1583         }
1584
1585         dbus_message_append_args(msg,
1586                                 DBUS_TYPE_INT32, &pid,
1587                                 DBUS_TYPE_INT32, &type,
1588                                 DBUS_TYPE_STRING, &send_event,
1589                                 DBUS_TYPE_INVALID);
1590
1591         dbus_message_set_no_reply(msg, TRUE);
1592
1593         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
1594                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
1595                 return -1;
1596         } else {
1597                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
1598                 dbus_connection_flush(g_m_conn_sender);
1599         }
1600
1601         return 0;
1602 }
1603
1604 int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
1605 {
1606         DBusError err;
1607         dbus_error_init(&err);
1608
1609         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1610         if (dbus_error_is_set(&err)) {
1611                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1612                 dbus_error_free(&err);
1613         }
1614
1615         int ret;
1616         if (false == exist) {
1617                 ret = __dbus_restore_daemon();
1618                 if (VC_ERROR_NONE != ret) {
1619                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1620                         return VC_ERROR_TIMED_OUT;
1621                 }
1622                 return VC_ERROR_OPERATION_FAILED;
1623         }
1624
1625         DBusMessage* msg;
1626
1627         /* create a signal & check for errors */
1628         msg = dbus_message_new_method_call(
1629                           VC_SERVER_SERVICE_NAME,
1630                           VC_SERVER_SERVICE_OBJECT_PATH,
1631                           VC_SERVER_SERVICE_INTERFACE,
1632                           VC_MANAGER_METHOD_START);
1633
1634         if (NULL == msg) {
1635                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr start : Fail to make message ");
1636                 return VC_ERROR_OPERATION_FAILED;
1637         } else {
1638                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
1639                          pid, recognition_mode, exclusive_command_option, start_by_client);
1640         }
1641
1642         int exclusive = (int)exclusive_command_option;
1643         int by = (int)start_by_client;
1644
1645         dbus_message_append_args(msg,
1646                                                          DBUS_TYPE_INT32, &pid,
1647                                                          DBUS_TYPE_INT32, &(recognition_mode),
1648                                                          DBUS_TYPE_INT32, &(exclusive),
1649                                                          DBUS_TYPE_INT32, &(by),
1650                                                          DBUS_TYPE_INVALID);
1651
1652         DBusMessage* result_msg;
1653         int result = VC_ERROR_OPERATION_FAILED;
1654
1655         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1656         dbus_message_unref(msg);
1657
1658         if (dbus_error_is_set(&err)) {
1659                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1660                 dbus_error_free(&err);
1661         }
1662
1663         if (NULL != result_msg) {
1664                 dbus_message_get_args(result_msg, &err,
1665                                                           DBUS_TYPE_INT32, &result,
1666                                                           DBUS_TYPE_INVALID);
1667
1668                 if (dbus_error_is_set(&err)) {
1669                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1670                         dbus_error_free(&err);
1671                         result = VC_ERROR_OPERATION_FAILED;
1672                 }
1673                 dbus_message_unref(result_msg);
1674
1675                 if (0 == result) {
1676                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr start : result = %d", result);
1677                 } else {
1678                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr start : result = %d", result);
1679                 }
1680         } else {
1681                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1682                 vc_mgr_dbus_reconnect();
1683                 result = VC_ERROR_TIMED_OUT;
1684         }
1685
1686         return result;
1687 }
1688
1689 int vc_mgr_dbus_request_stop(int pid)
1690 {
1691         DBusError err;
1692         dbus_error_init(&err);
1693
1694         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1695         if (dbus_error_is_set(&err)) {
1696                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1697                 dbus_error_free(&err);
1698         }
1699
1700         int ret;
1701         if (false == exist) {
1702                 ret = __dbus_restore_daemon();
1703                 if (VC_ERROR_NONE != ret) {
1704                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1705                         return VC_ERROR_TIMED_OUT;
1706                 }
1707                 return VC_ERROR_OPERATION_FAILED;
1708         }
1709
1710         DBusMessage* msg;
1711
1712         /* create a signal & check for errors */
1713         msg = dbus_message_new_method_call(
1714                           VC_SERVER_SERVICE_NAME,
1715                           VC_SERVER_SERVICE_OBJECT_PATH,
1716                           VC_SERVER_SERVICE_INTERFACE,
1717                           VC_MANAGER_METHOD_STOP);
1718
1719         if (NULL == msg) {
1720                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc mgr stop : Fail to make message ");
1721                 return VC_ERROR_OPERATION_FAILED;
1722         } else {
1723                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc mgr stop : pid(%d)", pid);
1724         }
1725
1726         dbus_message_append_args(msg,
1727                                                          DBUS_TYPE_INT32, &pid,
1728                                                          DBUS_TYPE_INVALID);
1729
1730         DBusMessage* result_msg;
1731         int result = VC_ERROR_OPERATION_FAILED;
1732
1733         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1734         dbus_message_unref(msg);
1735
1736         if (dbus_error_is_set(&err)) {
1737                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1738                 dbus_error_free(&err);
1739         }
1740
1741         if (NULL != result_msg) {
1742                 dbus_message_get_args(result_msg, &err,
1743                                                           DBUS_TYPE_INT32, &result,
1744                                                           DBUS_TYPE_INVALID);
1745
1746                 if (dbus_error_is_set(&err)) {
1747                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1748                         dbus_error_free(&err);
1749                         result = VC_ERROR_OPERATION_FAILED;
1750                 }
1751                 dbus_message_unref(result_msg);
1752
1753                 if (0 == result) {
1754                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc mgr stop : result = %d", result);
1755                 } else {
1756                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc mgr stop : result = %d", result);
1757                 }
1758         } else {
1759                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1760                 vc_mgr_dbus_reconnect();
1761                 result = VC_ERROR_TIMED_OUT;
1762         }
1763
1764         return result;
1765 }
1766
1767 int vc_mgr_dbus_request_cancel(int pid)
1768 {
1769         DBusError err;
1770         dbus_error_init(&err);
1771
1772         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1773         if (dbus_error_is_set(&err)) {
1774                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1775                 dbus_error_free(&err);
1776         }
1777
1778         int ret;
1779         if (false == exist) {
1780                 ret = __dbus_restore_daemon();
1781                 if (VC_ERROR_NONE != ret) {
1782                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1783                         return VC_ERROR_TIMED_OUT;
1784                 }
1785                 return VC_ERROR_OPERATION_FAILED;
1786         }
1787
1788         DBusMessage* msg;
1789
1790         /* create a signal & check for errors */
1791         msg = dbus_message_new_method_call(
1792                           VC_SERVER_SERVICE_NAME,
1793                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1794                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1795                           VC_MANAGER_METHOD_CANCEL);    /* name of the signal */
1796
1797         if (NULL == msg) {
1798                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc cancel : Fail to make message ");
1799                 return VC_ERROR_OPERATION_FAILED;
1800         } else {
1801                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc cancel : pid(%d)", pid);
1802         }
1803
1804         dbus_message_append_args(msg,
1805                                                          DBUS_TYPE_INT32, &pid,
1806                                                          DBUS_TYPE_INVALID);
1807
1808         DBusMessage* result_msg;
1809         int result = VC_ERROR_OPERATION_FAILED;
1810
1811         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1812         dbus_message_unref(msg);
1813
1814         if (dbus_error_is_set(&err)) {
1815                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1816                 dbus_error_free(&err);
1817         }
1818
1819         if (NULL != result_msg) {
1820                 dbus_message_get_args(result_msg, &err,
1821                                                           DBUS_TYPE_INT32, &result,
1822                                                           DBUS_TYPE_INVALID);
1823
1824                 if (dbus_error_is_set(&err)) {
1825                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1826                         dbus_error_free(&err);
1827                         result = VC_ERROR_OPERATION_FAILED;
1828                 }
1829                 dbus_message_unref(result_msg);
1830
1831                 if (0 == result) {
1832                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc cancel : result = %d", result);
1833                 } else {
1834                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc cancel : result = %d", result);
1835                 }
1836         } else {
1837                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1838                 vc_mgr_dbus_reconnect();
1839                 result = VC_ERROR_TIMED_OUT;
1840         }
1841
1842         return result;
1843 }
1844
1845 int vc_mgr_dbus_request_enable_command_type(int pid, int cmd_type)
1846 {
1847         DBusError err;
1848         dbus_error_init(&err);
1849
1850         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1851         if (dbus_error_is_set(&err)) {
1852                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1853                 dbus_error_free(&err);
1854         }
1855
1856         int ret;
1857         if (false == exist) {
1858                 ret = __dbus_restore_daemon();
1859                 if (VC_ERROR_NONE != ret) {
1860                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1861                         return VC_ERROR_TIMED_OUT;
1862                 }
1863                 return VC_ERROR_OPERATION_FAILED;
1864         }
1865
1866         DBusMessage* msg;
1867
1868         /* create a signal & check for errors */
1869         msg = dbus_message_new_method_call(
1870                           VC_SERVER_SERVICE_NAME,
1871                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1872                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1873                           VC_MANAGER_METHOD_ENABLE_COMMAND_TYPE);       /* name of the signal */
1874
1875         if (NULL == msg) {
1876                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc enable command type : Fail to make message ");
1877                 return VC_ERROR_OPERATION_FAILED;
1878         } else {
1879                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc enable command type : pid(%d) type(%d)", pid, cmd_type);
1880         }
1881
1882         dbus_message_append_args(msg,
1883                                  DBUS_TYPE_INT32, &pid,
1884                                  DBUS_TYPE_INT32, &cmd_type,
1885                                  DBUS_TYPE_INVALID);
1886
1887         DBusMessage* result_msg;
1888         int result = VC_ERROR_OPERATION_FAILED;
1889
1890         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1891         dbus_message_unref(msg);
1892
1893         if (dbus_error_is_set(&err)) {
1894                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1895                 dbus_error_free(&err);
1896         }
1897
1898         if (NULL != result_msg) {
1899                 dbus_message_get_args(result_msg, &err,
1900                                           DBUS_TYPE_INT32, &result,
1901                                           DBUS_TYPE_INVALID);
1902
1903                 if (dbus_error_is_set(&err)) {
1904                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1905                         dbus_error_free(&err);
1906                         result = VC_ERROR_OPERATION_FAILED;
1907                 }
1908                 dbus_message_unref(result_msg);
1909
1910                 if (0 == result) {
1911                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc enable command type : result = %d", result);
1912                 } else {
1913                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc enable command type : result = %d", result);
1914                 }
1915         } else {
1916                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1917                 vc_mgr_dbus_reconnect();
1918                 result = VC_ERROR_TIMED_OUT;
1919         }
1920
1921         return result;
1922 }
1923
1924 int vc_mgr_dbus_request_disable_command_type(int pid, int cmd_type)
1925 {
1926         DBusError err;
1927         dbus_error_init(&err);
1928
1929         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1930         if (dbus_error_is_set(&err)) {
1931                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1932                 dbus_error_free(&err);
1933         }
1934
1935         int ret;
1936         if (false == exist) {
1937                 ret = __dbus_restore_daemon();
1938                 if (VC_ERROR_NONE != ret) {
1939                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1940                         return VC_ERROR_TIMED_OUT;
1941                 }
1942                 return VC_ERROR_OPERATION_FAILED;
1943         }
1944
1945         DBusMessage* msg;
1946
1947         /* create a signal & check for errors */
1948         msg = dbus_message_new_method_call(
1949                           VC_SERVER_SERVICE_NAME,
1950                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1951                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1952                           VC_MANAGER_METHOD_DISABLE_COMMAND_TYPE);      /* name of the signal */
1953
1954         if (NULL == msg) {
1955                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc disable command type : Fail to make message ");
1956                 return VC_ERROR_OPERATION_FAILED;
1957         } else {
1958                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc disable command type : pid(%d) type(%d)", pid, cmd_type);
1959         }
1960
1961         dbus_message_append_args(msg,
1962                                  DBUS_TYPE_INT32, &pid,
1963                                  DBUS_TYPE_INT32, &cmd_type,
1964                                  DBUS_TYPE_INVALID);
1965
1966         DBusMessage* result_msg;
1967         int result = VC_ERROR_OPERATION_FAILED;
1968
1969         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1970         dbus_message_unref(msg);
1971
1972         if (dbus_error_is_set(&err)) {
1973                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1974                 dbus_error_free(&err);
1975         }
1976
1977         if (NULL != result_msg) {
1978                 dbus_message_get_args(result_msg, &err,
1979                                           DBUS_TYPE_INT32, &result,
1980                                           DBUS_TYPE_INVALID);
1981
1982                 if (dbus_error_is_set(&err)) {
1983                         SLOG(LOG_ERROR, TAG_VCM, "<<<< Get arguments error (%s)", err.message);
1984                         dbus_error_free(&err);
1985                         result = VC_ERROR_OPERATION_FAILED;
1986                 }
1987                 dbus_message_unref(result_msg);
1988
1989                 if (0 == result) {
1990                         SLOG(LOG_DEBUG, TAG_VCM, "<<<< vc disable command type : result = %d", result);
1991                 } else {
1992                         SLOG(LOG_ERROR, TAG_VCM, "<<<< vc disable command type : result = %d", result);
1993                 }
1994         } else {
1995                 SLOG(LOG_DEBUG, TAG_VCM, "<<<< Result Message is NULL");
1996                 vc_mgr_dbus_reconnect();
1997                 result = VC_ERROR_TIMED_OUT;
1998         }
1999
2000         return result;
2001 }
2002
2003 static DBusMessage* __get_message(int pid, const char* method, int type)
2004 {
2005         char service_name[64];
2006         char object_path[64];
2007         char target_if_name[128];
2008
2009         memset(service_name, '\0', 64);
2010         memset(object_path, '\0', 64);
2011         memset(target_if_name, '\0', 128);
2012
2013         if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
2014                 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
2015                 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
2016                 snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
2017         } else if (VC_COMMAND_TYPE_WIDGET == type) {
2018                 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
2019                 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
2020                 snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
2021         } else {
2022                 return NULL;
2023         }
2024
2025         SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name);
2026
2027         return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
2028 }
2029
2030 int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id)
2031 {
2032         DBusMessage* msg = NULL;
2033
2034         switch (cmd_type) {
2035         case VC_COMMAND_TYPE_FOREGROUND:
2036         case VC_COMMAND_TYPE_BACKGROUND:
2037                 msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type);
2038                 break;
2039         case VC_COMMAND_TYPE_WIDGET:
2040                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, cmd_type);
2041                 break;
2042         default:
2043                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
2044                 return -1;
2045         }
2046
2047         if (NULL == msg)
2048                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Message is NULL");
2049
2050         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_id, DBUS_TYPE_INVALID);
2051
2052         dbus_message_set_no_reply(msg, TRUE);
2053
2054         /* send the message and flush the connection */
2055         if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
2056                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
2057         } else {
2058                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Success to send result");
2059
2060                 dbus_connection_flush(g_m_conn_sender);
2061         }
2062
2063         dbus_message_unref(msg);
2064
2065         return 0;
2066 }
2067
2068 int vc_mgr_dbus_send_result_selection(int pid)
2069 {
2070         DBusMessage* msg;
2071
2072         /* create a signal & check for errors */
2073         msg = dbus_message_new_method_call(
2074                           VC_SERVER_SERVICE_NAME,
2075                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
2076                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
2077                           VC_MANAGER_METHOD_RESULT_SELECTION);  /* name of the signal */
2078
2079         if (NULL == msg) {
2080                 SLOG(LOG_ERROR, TAG_VCM, ">>>> vc result selection : Fail to make message ");
2081                 return VC_ERROR_OPERATION_FAILED;
2082         } else {
2083                 SLOG(LOG_DEBUG, TAG_VCM, ">>>> vc result selection : pid(%d)", pid);
2084         }
2085
2086         dbus_message_append_args(msg,
2087                                                          DBUS_TYPE_INT32, &pid,
2088                                                          DBUS_TYPE_INVALID);
2089
2090         dbus_message_set_no_reply(msg, TRUE);
2091
2092         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
2093                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
2094                 return -1;
2095         } else {
2096                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
2097                 dbus_connection_flush(g_m_conn_sender);
2098         }
2099
2100         return 0;
2101 }