client/vc_mgr_dbus.c

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