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