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