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