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_method_call(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         dbus_connection_set_exit_on_disconnect(g_m_conn_sender, false);
 634
 635         /* connect to the DBUS system bus, and check for errors */
 636         g_m_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 637
 638         if (dbus_error_is_set(&err)) {
 639                 SLOG(LOG_ERROR, TAG_VCM, "Dbus Connection Error (%s)", err.message);
 640                 dbus_error_free(&err);
 641         }
 642
 643         if (NULL == g_m_conn_listener) {
 644                 SLOG(LOG_ERROR, TAG_VCM, "Fail to get dbus connection ");
 645                 __vc_mgr_dbus_connection_free();
 646                 return VC_ERROR_OPERATION_FAILED;
 647         }
 648
 649         dbus_connection_set_exit_on_disconnect(g_m_conn_listener, false);
 650
 651         SLOG(LOG_DEBUG, TAG_VCM, "service name is %s", VC_MANAGER_SERVICE_NAME);
 652
 653         /* register our name on the bus, and check for errors */
 654         ret = dbus_bus_request_name(g_m_conn_listener, VC_MANAGER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 655
 656         if (dbus_error_is_set(&err)) {
 657                 SLOG(LOG_ERROR, TAG_VCM, "Name Error (%s)", err.message);
 658                 dbus_error_free(&err);
 659         }
 660
 661         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 662                 SLOG(LOG_ERROR, TAG_VCM, "fail dbus_bus_request_name()");
 663                 __vc_mgr_dbus_connection_free();
 664                 return -2;
 665         }
 666
 667         if (NULL != g_m_fd_handler) {
 668                 SLOG(LOG_WARN, TAG_VCM, "The handler already exists.");
 669                 __vc_mgr_dbus_connection_free();
 670                 return 0;
 671         }
 672
 673         char rule[128] = {0, };
 674         snprintf(rule, 128, "type='signal',interface='%s'", VC_MANAGER_SERVICE_INTERFACE);
 675
 676         /* add a rule for which messages we want to see */
 677         dbus_bus_add_match(g_m_conn_listener, rule, &err);
 678         dbus_connection_flush(g_m_conn_listener);
 679
 680         if (dbus_error_is_set(&err)) {
 681                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 682                 dbus_error_free(&err);
 683                 __vc_mgr_dbus_connection_free();
 684                 return VC_ERROR_OPERATION_FAILED;
 685         }
 686
 687         int fd = 0;
 688         if (1 != dbus_connection_get_unix_fd(g_m_conn_listener, &fd)) {
 689                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd from dbus ");
 690                 __vc_mgr_dbus_connection_free();
 691                 return VC_ERROR_OPERATION_FAILED;
 692         } else {
 693                 SLOG(LOG_DEBUG, TAG_VCM, "Get fd from dbus : %d", fd);
 694         }
 695
 696         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);
 697
 698         if (NULL == g_m_fd_handler) {
 699                 SLOG(LOG_ERROR, TAG_VCM, "fail to get fd handler from ecore ");
 700                 __vc_mgr_dbus_connection_free();
 701                 return VC_ERROR_OPERATION_FAILED;
 702         }
 703
 704         return 0;
 705 }
 706
 707 int vc_mgr_dbus_close_connection()
 708 {
 709         DBusError err;
 710         dbus_error_init(&err);
 711
 712         if (NULL != g_m_fd_handler) {
 713                 ecore_main_fd_handler_del(g_m_fd_handler);
 714                 g_m_fd_handler = NULL;
 715         }
 716
 717         if (NULL != g_m_conn_listener) {
 718                 int pid = getpid();
 719
 720                 char service_name[64];
 721                 memset(service_name, '\0', 64);
 722                 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, pid);
 723
 724                 dbus_bus_release_name(g_m_conn_listener, service_name, &err);
 725
 726                 if (dbus_error_is_set(&err)) {
 727                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 728                         dbus_error_free(&err);
 729                 }
 730         }
 731
 732         __vc_mgr_dbus_connection_free();
 733
 734         return 0;
 735 }
 736
 737 int vc_mgr_dbus_reconnect()
 738 {
 739         if (!g_m_conn_sender || !g_m_conn_listener) {
 740                 vc_mgr_dbus_close_connection();
 741
 742                 if (0 != vc_mgr_dbus_open_connection()) {
 743                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to reconnect");
 744                         return -1;
 745                 }
 746
 747                 SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
 748                 return 0;
 749         }
 750
 751         bool sender_connected = dbus_connection_get_is_connected(g_m_conn_sender);
 752         bool listener_connected = dbus_connection_get_is_connected(g_m_conn_listener);
 753
 754         SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Sender(%s) Listener(%s)",
 755                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 756
 757         if (false == sender_connected || false == listener_connected) {
 758                 vc_mgr_dbus_close_connection();
 759
 760                 if (0 != vc_mgr_dbus_open_connection()) {
 761                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to reconnect");
 762                         return -1;
 763                 }
 764
 765                 SLOG(LOG_DEBUG, TAG_VCM, "[DBUS] Reconnect");
 766         }
 767
 768         return 0;
 769 }
 770
 771 int vc_mgr_dbus_request_hello()
 772 {
 773         DBusMessage* msg;
 774
 775         msg = dbus_message_new_method_call(
 776                           VC_SERVER_SERVICE_NAME,
 777                           VC_SERVER_SERVICE_OBJECT_PATH,
 778                           VC_SERVER_SERVICE_INTERFACE,
 779                           VC_METHOD_HELLO);
 780
 781         if (NULL == msg) {
 782                 SLOG(LOG_ERROR, TAG_VCM, "@@ Request vc hello : Fail to make message");
 783                 return VC_ERROR_OPERATION_FAILED;
 784         }
 785
 786         DBusError err;
 787         dbus_error_init(&err);
 788
 789         DBusMessage* result_msg = NULL;
 790         int result = 0;
 791
 792         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, 500, &err);
 793
 794         if (dbus_error_is_set(&err)) {
 795                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 796                 dbus_error_free(&err);
 797         }
 798
 799         dbus_message_unref(msg);
 800
 801         if (NULL != result_msg) {
 802                 dbus_message_unref(result_msg);
 803                 result = 0;
 804         } else {
 805                 result = VC_ERROR_TIMED_OUT;
 806         }
 807
 808         return result;
 809 }
 810
 811 static int __dbus_restore_daemon()
 812 {
 813         int ret = -1;
 814         int count = 0;
 815         while (0 != ret) {
 816                 ret = vc_mgr_dbus_request_hello();
 817                 if (0 != ret) {
 818                         if (VC_ERROR_TIMED_OUT != ret) {
 819                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 820                                 break;
 821                         } else {
 822                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry restore daemon");
 823                                 usleep(10000);
 824                                 count++;
 825                                 if (VC_RETRY_COUNT == count) {
 826                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 827                                         break;
 828                                 }
 829                         }
 830                 } else {
 831                         SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] restore daemon");
 832                 }
 833         }
 834         return ret;
 835 }
 836
 837 int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid)
 838 {
 839         DBusError err;
 840         dbus_error_init(&err);
 841
 842         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 843         if (dbus_error_is_set(&err)) {
 844                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 845                 dbus_error_free(&err);
 846         }
 847
 848         int ret;
 849         if (false == exist) {
 850                 ret = __dbus_restore_daemon();
 851                 if (VC_ERROR_NONE != ret) {
 852                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 853                         return VC_ERROR_TIMED_OUT;
 854                 }
 855                 return VC_ERROR_OPERATION_FAILED;
 856         }
 857
 858         DBusMessage* msg;
 859
 860         msg = dbus_message_new_method_call(
 861                           VC_SERVER_SERVICE_NAME,
 862                           VC_SERVER_SERVICE_OBJECT_PATH,
 863                           VC_SERVER_SERVICE_INTERFACE,
 864                           VC_MANAGER_METHOD_INITIALIZE);
 865
 866         if (NULL == msg) {
 867                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr initialize : Fail to make message ");
 868                 return VC_ERROR_OPERATION_FAILED;
 869         } else {
 870                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr initialize : pid(%d)", pid);
 871         }
 872
 873         dbus_message_append_args(msg,
 874                 DBUS_TYPE_INT32, &pid,
 875                 DBUS_TYPE_INVALID);
 876
 877         DBusMessage* result_msg;
 878         int result = VC_ERROR_OPERATION_FAILED;
 879
 880         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 881         dbus_message_unref(msg);
 882
 883         if (dbus_error_is_set(&err)) {
 884                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 885                 dbus_error_free(&err);
 886         }
 887
 888         if (NULL != result_msg) {
 889                 int tmp_service_state = 0;
 890                 int tmp_foreground = 0;
 891                 int tmp_daemon_pid = 0;
 892                 dbus_message_get_args(result_msg, &err,
 893                         DBUS_TYPE_INT32, &result,
 894                         DBUS_TYPE_INT32, &tmp_service_state,
 895                         DBUS_TYPE_INT32, &tmp_foreground,
 896                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 897                         DBUS_TYPE_INVALID);
 898
 899                 if (dbus_error_is_set(&err)) {
 900                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
 901                         dbus_error_free(&err);
 902                         result = VC_ERROR_OPERATION_FAILED;
 903                 }
 904
 905                 dbus_message_unref(result_msg);
 906
 907                 if (0 == result) {
 908                         *service_state = tmp_service_state;
 909                         *foreground = tmp_foreground;
 910                         *daemon_pid = tmp_daemon_pid;
 911
 912                         /* add a rule for daemon error */
 913                         char rule_err[256] = {0, };
 914                         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);
 915                         dbus_bus_add_match(g_m_conn_listener, rule_err, &err);
 916                         dbus_connection_flush(g_m_conn_listener);
 917
 918                         if (dbus_error_is_set(&err)) {
 919                                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 920                                 dbus_error_free(&err);
 921                         }
 922
 923                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr initialize : result = %d, service state = %d, foreground = %d, daemon_pid = %d",
 924                                 result, *service_state, *foreground, *daemon_pid);
 925                 } else {
 926                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr initialize : result = %d", result);
 927                 }
 928         } else {
 929                 SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL ");
 930                 vc_mgr_dbus_reconnect();
 931                 result = VC_ERROR_TIMED_OUT;
 932         }
 933
 934         return result;
 935 }
 936
 937 int vc_mgr_dbus_request_finalize(int pid)
 938 {
 939         DBusError err;
 940         dbus_error_init(&err);
 941
 942         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
 943         if (dbus_error_is_set(&err)) {
 944                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 945                 dbus_error_free(&err);
 946         }
 947
 948         int ret;
 949         if (false == exist) {
 950                 ret = __dbus_restore_daemon();
 951                 if (VC_ERROR_NONE != ret) {
 952                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
 953                         return VC_ERROR_TIMED_OUT;
 954                 }
 955                 return VC_ERROR_OPERATION_FAILED;
 956         }
 957
 958         /* remove a rule for daemon error */
 959         char rule_err[256] = {0, };
 960         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);
 961         dbus_bus_remove_match(g_m_conn_listener, rule_err, &err);
 962         dbus_connection_flush(g_m_conn_listener);
 963
 964         if (dbus_error_is_set(&err)) {
 965                 SLOG(LOG_ERROR, TAG_VCM, "Match Error (%s)", err.message);
 966                 dbus_error_free(&err);
 967                 return VC_ERROR_OPERATION_FAILED;
 968         }
 969
 970         DBusMessage* msg;
 971
 972         msg = dbus_message_new_method_call(
 973                           VC_SERVER_SERVICE_NAME,
 974                           VC_SERVER_SERVICE_OBJECT_PATH,
 975                           VC_SERVER_SERVICE_INTERFACE,
 976                           VC_MANAGER_METHOD_FINALIZE);
 977
 978         if (NULL == msg) {
 979                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : Fail to make message ");
 980                 return VC_ERROR_OPERATION_FAILED;
 981         } else {
 982                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr finalize : pid(%d)", pid);
 983         }
 984
 985         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 986
 987         DBusMessage* result_msg;
 988         int result = VC_ERROR_OPERATION_FAILED;
 989
 990         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
 991         dbus_message_unref(msg);
 992
 993         if (dbus_error_is_set(&err)) {
 994                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
 995                 dbus_error_free(&err);
 996         }
 997
 998         if (NULL != result_msg) {
 999                 dbus_message_get_args(result_msg, &err,
1000                                                           DBUS_TYPE_INT32, &result,
1001                                                           DBUS_TYPE_INVALID);
1002
1003                 if (dbus_error_is_set(&err)) {
1004                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1005                         dbus_error_free(&err);
1006                         result = VC_ERROR_OPERATION_FAILED;
1007                 }
1008
1009                 dbus_message_unref(result_msg);
1010
1011                 if (0 == result) {
1012                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr finalize : result = %d", result);
1013                 } else {
1014                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr finalize : result = %d", result);
1015                 }
1016         } else {
1017                 SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL ");
1018                 vc_mgr_dbus_reconnect();
1019                 result = VC_ERROR_TIMED_OUT;
1020         }
1021
1022         return result;
1023 }
1024
1025 int vc_mgr_dbus_request_set_command(int pid)
1026 {
1027         DBusError err;
1028         dbus_error_init(&err);
1029
1030         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1031         if (dbus_error_is_set(&err)) {
1032                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1033                 dbus_error_free(&err);
1034         }
1035
1036         int ret;
1037         if (false == exist) {
1038                 ret = __dbus_restore_daemon();
1039                 if (VC_ERROR_NONE != ret) {
1040                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1041                         return VC_ERROR_TIMED_OUT;
1042                 }
1043                 return VC_ERROR_OPERATION_FAILED;
1044         }
1045
1046         DBusMessage* msg;
1047
1048         msg = dbus_message_new_method_call(
1049                           VC_SERVER_SERVICE_NAME,
1050                           VC_SERVER_SERVICE_OBJECT_PATH,
1051                           VC_SERVER_SERVICE_INTERFACE,
1052                           VC_MANAGER_METHOD_SET_COMMAND);
1053
1054         if (NULL == msg) {
1055                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : Fail to make message");
1056                 return VC_ERROR_OPERATION_FAILED;
1057         } else {
1058                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set command : pid(%d)", pid);
1059         }
1060
1061         dbus_message_append_args(msg,
1062                                                          DBUS_TYPE_INT32, &pid,
1063                                                          DBUS_TYPE_INVALID);
1064
1065         DBusMessage* result_msg;
1066         int result = VC_ERROR_OPERATION_FAILED;
1067
1068         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1069         dbus_message_unref(msg);
1070
1071         if (dbus_error_is_set(&err)) {
1072                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1073                 dbus_error_free(&err);
1074         }
1075
1076         if (NULL != result_msg) {
1077                 dbus_message_get_args(result_msg, &err,
1078                                                           DBUS_TYPE_INT32, &result,
1079                                                           DBUS_TYPE_INVALID);
1080
1081                 if (dbus_error_is_set(&err)) {
1082                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1083                         dbus_error_free(&err);
1084                         result = VC_ERROR_OPERATION_FAILED;
1085                 }
1086                 dbus_message_unref(result_msg);
1087
1088                 if (0 == result) {
1089                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set command : result = %d", result);
1090                 } else {
1091                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set command : result = %d", result);
1092                 }
1093         } else {
1094                 SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL");
1095                 vc_mgr_dbus_reconnect();
1096                 result = VC_ERROR_TIMED_OUT;
1097         }
1098
1099         return result;
1100 }
1101
1102 int vc_mgr_dbus_request_unset_command(int pid)
1103 {
1104         DBusError err;
1105         dbus_error_init(&err);
1106
1107         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1108         if (dbus_error_is_set(&err)) {
1109                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1110                 dbus_error_free(&err);
1111         }
1112
1113         int ret;
1114         if (false == exist) {
1115                 ret = __dbus_restore_daemon();
1116                 if (VC_ERROR_NONE != ret) {
1117                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1118                         return VC_ERROR_TIMED_OUT;
1119                 }
1120                 return VC_ERROR_OPERATION_FAILED;
1121         }
1122
1123         DBusMessage* msg;
1124
1125         msg = dbus_message_new_method_call(
1126                           VC_SERVER_SERVICE_NAME,
1127                           VC_SERVER_SERVICE_OBJECT_PATH,
1128                           VC_SERVER_SERVICE_INTERFACE,
1129                           VC_MANAGER_METHOD_UNSET_COMMAND);
1130
1131         if (NULL == msg) {
1132                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : Fail to make message");
1133                 return VC_ERROR_OPERATION_FAILED;
1134         } else {
1135                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr unset command : pid(%d)", pid);
1136         }
1137
1138         dbus_message_append_args(msg,
1139                                                          DBUS_TYPE_INT32, &pid,
1140                                                          DBUS_TYPE_INVALID);
1141
1142         DBusMessage* result_msg;
1143         int result = VC_ERROR_OPERATION_FAILED;
1144
1145         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1146         dbus_message_unref(msg);
1147
1148         if (dbus_error_is_set(&err)) {
1149                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1150                 dbus_error_free(&err);
1151         }
1152
1153         if (NULL != result_msg) {
1154                 dbus_message_get_args(result_msg, &err,
1155                                                           DBUS_TYPE_INT32, &result,
1156                                                           DBUS_TYPE_INVALID);
1157
1158                 if (dbus_error_is_set(&err)) {
1159                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1160                         dbus_error_free(&err);
1161                         result = VC_ERROR_OPERATION_FAILED;
1162                 }
1163                 dbus_message_unref(result_msg);
1164
1165                 if (0 == result) {
1166                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr unset command : result = %d", result);
1167                 } else {
1168                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr unset command : result = %d", result);
1169                 }
1170         } else {
1171                 SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL");
1172                 vc_mgr_dbus_reconnect();
1173                 result = VC_ERROR_TIMED_OUT;
1174         }
1175
1176         return result;
1177 }
1178
1179 int vc_mgr_dbus_request_demandable_client(int pid)
1180 {
1181         DBusError err;
1182         dbus_error_init(&err);
1183
1184         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1185         if (dbus_error_is_set(&err)) {
1186                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1187                 dbus_error_free(&err);
1188         }
1189
1190         int ret;
1191         if (false == exist) {
1192                 ret = __dbus_restore_daemon();
1193                 if (VC_ERROR_NONE != ret) {
1194                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1195                         return VC_ERROR_TIMED_OUT;
1196                 }
1197                 return VC_ERROR_OPERATION_FAILED;
1198         }
1199
1200         DBusMessage* msg;
1201
1202         msg = dbus_message_new_method_call(
1203                           VC_SERVER_SERVICE_NAME,
1204                           VC_SERVER_SERVICE_OBJECT_PATH,
1205                           VC_SERVER_SERVICE_INTERFACE,
1206                           VC_MANAGER_METHOD_SET_DEMANDABLE);
1207
1208         if (NULL == msg) {
1209                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : Fail to make message");
1210                 return VC_ERROR_OPERATION_FAILED;
1211         } else {
1212                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set demandable client : pid(%d)", pid);
1213         }
1214
1215         dbus_message_append_args(msg,
1216                                                          DBUS_TYPE_INT32, &pid,
1217                                                          DBUS_TYPE_INVALID);
1218
1219         DBusMessage* result_msg;
1220         int result = VC_ERROR_OPERATION_FAILED;
1221
1222         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1223         dbus_message_unref(msg);
1224
1225         if (dbus_error_is_set(&err)) {
1226                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1227                 dbus_error_free(&err);
1228         }
1229
1230         if (NULL != result_msg) {
1231                 dbus_message_get_args(result_msg, &err,
1232                                                           DBUS_TYPE_INT32, &result,
1233                                                           DBUS_TYPE_INVALID);
1234
1235                 if (dbus_error_is_set(&err)) {
1236                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1237                         dbus_error_free(&err);
1238                         result = VC_ERROR_OPERATION_FAILED;
1239                 }
1240                 dbus_message_unref(result_msg);
1241
1242                 if (0 == result) {
1243                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result);
1244                 } else {
1245                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set demandable client : result = %d", result);
1246                 }
1247         } else {
1248                 SLOG(LOG_ERROR, TAG_VCM, "@@ Result message is NULL");
1249                 vc_mgr_dbus_reconnect();
1250                 result = VC_ERROR_TIMED_OUT;
1251         }
1252
1253         return result;
1254 }
1255
1256 int vc_mgr_dbus_request_set_audio_type(int pid, const char* audio_type)
1257 {
1258         DBusError err;
1259         dbus_error_init(&err);
1260
1261         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1262         if (dbus_error_is_set(&err)) {
1263                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1264                 dbus_error_free(&err);
1265         }
1266
1267         int ret;
1268         if (false == exist) {
1269                 ret = __dbus_restore_daemon();
1270                 if (VC_ERROR_NONE != ret) {
1271                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1272                         return VC_ERROR_TIMED_OUT;
1273                 }
1274                 return VC_ERROR_OPERATION_FAILED;
1275         }
1276
1277         DBusMessage* msg;
1278
1279         /* create a signal & check for errors */
1280         msg = dbus_message_new_method_call(
1281                           VC_SERVER_SERVICE_NAME,
1282                           VC_SERVER_SERVICE_OBJECT_PATH,
1283                           VC_SERVER_SERVICE_INTERFACE,
1284                           VC_MANAGER_METHOD_SET_AUDIO_TYPE);
1285
1286         if (NULL == msg) {
1287                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : Fail to make message ");
1288                 return VC_ERROR_OPERATION_FAILED;
1289         } else {
1290                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set audio type : pid(%d), audio type(%s)", pid, audio_type);
1291         }
1292
1293         dbus_message_append_args(msg,
1294                                                          DBUS_TYPE_INT32, &pid,
1295                                                          DBUS_TYPE_STRING, &(audio_type),
1296                                                          DBUS_TYPE_INVALID);
1297
1298         DBusMessage* result_msg;
1299         int result = VC_ERROR_OPERATION_FAILED;
1300
1301         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1302         dbus_message_unref(msg);
1303
1304         if (dbus_error_is_set(&err)) {
1305                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1306                 dbus_error_free(&err);
1307         }
1308
1309         if (NULL != result_msg) {
1310                 dbus_message_get_args(result_msg, &err,
1311                                                           DBUS_TYPE_INT32, &result,
1312                                                           DBUS_TYPE_INVALID);
1313
1314                 if (dbus_error_is_set(&err)) {
1315                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1316                         dbus_error_free(&err);
1317                         result = VC_ERROR_OPERATION_FAILED;
1318                 }
1319                 dbus_message_unref(result_msg);
1320
1321                 if (0 == result) {
1322                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set audio type : result = %d", result);
1323                 } else {
1324                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set audio type : result = %d", result);
1325                 }
1326         } else {
1327                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1328                 vc_mgr_dbus_reconnect();
1329                 result = VC_ERROR_TIMED_OUT;
1330         }
1331
1332         return result;
1333 }
1334
1335 int vc_mgr_dbus_request_get_audio_type(int pid, char** audio_type)
1336 {
1337         DBusError err;
1338         dbus_error_init(&err);
1339
1340         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1341         if (dbus_error_is_set(&err)) {
1342                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1343                 dbus_error_free(&err);
1344         }
1345
1346         int ret;
1347         if (false == exist) {
1348                 ret = __dbus_restore_daemon();
1349                 if (VC_ERROR_NONE != ret) {
1350                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1351                         return VC_ERROR_TIMED_OUT;
1352                 }
1353                 return VC_ERROR_OPERATION_FAILED;
1354         }
1355
1356         DBusMessage* msg;
1357
1358         /* create a signal & check for errors */
1359         msg = dbus_message_new_method_call(
1360                           VC_SERVER_SERVICE_NAME,
1361                           VC_SERVER_SERVICE_OBJECT_PATH,
1362                           VC_SERVER_SERVICE_INTERFACE,
1363                           VC_MANAGER_METHOD_GET_AUDIO_TYPE);
1364
1365         if (NULL == msg) {
1366                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : Fail to make message ");
1367                 return VC_ERROR_OPERATION_FAILED;
1368         } else {
1369                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get audio type : pid(%d)", pid);
1370         }
1371
1372         dbus_message_append_args(msg,
1373                                                          DBUS_TYPE_INT32, &pid,
1374                                                          DBUS_TYPE_INVALID);
1375
1376
1377         DBusMessage* result_msg;
1378         int result = VC_ERROR_OPERATION_FAILED;
1379         char* temp = NULL;
1380
1381         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1382         dbus_message_unref(msg);
1383
1384         if (dbus_error_is_set(&err)) {
1385                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1386                 dbus_error_free(&err);
1387         }
1388
1389         if (NULL != result_msg) {
1390                 dbus_message_get_args(result_msg, &err,
1391                                                           DBUS_TYPE_INT32, &result,
1392                                                           DBUS_TYPE_STRING, &temp,
1393                                                           DBUS_TYPE_INVALID);
1394
1395                 if (dbus_error_is_set(&err)) {
1396                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1397                         dbus_error_free(&err);
1398                         result = VC_ERROR_OPERATION_FAILED;
1399                 }
1400                 dbus_message_unref(result_msg);
1401
1402                 if (0 == result) {
1403                         if (NULL != audio_type && NULL != temp) {
1404                                 *audio_type = strdup(temp);
1405                         }
1406                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get audio type : result = %d audio type = %s", result, temp);
1407                 } else {
1408                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get audio type : result = %d", result);
1409                 }
1410         } else {
1411                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1412                 vc_mgr_dbus_reconnect();
1413                 result = VC_ERROR_TIMED_OUT;
1414         }
1415
1416         return result;
1417 }
1418
1419 int vc_mgr_dbus_request_set_private_data(int pid, const char* key, const char* data)
1420 {
1421         DBusMessage* msg;
1422
1423         /* create a signal & check for errors */
1424         msg = dbus_message_new_method_call(
1425                           VC_SERVER_SERVICE_NAME,
1426                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1427                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1428                           VC_MANAGER_METHOD_SET_PRIVATE_DATA);  /* name of the signal */
1429
1430         if (NULL == msg) {
1431                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc set private data : Fail to make message ");
1432                 return VC_ERROR_OPERATION_FAILED;
1433         } else {
1434                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set private data : pid(%d), data(%s)", pid, data);
1435         }
1436
1437         dbus_message_append_args(msg,
1438                                 DBUS_TYPE_INT32, &pid,
1439                                 DBUS_TYPE_STRING, &key,
1440                                 DBUS_TYPE_STRING, &data,
1441                                 DBUS_TYPE_INVALID);
1442
1443         dbus_message_set_no_reply(msg, TRUE);
1444
1445         /* send the message and flush the connection */
1446         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
1447                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send private data");
1448                 dbus_message_unref(msg);
1449                 return VC_ERROR_OPERATION_FAILED;
1450         } else {
1451                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus] Success to send private data");
1452                 dbus_connection_flush(g_m_conn_sender);
1453         }
1454
1455         dbus_message_unref(msg);
1456
1457         return VC_ERROR_NONE;
1458 }
1459
1460 int vc_mgr_dbus_request_get_private_data(int pid, const char* key, char** data)
1461 {
1462         DBusMessage* msg;
1463
1464         /* create a signal & check for errors */
1465         msg = dbus_message_new_method_call(
1466                           VC_SERVER_SERVICE_NAME,
1467                           VC_SERVER_SERVICE_OBJECT_PATH,
1468                           VC_SERVER_SERVICE_INTERFACE,
1469                           VC_MANAGER_METHOD_GET_PRIVATE_DATA);
1470
1471         if (NULL == msg) {
1472                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : Fail to make message ");
1473                 return VC_ERROR_OPERATION_FAILED;
1474         } else {
1475                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get private data : pid(%d), key(%s)", pid, key);
1476         }
1477
1478         dbus_message_append_args(msg,
1479                                 DBUS_TYPE_INT32, &pid,
1480                                 DBUS_TYPE_STRING, &key,
1481                                 DBUS_TYPE_INVALID);
1482
1483         DBusError err;
1484         dbus_error_init(&err);
1485
1486         DBusMessage* result_msg;
1487         int result = VC_ERROR_OPERATION_FAILED;
1488         char* temp = NULL;
1489
1490         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1491         dbus_message_unref(msg);
1492
1493         if (dbus_error_is_set(&err)) {
1494                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1495                 dbus_error_free(&err);
1496         }
1497
1498         if (NULL != result_msg) {
1499                 dbus_message_get_args(result_msg, &err,
1500                                         DBUS_TYPE_INT32, &result,
1501                                         DBUS_TYPE_STRING, &temp,
1502                                         DBUS_TYPE_INVALID);
1503
1504                 if (dbus_error_is_set(&err)) {
1505                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1506                         dbus_error_free(&err);
1507                         result = VC_ERROR_OPERATION_FAILED;
1508                 }
1509                 dbus_message_unref(result_msg);
1510
1511                 if (0 == result) {
1512                         if (NULL != data && NULL != temp) {
1513                                 *data = strdup(temp);
1514
1515                                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr get private data : result = %d private data = %s", result, *data);
1516                         }
1517                 } else {
1518                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr get private data : result = %d", result);
1519                 }
1520         } else {
1521                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1522                 vc_mgr_dbus_reconnect();
1523                 result = VC_ERROR_TIMED_OUT;
1524         }
1525
1526         return result;
1527 }
1528
1529 int vc_mgr_dbus_request_set_client_info(int pid)
1530 {
1531         DBusError err;
1532         dbus_error_init(&err);
1533
1534         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1535         if (dbus_error_is_set(&err)) {
1536                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1537                 dbus_error_free(&err);
1538         }
1539
1540         int ret;
1541         if (false == exist) {
1542                 ret = __dbus_restore_daemon();
1543                 if (VC_ERROR_NONE != ret) {
1544                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1545                         return VC_ERROR_TIMED_OUT;
1546                 }
1547                 return VC_ERROR_OPERATION_FAILED;
1548         }
1549
1550         DBusMessage* msg;
1551
1552         /* create a signal & check for errors */
1553         msg = dbus_message_new_method_call(
1554                           VC_SERVER_SERVICE_NAME,
1555                           VC_SERVER_SERVICE_OBJECT_PATH,
1556                           VC_SERVER_SERVICE_INTERFACE,
1557                           VC_MANAGER_METHOD_SET_CLIENT_INFO);
1558
1559         if (NULL == msg) {
1560                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : Fail to make message ");
1561                 return VC_ERROR_OPERATION_FAILED;
1562         } else {
1563                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set client info : pid(%d)", pid);
1564         }
1565
1566         dbus_message_append_args(msg,
1567                                                          DBUS_TYPE_INT32, &pid,
1568                                                          DBUS_TYPE_INVALID);
1569
1570         DBusMessage* result_msg;
1571         int result = VC_ERROR_OPERATION_FAILED;
1572
1573         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1574         dbus_message_unref(msg);
1575
1576         if (dbus_error_is_set(&err)) {
1577                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1578                 dbus_error_free(&err);
1579         }
1580
1581         if (NULL != result_msg) {
1582                 dbus_message_get_args(result_msg, &err,
1583                                                           DBUS_TYPE_INT32, &result,
1584                                                           DBUS_TYPE_INVALID);
1585
1586                 if (dbus_error_is_set(&err)) {
1587                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1588                         dbus_error_free(&err);
1589                         result = VC_ERROR_OPERATION_FAILED;
1590                 }
1591                 dbus_message_unref(result_msg);
1592
1593                 if (0 == result) {
1594                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr set client info : result = %d", result);
1595                 } else {
1596                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr set client info : result = %d", result);
1597                 }
1598         } else {
1599                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1600                 vc_mgr_dbus_reconnect();
1601                 result = VC_ERROR_TIMED_OUT;
1602         }
1603
1604         return result;
1605 }
1606
1607 int vc_mgr_dbus_request_set_domain(int pid, const char* domain)
1608 {
1609         DBusMessage* msg;
1610
1611         /* create a signal & check for errors */
1612         msg = dbus_message_new_method_call(
1613                           VC_SERVER_SERVICE_NAME,
1614                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1615                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1616                           VC_MANAGER_METHOD_SET_DOMAIN);        /* name of the signal */
1617
1618         if (NULL == msg) {
1619                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message ");
1620                 return VC_ERROR_OPERATION_FAILED;
1621         } else {
1622                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : pid(%d), domain(%s)", pid, domain);
1623         }
1624
1625         dbus_message_append_args(msg,
1626                                 DBUS_TYPE_INT32, &pid,
1627                                 DBUS_TYPE_STRING, &domain,
1628                                 DBUS_TYPE_INVALID);
1629
1630         DBusError err;
1631         dbus_error_init(&err);
1632
1633         DBusMessage* result_msg;
1634         int result = VC_ERROR_OPERATION_FAILED;
1635
1636         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1637         dbus_message_unref(msg);
1638
1639         if (dbus_error_is_set(&err)) {
1640                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1641                 dbus_error_free(&err);
1642         }
1643
1644         if (NULL != result_msg) {
1645                 dbus_message_get_args(result_msg, &err,
1646                                         DBUS_TYPE_INT32, &result,
1647                                         DBUS_TYPE_INVALID);
1648
1649                 if (dbus_error_is_set(&err)) {
1650                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1651                         dbus_error_free(&err);
1652                         result = VC_ERROR_OPERATION_FAILED;
1653                 }
1654                 dbus_message_unref(result_msg);
1655
1656                 if (0 == result) {
1657                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : result = %d", result);
1658                 } else {
1659                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : result = %d", result);
1660                 }
1661         } else {
1662                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1663                 vc_mgr_dbus_reconnect();
1664                 result = VC_ERROR_TIMED_OUT;
1665         }
1666
1667         return result;
1668 }
1669
1670 int vc_mgr_dbus_request_do_action(int pid, vc_send_event_type_e type, char* send_event)
1671 {
1672         DBusMessage* msg;
1673
1674         /* create a signal & check for errors */
1675         msg = dbus_message_new_method_call(
1676                           VC_SERVER_SERVICE_NAME,
1677                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1678                           VC_SERVER_SERVICE_INTERFACE,          /* interface name of the signal */
1679                           VC_MANAGER_METHOD_DO_ACTION); /* name of the signal */
1680
1681         if (NULL == msg) {
1682                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc set domain : Fail to make message ");
1683                 return VC_ERROR_OPERATION_FAILED;
1684         } else {
1685                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc set domain : pid(%d), type(%d), send_event(%s)", pid, type, send_event);
1686         }
1687
1688         dbus_message_append_args(msg,
1689                                 DBUS_TYPE_INT32, &pid,
1690                                 DBUS_TYPE_INT32, &type,
1691                                 DBUS_TYPE_STRING, &send_event,
1692                                 DBUS_TYPE_INVALID);
1693
1694         dbus_message_set_no_reply(msg, TRUE);
1695
1696         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
1697                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
1698                 return -1;
1699         } else {
1700                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
1701                 dbus_connection_flush(g_m_conn_sender);
1702         }
1703
1704         return 0;
1705 }
1706
1707 int vc_mgr_dbus_request_start(int pid, int recognition_mode, bool exclusive_command_option, bool start_by_client)
1708 {
1709         DBusError err;
1710         dbus_error_init(&err);
1711
1712         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1713         if (dbus_error_is_set(&err)) {
1714                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1715                 dbus_error_free(&err);
1716         }
1717
1718         int ret;
1719         if (false == exist) {
1720                 ret = __dbus_restore_daemon();
1721                 if (VC_ERROR_NONE != ret) {
1722                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1723                         return VC_ERROR_TIMED_OUT;
1724                 }
1725                 return VC_ERROR_OPERATION_FAILED;
1726         }
1727
1728         DBusMessage* msg;
1729
1730         /* create a signal & check for errors */
1731         msg = dbus_message_new_method_call(
1732                           VC_SERVER_SERVICE_NAME,
1733                           VC_SERVER_SERVICE_OBJECT_PATH,
1734                           VC_SERVER_SERVICE_INTERFACE,
1735                           VC_MANAGER_METHOD_START);
1736
1737         if (NULL == msg) {
1738                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : Fail to make message ");
1739                 return VC_ERROR_OPERATION_FAILED;
1740         } else {
1741                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr start : pid(%d), recognition_mode(%d) exclusive(%d) start by client(%d)",
1742                          pid, recognition_mode, exclusive_command_option, start_by_client);
1743         }
1744
1745         int exclusive = (int)exclusive_command_option;
1746         int by = (int)start_by_client;
1747
1748         dbus_message_append_args(msg,
1749                                                          DBUS_TYPE_INT32, &pid,
1750                                                          DBUS_TYPE_INT32, &(recognition_mode),
1751                                                          DBUS_TYPE_INT32, &(exclusive),
1752                                                          DBUS_TYPE_INT32, &(by),
1753                                                          DBUS_TYPE_INVALID);
1754
1755         DBusMessage* result_msg;
1756         int result = VC_ERROR_OPERATION_FAILED;
1757
1758         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1759         dbus_message_unref(msg);
1760
1761         if (dbus_error_is_set(&err)) {
1762                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1763                 dbus_error_free(&err);
1764         }
1765
1766         if (NULL != result_msg) {
1767                 dbus_message_get_args(result_msg, &err,
1768                                                           DBUS_TYPE_INT32, &result,
1769                                                           DBUS_TYPE_INVALID);
1770
1771                 if (dbus_error_is_set(&err)) {
1772                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1773                         dbus_error_free(&err);
1774                         result = VC_ERROR_OPERATION_FAILED;
1775                 }
1776                 dbus_message_unref(result_msg);
1777
1778                 if (0 == result) {
1779                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr start : result = %d", result);
1780                 } else {
1781                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr start : result = %d", result);
1782                 }
1783         } else {
1784                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1785                 vc_mgr_dbus_reconnect();
1786                 result = VC_ERROR_TIMED_OUT;
1787         }
1788
1789         return result;
1790 }
1791
1792 int vc_mgr_dbus_request_stop(int pid)
1793 {
1794         DBusError err;
1795         dbus_error_init(&err);
1796
1797         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1798         if (dbus_error_is_set(&err)) {
1799                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1800                 dbus_error_free(&err);
1801         }
1802
1803         int ret;
1804         if (false == exist) {
1805                 ret = __dbus_restore_daemon();
1806                 if (VC_ERROR_NONE != ret) {
1807                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1808                         return VC_ERROR_TIMED_OUT;
1809                 }
1810                 return VC_ERROR_OPERATION_FAILED;
1811         }
1812
1813         DBusMessage* msg;
1814
1815         /* create a signal & check for errors */
1816         msg = dbus_message_new_method_call(
1817                           VC_SERVER_SERVICE_NAME,
1818                           VC_SERVER_SERVICE_OBJECT_PATH,
1819                           VC_SERVER_SERVICE_INTERFACE,
1820                           VC_MANAGER_METHOD_STOP);
1821
1822         if (NULL == msg) {
1823                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : Fail to make message ");
1824                 return VC_ERROR_OPERATION_FAILED;
1825         } else {
1826                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr stop : pid(%d)", pid);
1827         }
1828
1829         dbus_message_append_args(msg,
1830                                                          DBUS_TYPE_INT32, &pid,
1831                                                          DBUS_TYPE_INVALID);
1832
1833         DBusMessage* result_msg;
1834         int result = VC_ERROR_OPERATION_FAILED;
1835
1836         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1837         dbus_message_unref(msg);
1838
1839         if (dbus_error_is_set(&err)) {
1840                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1841                 dbus_error_free(&err);
1842         }
1843
1844         if (NULL != result_msg) {
1845                 dbus_message_get_args(result_msg, &err,
1846                                                           DBUS_TYPE_INT32, &result,
1847                                                           DBUS_TYPE_INVALID);
1848
1849                 if (dbus_error_is_set(&err)) {
1850                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1851                         dbus_error_free(&err);
1852                         result = VC_ERROR_OPERATION_FAILED;
1853                 }
1854                 dbus_message_unref(result_msg);
1855
1856                 if (0 == result) {
1857                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc mgr stop : result = %d", result);
1858                 } else {
1859                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc mgr stop : result = %d", result);
1860                 }
1861         } else {
1862                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1863                 vc_mgr_dbus_reconnect();
1864                 result = VC_ERROR_TIMED_OUT;
1865         }
1866
1867         return result;
1868 }
1869
1870 int vc_mgr_dbus_request_cancel(int pid)
1871 {
1872         DBusError err;
1873         dbus_error_init(&err);
1874
1875         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1876         if (dbus_error_is_set(&err)) {
1877                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1878                 dbus_error_free(&err);
1879         }
1880
1881         int ret;
1882         if (false == exist) {
1883                 ret = __dbus_restore_daemon();
1884                 if (VC_ERROR_NONE != ret) {
1885                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1886                         return VC_ERROR_TIMED_OUT;
1887                 }
1888                 return VC_ERROR_OPERATION_FAILED;
1889         }
1890
1891         DBusMessage* msg;
1892
1893         /* create a signal & check for errors */
1894         msg = dbus_message_new_method_call(
1895                           VC_SERVER_SERVICE_NAME,
1896                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1897                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1898                           VC_MANAGER_METHOD_CANCEL);    /* name of the signal */
1899
1900         if (NULL == msg) {
1901                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : Fail to make message ");
1902                 return VC_ERROR_OPERATION_FAILED;
1903         } else {
1904                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc cancel : pid(%d)", pid);
1905         }
1906
1907         dbus_message_append_args(msg,
1908                                                          DBUS_TYPE_INT32, &pid,
1909                                                          DBUS_TYPE_INVALID);
1910
1911         DBusMessage* result_msg;
1912         int result = VC_ERROR_OPERATION_FAILED;
1913
1914         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1915         dbus_message_unref(msg);
1916
1917         if (dbus_error_is_set(&err)) {
1918                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1919                 dbus_error_free(&err);
1920         }
1921
1922         if (NULL != result_msg) {
1923                 dbus_message_get_args(result_msg, &err,
1924                                                           DBUS_TYPE_INT32, &result,
1925                                                           DBUS_TYPE_INVALID);
1926
1927                 if (dbus_error_is_set(&err)) {
1928                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
1929                         dbus_error_free(&err);
1930                         result = VC_ERROR_OPERATION_FAILED;
1931                 }
1932                 dbus_message_unref(result_msg);
1933
1934                 if (0 == result) {
1935                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc cancel : result = %d", result);
1936                 } else {
1937                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc cancel : result = %d", result);
1938                 }
1939         } else {
1940                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
1941                 vc_mgr_dbus_reconnect();
1942                 result = VC_ERROR_TIMED_OUT;
1943         }
1944
1945         return result;
1946 }
1947
1948 int vc_mgr_dbus_request_enable_command_type(int pid, int cmd_type)
1949 {
1950         DBusError err;
1951         dbus_error_init(&err);
1952
1953         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
1954         if (dbus_error_is_set(&err)) {
1955                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1956                 dbus_error_free(&err);
1957         }
1958
1959         int ret;
1960         if (false == exist) {
1961                 ret = __dbus_restore_daemon();
1962                 if (VC_ERROR_NONE != ret) {
1963                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
1964                         return VC_ERROR_TIMED_OUT;
1965                 }
1966                 return VC_ERROR_OPERATION_FAILED;
1967         }
1968
1969         DBusMessage* msg;
1970
1971         /* create a signal & check for errors */
1972         msg = dbus_message_new_method_call(
1973                           VC_SERVER_SERVICE_NAME,
1974                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1975                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1976                           VC_MANAGER_METHOD_ENABLE_COMMAND_TYPE);       /* name of the signal */
1977
1978         if (NULL == msg) {
1979                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc enable command type : Fail to make message ");
1980                 return VC_ERROR_OPERATION_FAILED;
1981         } else {
1982                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc enable command type : pid(%d) type(%d)", pid, cmd_type);
1983         }
1984
1985         dbus_message_append_args(msg,
1986                                  DBUS_TYPE_INT32, &pid,
1987                                  DBUS_TYPE_INT32, &cmd_type,
1988                                  DBUS_TYPE_INVALID);
1989
1990         DBusMessage* result_msg;
1991         int result = VC_ERROR_OPERATION_FAILED;
1992
1993         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
1994         dbus_message_unref(msg);
1995
1996         if (dbus_error_is_set(&err)) {
1997                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
1998                 dbus_error_free(&err);
1999         }
2000
2001         if (NULL != result_msg) {
2002                 dbus_message_get_args(result_msg, &err,
2003                                           DBUS_TYPE_INT32, &result,
2004                                           DBUS_TYPE_INVALID);
2005
2006                 if (dbus_error_is_set(&err)) {
2007                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
2008                         dbus_error_free(&err);
2009                         result = VC_ERROR_OPERATION_FAILED;
2010                 }
2011                 dbus_message_unref(result_msg);
2012
2013                 if (0 == result) {
2014                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc enable command type : result = %d", result);
2015                 } else {
2016                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc enable command type : result = %d", result);
2017                 }
2018         } else {
2019                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
2020                 vc_mgr_dbus_reconnect();
2021                 result = VC_ERROR_TIMED_OUT;
2022         }
2023
2024         return result;
2025 }
2026
2027 int vc_mgr_dbus_request_disable_command_type(int pid, int cmd_type)
2028 {
2029         DBusError err;
2030         dbus_error_init(&err);
2031
2032         bool exist = dbus_bus_name_has_owner(g_m_conn_sender, VC_SERVER_SERVICE_NAME, &err);
2033         if (dbus_error_is_set(&err)) {
2034                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
2035                 dbus_error_free(&err);
2036         }
2037
2038         int ret;
2039         if (false == exist) {
2040                 ret = __dbus_restore_daemon();
2041                 if (VC_ERROR_NONE != ret) {
2042                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to restore daemon");
2043                         return VC_ERROR_TIMED_OUT;
2044                 }
2045                 return VC_ERROR_OPERATION_FAILED;
2046         }
2047
2048         DBusMessage* msg;
2049
2050         /* create a signal & check for errors */
2051         msg = dbus_message_new_method_call(
2052                           VC_SERVER_SERVICE_NAME,
2053                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
2054                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
2055                           VC_MANAGER_METHOD_DISABLE_COMMAND_TYPE);      /* name of the signal */
2056
2057         if (NULL == msg) {
2058                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc disable command type : Fail to make message ");
2059                 return VC_ERROR_OPERATION_FAILED;
2060         } else {
2061                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc disable command type : pid(%d) type(%d)", pid, cmd_type);
2062         }
2063
2064         dbus_message_append_args(msg,
2065                                  DBUS_TYPE_INT32, &pid,
2066                                  DBUS_TYPE_INT32, &cmd_type,
2067                                  DBUS_TYPE_INVALID);
2068
2069         DBusMessage* result_msg;
2070         int result = VC_ERROR_OPERATION_FAILED;
2071
2072         result_msg = dbus_connection_send_with_reply_and_block(g_m_conn_sender, msg, g_m_waiting_time, &err);
2073         dbus_message_unref(msg);
2074
2075         if (dbus_error_is_set(&err)) {
2076                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Dbus Error (%s)", err.message);
2077                 dbus_error_free(&err);
2078         }
2079
2080         if (NULL != result_msg) {
2081                 dbus_message_get_args(result_msg, &err,
2082                                           DBUS_TYPE_INT32, &result,
2083                                           DBUS_TYPE_INVALID);
2084
2085                 if (dbus_error_is_set(&err)) {
2086                         SLOG(LOG_ERROR, TAG_VCM, "@@ Get arguments error (%s)", err.message);
2087                         dbus_error_free(&err);
2088                         result = VC_ERROR_OPERATION_FAILED;
2089                 }
2090                 dbus_message_unref(result_msg);
2091
2092                 if (0 == result) {
2093                         SLOG(LOG_DEBUG, TAG_VCM, "@@ vc disable command type : result = %d", result);
2094                 } else {
2095                         SLOG(LOG_ERROR, TAG_VCM, "@@ vc disable command type : result = %d", result);
2096                 }
2097         } else {
2098                 SLOG(LOG_DEBUG, TAG_VCM, "@@ Result Message is NULL");
2099                 vc_mgr_dbus_reconnect();
2100                 result = VC_ERROR_TIMED_OUT;
2101         }
2102
2103         return result;
2104 }
2105
2106 static DBusMessage* __get_message(int pid, const char* method, int type)
2107 {
2108         char service_name[64];
2109         char object_path[64];
2110         char target_if_name[128];
2111
2112         memset(service_name, '\0', 64);
2113         memset(object_path, '\0', 64);
2114         memset(target_if_name, '\0', 128);
2115
2116         if (VC_COMMAND_TYPE_FOREGROUND == type || VC_COMMAND_TYPE_BACKGROUND == type) {
2117                 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
2118                 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
2119                 snprintf(target_if_name, 128, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
2120         } else if (VC_COMMAND_TYPE_WIDGET == type) {
2121                 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
2122                 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
2123                 snprintf(target_if_name, 128, "%s%d", VC_WIDGET_SERVICE_INTERFACE, pid);
2124         } else {
2125                 return NULL;
2126         }
2127
2128         SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Service(%s) object(%s) if(%s)", service_name, object_path, target_if_name);
2129
2130         return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
2131 }
2132
2133 int vc_mgr_dbus_send_result(int pid, int cmd_type, int result_id)
2134 {
2135         DBusMessage* msg = NULL;
2136
2137         switch (cmd_type) {
2138         case VC_COMMAND_TYPE_FOREGROUND:
2139         case VC_COMMAND_TYPE_BACKGROUND:
2140                 msg = __get_message(pid, VCD_METHOD_RESULT, cmd_type);
2141                 break;
2142         case VC_COMMAND_TYPE_WIDGET:
2143                 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, cmd_type);
2144                 break;
2145         default:
2146                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
2147                 return -1;
2148         }
2149
2150         if (NULL == msg)
2151                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Message is NULL");
2152
2153         dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_id, DBUS_TYPE_INVALID);
2154
2155         dbus_message_set_no_reply(msg, TRUE);
2156
2157         /* send the message and flush the connection */
2158         if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
2159                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send result message");
2160         } else {
2161                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] Success to send result");
2162
2163                 dbus_connection_flush(g_m_conn_sender);
2164         }
2165
2166         dbus_message_unref(msg);
2167
2168         return 0;
2169 }
2170
2171 int vc_mgr_dbus_send_result_selection(int pid)
2172 {
2173         DBusMessage* msg;
2174
2175         /* create a signal & check for errors */
2176         msg = dbus_message_new_method_call(
2177                           VC_SERVER_SERVICE_NAME,
2178                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
2179                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
2180                           VC_MANAGER_METHOD_RESULT_SELECTION);  /* name of the signal */
2181
2182         if (NULL == msg) {
2183                 SLOG(LOG_ERROR, TAG_VCM, "@@ vc result selection : Fail to make message ");
2184                 return VC_ERROR_OPERATION_FAILED;
2185         } else {
2186                 SLOG(LOG_DEBUG, TAG_VCM, "@@ vc result selection : pid(%d)", pid);
2187         }
2188
2189         dbus_message_append_args(msg,
2190                                                          DBUS_TYPE_INT32, &pid,
2191                                                          DBUS_TYPE_INVALID);
2192
2193         dbus_message_set_no_reply(msg, TRUE);
2194
2195         if (1 != dbus_connection_send(g_m_conn_sender, msg, NULL)) {
2196                 SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to Send");
2197                 return -1;
2198         } else {
2199                 SLOG(LOG_DEBUG, TAG_VCM, "[Dbus] SUCCESS Send");
2200                 dbus_connection_flush(g_m_conn_sender);
2201         }
2202
2203         return 0;
2204 }