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