client/vc.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 #include <aul.h>
  18 #include <cynara-client.h>
  19 #include <cynara-error.h>
  20 #include <cynara-session.h>
  21 #include <system_info.h>
  22
  23 #include "vc_client.h"
  24 #include "vc_command.h"
  25 #include "vc_config_mgr.h"
  26 #include "vc_dbus.h"
  27 #include "vc_info_parser.h"
  28 #include "vc_main.h"
  29 #include "voice_control.h"
  30 #include "voice_control_authority.h"
  31 #include "voice_control_command.h"
  32 #include "voice_control_command_expand.h"
  33
  34
  35
  36 static Ecore_Timer* g_connect_timer = NULL;
  37
  38 static vc_h g_vc = NULL;
  39
  40 static int g_feature_enabled = -1;
  41
  42 static int g_privilege_allowed = -1;
  43 static cynara *p_cynara = NULL;
  44
  45 #if 0
  46 static Ecore_Event_Handler* g_focus_in_hander = NULL;
  47 static Ecore_Event_Handler* g_focus_out_hander = NULL;
  48 #endif
  49
  50 Eina_Bool __vc_notify_state_changed(void *data);
  51 Eina_Bool __vc_notify_error(void *data);
  52
  53 static int __vc_get_feature_enabled()
  54 {
  55         if (0 == g_feature_enabled) {
  56                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  57                 return VC_ERROR_NOT_SUPPORTED;
  58         } else if (-1 == g_feature_enabled) {
  59                 bool vc_supported = false;
  60                 bool mic_supported = false;
  61                 if (0 == system_info_get_platform_bool(VC_FEATURE_PATH, &vc_supported)) {
  62                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
  63                                 if (false == vc_supported || false == mic_supported) {
  64                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Voice control feature NOT supported");
  65                                         g_feature_enabled = 0;
  66                                         return VC_ERROR_NOT_SUPPORTED;
  67                                 }
  68
  69                                 g_feature_enabled = 1;
  70                         } else {
  71                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
  72                                 return VC_ERROR_NOT_SUPPORTED;
  73                         }
  74                 } else {
  75                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get feature value");
  76                         return VC_ERROR_NOT_SUPPORTED;
  77                 }
  78         }
  79
  80         return 0;
  81 }
  82
  83 static int __check_privilege_initialize()
  84 {
  85         int ret = cynara_initialize(&p_cynara, NULL);
  86         if (CYNARA_API_SUCCESS != ret)
  87                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to initialize");
  88
  89         return ret == CYNARA_API_SUCCESS;
  90 }
  91
  92 static int __check_privilege(const char* uid, const char * privilege)
  93 {
  94         FILE *fp = NULL;
  95         char smack_label[1024] = "/proc/self/attr/current";
  96
  97         if (!p_cynara) {
  98             return false;
  99         }
 100
 101         fp = fopen(smack_label, "r");
 102         if (fp != NULL) {
 103             if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
 104                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to fread");
 105
 106             fclose(fp);
 107         }
 108
 109         pid_t pid = getpid();
 110         char *session = cynara_session_from_pid(pid);
 111         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 112         SLOG(LOG_DEBUG, TAG_VCC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
 113         if (session)
 114             free(session);
 115
 116         if (ret != CYNARA_API_ACCESS_ALLOWED)
 117             return false;
 118         return true;
 119 }
 120
 121 static void __check_privilege_deinitialize()
 122 {
 123         if (p_cynara)
 124                 cynara_finish(p_cynara);
 125         p_cynara = NULL;
 126 }
 127
 128 static int __vc_check_privilege()
 129 {
 130         char uid[16];
 131
 132         if (0 == g_privilege_allowed) {
 133                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
 134                 return VC_ERROR_PERMISSION_DENIED;
 135         } else if (-1 == g_privilege_allowed) {
 136                 if (false == __check_privilege_initialize()){
 137                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] privilege initialize is failed");
 138                         return VC_ERROR_PERMISSION_DENIED;
 139                 }
 140                 snprintf(uid, 16, "%d", getuid());
 141                 if (false == __check_privilege(uid, VC_PRIVILEGE)) {
 142                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
 143                         g_privilege_allowed = 0;
 144                         __check_privilege_deinitialize();
 145                         return VC_ERROR_PERMISSION_DENIED;
 146                 }
 147                 __check_privilege_deinitialize();
 148         }
 149
 150         g_privilege_allowed = 1;
 151         return VC_ERROR_NONE;
 152 }
 153
 154 static const char* __vc_get_error_code(vc_error_e err)
 155 {
 156         switch (err) {
 157         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
 158         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
 159         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
 160         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
 161         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
 162         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
 163         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
 164         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
 165         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
 166         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
 167         default:                                return "Invalid error code";
 168         }
 169         return NULL;
 170 }
 171
 172 static int __vc_convert_config_error_code(vc_config_error_e code)
 173 {
 174         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
 175         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
 176         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
 177         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
 178         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
 179         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
 180         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
 181         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
 182
 183         return VC_ERROR_NONE;
 184 }
 185
 186 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
 187 {
 188         SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
 189                  before_lang, current_lang);
 190
 191         vc_current_language_changed_cb callback;
 192         void* lang_user_data;
 193         vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
 194
 195         if (NULL != callback) {
 196                 vc_client_use_callback(g_vc);
 197                 callback(before_lang, current_lang, lang_user_data);
 198                 vc_client_not_use_callback(g_vc);
 199                 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
 200         } else {
 201                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
 202         }
 203
 204         return;
 205 }
 206
 207 static Eina_Bool __notify_auth_changed_cb(void *data)
 208 {
 209         vc_auth_state_changed_cb callback = NULL;
 210         void* user_data;
 211
 212         vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
 213
 214         vc_auth_state_e before = -1;
 215         vc_auth_state_e current = -1;
 216
 217         vc_client_get_before_auth_state(g_vc, &before, &current);
 218
 219         if (NULL != callback) {
 220                 vc_client_use_callback(g_vc);
 221                 callback(before, current, user_data);
 222                 vc_client_not_use_callback(g_vc);
 223                 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
 224         } else {
 225                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
 226         }
 227
 228         return EINA_FALSE;
 229 }
 230
 231 static int __vc_app_state_changed_cb(int app_state, void *data)
 232 {
 233         int ret = -1;
 234         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] app state changed");
 235
 236         /* Set current pid */
 237         if (STATUS_VISIBLE == app_state) {
 238                 SLOG(LOG_DEBUG, TAG_VCC, "===== Set foreground");
 239                 ret = vc_dbus_set_foreground(getpid(), true);
 240                 if (0 != ret) {
 241                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
 242                 }
 243
 244                 ret = vc_client_set_is_foreground(g_vc, true);
 245                 if (0 != ret) {
 246                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (true) : %d", ret);
 247                 }
 248
 249                 /* set authority valid */
 250                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 251                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 252                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 253                 }
 254                 if (VC_AUTH_STATE_INVALID == state) {
 255                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
 256
 257                         /* notify auth changed cb */
 258                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 259                 }
 260         } else if (STATUS_BG == app_state) {
 261                 SLOG(LOG_DEBUG, TAG_VCC, "===== Set background");
 262                 ret = vc_dbus_set_foreground(getpid(), false);
 263                 if (0 != ret) {
 264                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (false) : %d", ret);
 265                 }
 266
 267                 ret = vc_client_set_is_foreground(g_vc, false);
 268                 if (0 != ret) {
 269                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save is_foreground (false) : %d", ret);
 270                 }
 271
 272                 /* set authority valid */
 273                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 274                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 275                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 276                 }
 277                 if (VC_AUTH_STATE_VALID == state) {
 278                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
 279
 280                         /* notify authority changed cb */
 281                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 282                 }
 283         } else {
 284                 SLOG(LOG_DEBUG, TAG_VCC, "===== App state is NOT valid");
 285         }
 286
 287         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 288         SLOG(LOG_DEBUG, TAG_VCC, " ");
 289
 290         return 0;
 291 }
 292
 293 int vc_initialize(void)
 294 {
 295         if (0 != __vc_get_feature_enabled()) {
 296                 return VC_ERROR_NOT_SUPPORTED;
 297         }
 298         if (0 != __vc_check_privilege()) {
 299                 return VC_ERROR_PERMISSION_DENIED;
 300         }
 301
 302         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Initialize");
 303
 304         /* check handle */
 305         if (true == vc_client_is_valid(g_vc)) {
 306                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already initialized");
 307                 return VC_ERROR_INVALID_STATE;
 308         }
 309
 310         if (0 < vc_client_get_count()) {
 311                 SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] Already initialized");
 312                 return VC_ERROR_INVALID_STATE;
 313         }
 314
 315         if (0 != vc_dbus_open_connection()) {
 316                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to open connection");
 317                 return VC_ERROR_OPERATION_FAILED;
 318         }
 319
 320         if (0 != vc_client_create(&g_vc)) {
 321                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create client!!!!!");
 322                 return VC_ERROR_OUT_OF_MEMORY;
 323         }
 324
 325         int ret = vc_config_mgr_initialize(g_vc->handle);
 326         if (0 != ret) {
 327                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to init config manager : %s",
 328                          __vc_get_error_code(__vc_convert_config_error_code(ret)));
 329                 vc_client_destroy(g_vc);
 330                 return __vc_convert_config_error_code(ret);
 331         }
 332
 333         ret = vc_config_mgr_set_lang_cb(g_vc->handle, __vc_lang_changed_cb);
 334         if (0 != ret) {
 335                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set config changed : %d", ret);
 336                 vc_config_mgr_finalize(g_vc->handle);
 337                 vc_client_destroy(g_vc);
 338                 return __vc_convert_config_error_code(ret);
 339         }
 340
 341         SLOG(LOG_DEBUG, TAG_VCC, "[Success] pid(%d)", g_vc->handle);
 342
 343         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 344         SLOG(LOG_DEBUG, TAG_VCC, " ");
 345
 346         return VC_ERROR_NONE;
 347 }
 348
 349 static void __vc_internal_unprepare(void)
 350 {
 351         /* return authority */
 352         vc_auth_state_e state = VC_AUTH_STATE_NONE;
 353         if (0 != vc_client_get_auth_state(g_vc, &state)) {
 354                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 355         }
 356
 357         if (VC_AUTH_STATE_NONE != state) {
 358                 if (0 != vc_auth_disable()) {
 359                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to auth disable");
 360                 }
 361         }
 362
 363         int ret = vc_dbus_request_finalize(g_vc->handle);
 364         if (0 != ret) {
 365                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request finalize : %s", __vc_get_error_code(ret));
 366         }
 367
 368
 369 #if 0
 370         ecore_event_handler_del(g_focus_in_hander);
 371         ecore_event_handler_del(g_focus_out_hander);
 372 #endif
 373
 374         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_FOREGROUND);
 375         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_BACKGROUND);
 376
 377         return;
 378 }
 379
 380 int vc_deinitialize(void)
 381 {
 382         if (0 != __vc_get_feature_enabled()) {
 383                 return VC_ERROR_NOT_SUPPORTED;
 384         }
 385         if (0 != __vc_check_privilege()) {
 386                 return VC_ERROR_PERMISSION_DENIED;
 387         }
 388
 389         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Deinitialize");
 390
 391         if (false == vc_client_is_valid(g_vc)) {
 392                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NOT initialized");
 393                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 394                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 395                 return VC_ERROR_INVALID_STATE;
 396         }
 397
 398         vc_state_e state;
 399         vc_client_get_client_state(g_vc, &state);
 400
 401         /* check state */
 402         switch (state) {
 403         case VC_STATE_READY:
 404                 __vc_internal_unprepare();
 405                 /* no break. need to next step*/
 406         case VC_STATE_INITIALIZED:
 407                 if (NULL != g_connect_timer) {
 408                         SLOG(LOG_DEBUG, TAG_VCC, "Connect Timer is deleted");
 409                         ecore_timer_del(g_connect_timer);
 410                 }
 411
 412                 vc_config_mgr_unset_lang_cb(g_vc->handle);
 413                 vc_config_mgr_finalize(g_vc->handle);
 414
 415                 /* Free client resources */
 416                 vc_client_destroy(g_vc);
 417                 g_vc = NULL;
 418                 break;
 419         case VC_STATE_NONE:
 420                 break;
 421         default:
 422                 break;
 423         }
 424
 425         SLOG(LOG_DEBUG, TAG_VCC, "Success: destroy");
 426
 427         if (0 != vc_dbus_close_connection()) {
 428                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to close connection");
 429         }
 430
 431         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 432         SLOG(LOG_DEBUG, TAG_VCC, " ");
 433
 434         return VC_ERROR_NONE;
 435 }
 436
 437 #if 0
 438 static Eina_Bool __vc_x_event_window_focus_in(void *data, int type, void *event)
 439 {
 440         Ecore_X_Event_Window_Focus_In *e;
 441
 442         e = event;
 443
 444         int xid = -1;
 445         if (0 != vc_client_get_xid(g_vc, &xid)) {
 446                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
 447                 return ECORE_CALLBACK_PASS_ON;
 448         }
 449
 450         if (e->win == (Ecore_X_Window)xid) {
 451                 SLOG(LOG_DEBUG, TAG_VCC, "Focus in : pid(%d) xid(%d)", getpid(), xid);
 452                 int ret = vc_config_mgr_set_foreground(getpid(), true);
 453                 if (0 != ret) {
 454                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 455                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
 456                 }
 457                 /* set authority valid */
 458                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 459                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 460                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 461                 }
 462                 if (VC_AUTH_STATE_INVALID == state) {
 463                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_VALID);
 464
 465                         /* notify auth changed cb */
 466                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 467                 }
 468         }
 469
 470         return ECORE_CALLBACK_PASS_ON;
 471 }
 472
 473 static Eina_Bool __vc_x_event_window_focus_out(void *data, int type, void *event)
 474 {
 475         Ecore_X_Event_Window_Focus_In *e;
 476
 477         e = event;
 478
 479         int xid = -1;
 480         if (0 != vc_client_get_xid(g_vc, &xid)) {
 481                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current xid");
 482                 return ECORE_CALLBACK_PASS_ON;
 483         }
 484
 485         if (e->win == (Ecore_X_Window)xid) {
 486                 SLOG(LOG_DEBUG, TAG_VCC, "Focus out : pid(%d) xid(%d)", getpid(), xid);
 487                 int ret = vc_config_mgr_set_foreground(getpid(), false);
 488                 if (0 != ret) {
 489                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 490                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus out : %s", __vc_get_error_code(ret));
 491                 }
 492                 /* set authority valid */
 493                 vc_auth_state_e state = VC_AUTH_STATE_NONE;
 494                 if (0 != vc_client_get_auth_state(g_vc, &state)) {
 495                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
 496                 }
 497                 if (VC_AUTH_STATE_VALID == state) {
 498                         vc_client_set_auth_state(g_vc, VC_AUTH_STATE_INVALID);
 499
 500                         /* notify authority changed cb */
 501                         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
 502                 }
 503         }
 504
 505         return ECORE_CALLBACK_PASS_ON;
 506 }
 507 #endif
 508
 509 static Eina_Bool __vc_connect_daemon(void *data)
 510 {
 511         /* Send hello */
 512         if (0 != vc_dbus_request_hello()) {
 513                 return EINA_TRUE;
 514         }
 515
 516         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Connect daemon");
 517
 518         /* request initialization */
 519         int ret = -1;
 520         int mgr_pid = -1;
 521         int service_state = 0;
 522         ret = vc_dbus_request_initialize(g_vc->handle, &mgr_pid, &service_state);
 523         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 524                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize : %s", __vc_get_error_code(ret));
 525
 526                 vc_client_set_error(g_vc, VC_ERROR_ENGINE_NOT_FOUND);
 527                 ecore_timer_add(0, __vc_notify_error, g_vc);
 528
 529                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 530                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 531                 return EINA_FALSE;
 532
 533         } else if (0 != ret) {
 534                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to initialize :%s", __vc_get_error_code(ret));
 535
 536                 vc_client_set_error(g_vc, VC_ERROR_TIMED_OUT);
 537                 ecore_timer_add(0, __vc_notify_error, g_vc);
 538
 539                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 540                 SLOG(LOG_DEBUG, TAG_VCC, "  ");
 541                 return EINA_FALSE;
 542         } else {
 543                 /* Success to connect */
 544         }
 545
 546         /* Set service state */
 547         vc_client_set_service_state(g_vc, (vc_service_state_e)service_state);
 548
 549         g_connect_timer = NULL;
 550 #if 0
 551         g_focus_in_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, __vc_x_event_window_focus_in, NULL);
 552         g_focus_out_hander = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, __vc_x_event_window_focus_out, NULL);
 553 #else
 554         ret = aul_add_status_local_cb(__vc_app_state_changed_cb, NULL);
 555         if (0 != ret) {
 556                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set app stae changed callback");
 557         }
 558 #endif
 559         vc_client_set_client_state(g_vc, VC_STATE_READY);
 560         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 561
 562         vc_client_set_mgr_pid(g_vc, mgr_pid);
 563
 564         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 565         SLOG(LOG_DEBUG, TAG_VCC, "  ");
 566
 567         return EINA_FALSE;
 568 }
 569
 570 int vc_prepare(void)
 571 {
 572         if (0 != __vc_get_feature_enabled()) {
 573                 return VC_ERROR_NOT_SUPPORTED;
 574         }
 575         if (0 != __vc_check_privilege()) {
 576                 return VC_ERROR_PERMISSION_DENIED;
 577         }
 578
 579         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Prepare");
 580
 581         vc_state_e state;
 582         if (0 != vc_client_get_client_state(g_vc, &state)) {
 583                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 584                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 585                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 586                 return VC_ERROR_INVALID_STATE;
 587         }
 588
 589         /* check state */
 590         if (state != VC_STATE_INITIALIZED) {
 591                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 592                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 593                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 594                 return VC_ERROR_INVALID_STATE;
 595         }
 596
 597         g_connect_timer = ecore_timer_add(0, __vc_connect_daemon, NULL);
 598
 599         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 600         SLOG(LOG_DEBUG, TAG_VCC, " ");
 601
 602         return VC_ERROR_NONE;
 603 }
 604
 605 int vc_unprepare(void)
 606 {
 607         if (0 != __vc_get_feature_enabled()) {
 608                 return VC_ERROR_NOT_SUPPORTED;
 609         }
 610         if (0 != __vc_check_privilege()) {
 611                 return VC_ERROR_PERMISSION_DENIED;
 612         }
 613
 614         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unprepare");
 615
 616         vc_state_e state;
 617         if (0 != vc_client_get_client_state(g_vc, &state)) {
 618                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 619                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 620                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 621                 return VC_ERROR_INVALID_STATE;
 622         }
 623
 624         /* check state */
 625         if (state != VC_STATE_READY) {
 626                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 627                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 628                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 629                 return VC_ERROR_INVALID_STATE;
 630         }
 631
 632         __vc_internal_unprepare();
 633
 634         vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
 635         ecore_timer_add(0, __vc_notify_state_changed, g_vc);
 636
 637         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 638         SLOG(LOG_DEBUG, TAG_VCC, " ");
 639
 640         return VC_ERROR_NONE;
 641 }
 642
 643 int vc_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 644 {
 645         if (0 != __vc_get_feature_enabled()) {
 646                 return VC_ERROR_NOT_SUPPORTED;
 647         }
 648         if (0 != __vc_check_privilege()) {
 649                 return VC_ERROR_PERMISSION_DENIED;
 650         }
 651
 652         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Foreach Supported Language");
 653
 654         if (NULL == callback) {
 655                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 656                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 657                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 658                 return VC_ERROR_INVALID_PARAMETER;
 659         }
 660
 661         vc_state_e state;
 662         if (0 != vc_client_get_client_state(g_vc, &state)) {
 663                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 664                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 665                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 666                 return VC_ERROR_INVALID_STATE;
 667         }
 668
 669         int ret = -1;
 670         ret = vc_config_mgr_get_language_list(callback, user_data);
 671         if (0 != ret) {
 672                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 673                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get languages : %s", __vc_get_error_code(ret));
 674         }
 675
 676         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 677         SLOG(LOG_DEBUG, TAG_VCC, " ");
 678
 679         return VC_ERROR_NONE;
 680 }
 681
 682
 683 int vc_get_current_language(char** language)
 684 {
 685         if (0 != __vc_get_feature_enabled()) {
 686                 return VC_ERROR_NOT_SUPPORTED;
 687         }
 688         if (0 != __vc_check_privilege()) {
 689                 return VC_ERROR_PERMISSION_DENIED;
 690         }
 691
 692         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Current Language");
 693
 694         if (NULL == language) {
 695                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 696                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 697                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 698                 return VC_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         vc_state_e state;
 702         if (0 != vc_client_get_client_state(g_vc, &state)) {
 703                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 704                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 705                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 706                 return VC_ERROR_INVALID_STATE;
 707         }
 708
 709         int ret = -1;
 710         ret = vc_config_mgr_get_default_language(language);
 711         if (0 != ret) {
 712                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 713                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get current languages : %s", __vc_get_error_code(ret));
 714         }
 715
 716         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 717         SLOG(LOG_DEBUG, TAG_VCC, " ");
 718
 719         return ret;
 720 }
 721
 722 int vc_get_state(vc_state_e* state)
 723 {
 724         if (0 != __vc_get_feature_enabled()) {
 725                 return VC_ERROR_NOT_SUPPORTED;
 726         }
 727         if (0 != __vc_check_privilege()) {
 728                 return VC_ERROR_PERMISSION_DENIED;
 729         }
 730
 731         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get State");
 732
 733         if (NULL == state) {
 734                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 735                 return VC_ERROR_INVALID_PARAMETER;
 736         }
 737
 738         vc_state_e temp;
 739         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 740                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 741                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 742                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 743                 return VC_ERROR_INVALID_STATE;
 744         }
 745
 746         *state = temp;
 747
 748         switch (*state) {
 749         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'None'");            break;
 750         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Created'");         break;
 751         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current state is 'Ready'");           break;
 752         default:                        SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
 753         }
 754
 755         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 756         SLOG(LOG_DEBUG, TAG_VCC, " ");
 757
 758         return VC_ERROR_NONE;
 759 }
 760
 761 int vc_get_service_state(vc_service_state_e* state)
 762 {
 763         if (0 != __vc_get_feature_enabled()) {
 764                 return VC_ERROR_NOT_SUPPORTED;
 765         }
 766         if (0 != __vc_check_privilege()) {
 767                 return VC_ERROR_PERMISSION_DENIED;
 768         }
 769
 770         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Service State");
 771
 772         if (NULL == state) {
 773                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 774                 return VC_ERROR_INVALID_PARAMETER;
 775         }
 776
 777         vc_state_e temp;
 778         if (0 != vc_client_get_client_state(g_vc, &temp)) {
 779                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 780                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 781                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 782                 return VC_ERROR_INVALID_STATE;
 783         }
 784
 785         if (VC_STATE_READY != temp) {
 786                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 787                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 788                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 789                 return VC_ERROR_INVALID_STATE;
 790         }
 791
 792         /* get service state */
 793         vc_service_state_e service_state;
 794         if (0 != vc_client_get_service_state(g_vc, &service_state)) {
 795                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get service state");
 796                 return VC_ERROR_OPERATION_FAILED;
 797         }
 798
 799         *state = service_state;
 800
 801         switch (*state) {
 802         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'None'");            break;
 803         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Ready'");           break;
 804         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Recording'");       break;
 805         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCC, "Current service state is 'Processing'");      break;
 806         default:                                SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid state");
 807         }
 808
 809         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 810         SLOG(LOG_DEBUG, TAG_VCC, " ");
 811
 812         return VC_ERROR_NONE;
 813 }
 814
 815 #if 0
 816 int vc_set_window_id(int wid)
 817 {
 818         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Window id");
 819
 820         if (0 >= wid) {
 821                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is invalid");
 822                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 823                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 824                 return VC_ERROR_INVALID_PARAMETER;
 825         }
 826
 827         vc_state_e state;
 828         if (0 != vc_client_get_client_state(g_vc, &state)) {
 829                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 830                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 831                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 832                 return VC_ERROR_INVALID_STATE;
 833         }
 834
 835         /* check state */
 836         if (state != VC_STATE_READY) {
 837                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 838                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 839                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 840                 return VC_ERROR_INVALID_STATE;
 841         }
 842
 843         if (0 != vc_client_set_xid(g_vc, wid)) {
 844                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
 845                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 846                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 847                 return VC_ERROR_INVALID_STATE;
 848         }
 849
 850         /* Check if current xid is top window */
 851         int ret = -1;
 852         if ((Ecore_X_Window)wid == ecore_x_window_focus_get()) {
 853                 /* Set current pid */
 854                 ret = vc_config_mgr_set_foreground(getpid(), true);
 855                 if (0 != ret) {
 856                         ret = vc_config_convert_error_code((vc_config_error_e)ret);
 857                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set focus in : %s", __vc_get_error_code(ret));
 858                 }
 859         }
 860
 861         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 862         SLOG(LOG_DEBUG, TAG_VCC, " ");
 863
 864         return ret;
 865 }
 866
 867 int vc_get_window_id(int* wid)
 868 {
 869         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get Window id");
 870
 871         if (NULL == wid) {
 872                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 873                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 874                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 875                 return VC_ERROR_INVALID_PARAMETER;
 876         }
 877
 878         vc_state_e state;
 879         if (0 != vc_client_get_client_state(g_vc, &state)) {
 880                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 881                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 882                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 883                 return VC_ERROR_INVALID_STATE;
 884         }
 885
 886         /* check state */
 887         if (state != VC_STATE_READY) {
 888                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 889                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 890                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 891                 return VC_ERROR_INVALID_STATE;
 892         }
 893
 894         if (0 != vc_client_get_xid(g_vc, wid)) {
 895                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
 896                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 897                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 898                 return VC_ERROR_INVALID_STATE;
 899         }
 900
 901         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 902         SLOG(LOG_DEBUG, TAG_VCC, " ");
 903
 904         return VC_ERROR_NONE;
 905 }
 906 #endif
 907
 908 /**
 909 * @brief Checks whether the command format is supported.
 910 * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
 911 *
 912 * @param[in] format The command format
 913 * @param[out] support The result status @c true = supported, @c false = not supported
 914 *
 915 * @return 0 on success, otherwise a negative error value
 916 * @retval #VC_ERROR_NONE Successful
 917 * @retval #VC_ERROR_INVALID_PARAMETER Invalid parameter
 918 * @retval #VC_ERROR_OPERATION_FAILED Operation failure
 919 * @retval #VC_ERROR_INVALID_STATE Invalid state
 920 *
 921 * @pre The state should be #VC_STATE_READY.
 922 */
 923 #if 0
 924 int vc_is_command_format_supported(vc_cmd_format_e format, bool* support)
 925 {
 926         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Is command format supported");
 927
 928         vc_state_e state;
 929         if (0 != vc_client_get_client_state(g_vc, &state)) {
 930                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 931                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 932                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 933                 return VC_ERROR_INVALID_STATE;
 934         }
 935
 936         /* check support */
 937         bool non_fixed_support = false;
 938         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 939                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get nonfixed support info");
 940         }
 941
 942         switch (format) {
 943         case VC_CMD_FORMAT_FIXED:                       *support = true;                break;
 944         case VC_CMD_FORMAT_FIXED_AND_EXTRA:     *support = non_fixed_support;   break;
 945         case VC_CMD_FORMAT_EXTRA_AND_FIXED:     *support = non_fixed_support;   break;
 946         default:                                        *support = false;               break;
 947         }
 948
 949         SLOG(LOG_ERROR, TAG_VCC, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 950
 951         SLOG(LOG_DEBUG, TAG_VCC, "=====");
 952         SLOG(LOG_DEBUG, TAG_VCC, " ");
 953
 954         return VC_ERROR_NONE;
 955 }
 956 #endif
 957
 958 int vc_set_command_list(vc_cmd_list_h vc_cmd_list, int type)
 959 {
 960         if (0 != __vc_get_feature_enabled()) {
 961                 return VC_ERROR_NOT_SUPPORTED;
 962         }
 963         if (0 != __vc_check_privilege()) {
 964                 return VC_ERROR_PERMISSION_DENIED;
 965         }
 966
 967         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list");
 968
 969         if (NULL == vc_cmd_list) {
 970                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Input parameter is NULL");
 971                 return VC_ERROR_INVALID_PARAMETER;
 972         }
 973
 974         vc_state_e state;
 975         if (0 != vc_client_get_client_state(g_vc, &state)) {
 976                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
 977                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 978                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 979                 return VC_ERROR_INVALID_STATE;
 980         }
 981
 982         /* check state */
 983         if (state != VC_STATE_READY) {
 984                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
 985                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 986                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 987                 return VC_ERROR_INVALID_STATE;
 988         }
 989
 990         /* check type */
 991         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
 992                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
 993                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 994                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 995                 return VC_ERROR_INVALID_PARAMETER;
 996         }
 997
 998         vc_cmd_list_s* list = NULL;
 999         list = (vc_cmd_list_s*)vc_cmd_list;
1000
1001         int ret = 0;
1002         if (0 != vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list)) {
1003                 ret = VC_ERROR_INVALID_PARAMETER;
1004                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1005         } else {
1006                 int count = 0;
1007                 do {
1008                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1009                         if (0 != ret) {
1010                                 if (VC_ERROR_TIMED_OUT != ret) {
1011                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1012                                         break;
1013                                 } else {
1014                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1015                                         usleep(10000);
1016                                         count++;
1017                                         if (VC_RETRY_COUNT == count) {
1018                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1019                                                 break;
1020                                         }
1021                                 }
1022                         }
1023                 } while (0 != ret);
1024         }
1025
1026         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1027         SLOG(LOG_DEBUG, TAG_VCC, " ");
1028
1029         return ret;
1030 }
1031
1032 int vc_unset_command_list(int type)
1033 {
1034         if (0 != __vc_get_feature_enabled()) {
1035                 return VC_ERROR_NOT_SUPPORTED;
1036         }
1037         if (0 != __vc_check_privilege()) {
1038                 return VC_ERROR_PERMISSION_DENIED;
1039         }
1040
1041         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1042
1043         vc_state_e state;
1044         if (0 != vc_client_get_client_state(g_vc, &state)) {
1045                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1046                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1047                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1048                 return VC_ERROR_INVALID_STATE;
1049         }
1050
1051         /* check state */
1052         if (state != VC_STATE_READY) {
1053                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1054                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1055                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1056                 return VC_ERROR_INVALID_STATE;
1057         }
1058
1059         int count = 0;
1060         int ret = -1;
1061         while (0 != ret) {
1062                 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1063                 if (0 != ret) {
1064                         if (VC_ERROR_TIMED_OUT != ret) {
1065                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1066                                 break;
1067                         } else {
1068                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1069                                 usleep(10000);
1070                                 count++;
1071                                 if (VC_RETRY_COUNT == count) {
1072                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1073                                         break;
1074                                 }
1075                         }
1076                 }
1077         }
1078
1079         ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1080         if (0 != ret) {
1081                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1082                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1083         }
1084
1085         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1086         SLOG(LOG_DEBUG, TAG_VCC, " ");
1087
1088         return ret;
1089 }
1090
1091 #if 0
1092 int vc_get_exclusive_command_option(bool* value)
1093 {
1094         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1095
1096         vc_state_e state;
1097         if (0 != vc_client_get_client_state(g_vc, &state)) {
1098                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1099                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1100                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1101                 return VC_ERROR_INVALID_STATE;
1102         }
1103
1104         /* check state */
1105         if (state != VC_STATE_READY) {
1106                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1107                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1108                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1109                 return VC_ERROR_INVALID_STATE;
1110         }
1111
1112         int ret = vc_client_get_exclusive_cmd(g_vc, value);
1113         if (0 != ret) {
1114                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1115                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1116                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1117                 return ret;
1118         }
1119
1120         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1121         SLOG(LOG_DEBUG, TAG_VCC, " ");
1122
1123         return ret;
1124 }
1125
1126 int vc_set_exclusive_command_option(bool value)
1127 {
1128         if (0 != __vc_get_feature_enabled()) {
1129                 return VC_ERROR_NOT_SUPPORTED;
1130         }
1131         if (0 != __vc_check_privilege()) {
1132                 return VC_ERROR_PERMISSION_DENIED;
1133         }
1134
1135         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
1136
1137         vc_state_e state;
1138         if (0 != vc_client_get_client_state(g_vc, &state)) {
1139                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1140                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1141                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1142                 return VC_ERROR_INVALID_STATE;
1143         }
1144
1145         /* check state */
1146         if (state != VC_STATE_READY) {
1147                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1148                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1149                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1150                 return VC_ERROR_INVALID_STATE;
1151         }
1152
1153         int ret = vc_client_set_exclusive_cmd(g_vc, value);
1154         if (0 != ret) {
1155                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1156                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1157                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1158                 return ret;
1159         }
1160
1161         /* Check if current xid is top window */
1162         int count = 0;
1163         do {
1164                 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1165                 if (0 != ret) {
1166                         if (VC_ERROR_TIMED_OUT != ret) {
1167                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1168                                 break;
1169                         } else {
1170                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1171                                 usleep(10000);
1172                                 count++;
1173                                 if (VC_RETRY_COUNT == count) {
1174                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1175                                         break;
1176                                 }
1177                         }
1178                 }
1179         } while (0 != ret);
1180
1181         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1182         SLOG(LOG_DEBUG, TAG_VCC, " ");
1183
1184         return ret;
1185 }
1186 #endif
1187
1188 #if 0
1189 int vc_request_start(bool stop_by_silence)
1190 {
1191         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1192
1193         vc_state_e state;
1194         if (0 != vc_client_get_client_state(g_vc, &state)) {
1195                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1196                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1197                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1198                 return VC_ERROR_INVALID_STATE;
1199         }
1200
1201         /* check state */
1202         if (state != VC_STATE_READY) {
1203                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1204                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1205                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1206                 return VC_ERROR_INVALID_STATE;
1207         }
1208
1209         /* Check service state */
1210         vc_service_state_e service_state = -1;
1211         vc_client_get_service_state(g_vc, &service_state);
1212         if (service_state != VC_SERVICE_STATE_READY) {
1213                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1214                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1215                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1216                 return VC_ERROR_INVALID_STATE;
1217         }
1218
1219         int ret;
1220         int count = 0;
1221
1222         /* Request */
1223         ret = -1;
1224         count = 0;
1225         while (0 != ret) {
1226                 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1227                 if (0 != ret) {
1228                         if (VC_ERROR_TIMED_OUT != ret) {
1229                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1230                                 break;
1231                         } else {
1232                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1233                                 usleep(10000);
1234                                 count++;
1235                                 if (VC_RETRY_COUNT == count) {
1236                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1237                                         break;
1238                                 }
1239                         }
1240                 } else {
1241                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1242                 }
1243         }
1244
1245         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1246         SLOG(LOG_DEBUG, TAG_VCC, " ");
1247
1248         return ret;
1249 }
1250
1251 int vc_request_stop(void)
1252 {
1253         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1254
1255         vc_state_e state;
1256         if (0 != vc_client_get_client_state(g_vc, &state)) {
1257                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1258                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1259                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1260                 return VC_ERROR_INVALID_STATE;
1261         }
1262
1263         /* check state */
1264         if (state != VC_STATE_READY) {
1265                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1266                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1267                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1268                 return VC_ERROR_INVALID_STATE;
1269         }
1270
1271         /* Check service state */
1272         vc_service_state_e service_state = -1;
1273         vc_client_get_service_state(g_vc, &service_state);
1274         if (service_state != VC_SERVICE_STATE_RECORDING) {
1275                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1276                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1277                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1278                 return VC_ERROR_INVALID_STATE;
1279         }
1280
1281         int ret = -1;
1282         int count = 0;
1283         /* do request */
1284         while (0 != ret) {
1285                 ret = vc_dbus_request_stop(g_vc->handle);
1286                 if (0 != ret) {
1287                         if (VC_ERROR_TIMED_OUT != ret) {
1288                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1289                                 break;
1290                         } else {
1291                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1292                                 usleep(10000);
1293                                 count++;
1294                                 if (VC_RETRY_COUNT == count) {
1295                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1296                                         break;
1297                                 }
1298                         }
1299                 } else {
1300                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1301                 }
1302         }
1303
1304         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1305         SLOG(LOG_DEBUG, TAG_VCC, " ");
1306
1307         return ret;
1308 }
1309
1310 int vc_request_cancel(void)
1311 {
1312         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1313
1314         vc_state_e state;
1315         if (0 != vc_client_get_client_state(g_vc, &state)) {
1316                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1317                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1318                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1319                 return VC_ERROR_INVALID_STATE;
1320         }
1321
1322         /* check state */
1323         if (state != VC_STATE_READY) {
1324                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1325                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1326                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1327                 return VC_ERROR_INVALID_STATE;
1328         }
1329
1330         /* Check service state */
1331         vc_service_state_e service_state = -1;
1332         vc_client_get_service_state(g_vc, &service_state);
1333         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1334                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1335                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1336                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1337                 return VC_ERROR_INVALID_STATE;
1338         }
1339
1340         int ret = -1;
1341         int count = 0;
1342         while (0 != ret) {
1343                 ret = vc_dbus_request_cancel(g_vc->handle);
1344                 if (0 != ret) {
1345                         if (VC_ERROR_TIMED_OUT != ret) {
1346                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1347                                 break;
1348                         } else {
1349                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1350                                 usleep(10000);
1351                                 count++;
1352                                 if (VC_RETRY_COUNT == count) {
1353                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1354                                         break;
1355                                 }
1356                         }
1357                 } else {
1358                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1359                 }
1360         }
1361
1362         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1363         SLOG(LOG_DEBUG, TAG_VCC, " ");
1364
1365         return ret;
1366 }
1367 #endif
1368
1369 Eina_Bool __vc_notify_error(void *data)
1370 {
1371         vc_h vc = (vc_h)data;
1372
1373         vc_error_cb callback = NULL;
1374         void* user_data;
1375         int reason;
1376
1377         vc_client_get_error_cb(vc, &callback, &user_data);
1378         vc_client_get_error(vc, &reason);
1379
1380         if (NULL != callback) {
1381                 vc_client_use_callback(vc);
1382                 callback(reason, user_data);
1383                 vc_client_not_use_callback(vc);
1384                 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1385         } else {
1386                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1387         }
1388
1389         return EINA_FALSE;
1390 }
1391
1392 int __vc_cb_error(int pid, int reason)
1393 {
1394         if (0 != vc_client_get_handle(pid, &g_vc)) {
1395                 SLOG(LOG_ERROR, TAG_VCC, "Handle is not valid : pid(%d)", pid);
1396                 return -1;
1397         }
1398
1399         vc_client_set_error(g_vc, reason);
1400         ecore_timer_add(0, __vc_notify_error, g_vc);
1401
1402         return 0;
1403 }
1404
1405 Eina_Bool __vc_notify_state_changed(void *data)
1406 {
1407         vc_h vc = (vc_h)data;
1408
1409         vc_state_changed_cb changed_callback = NULL;
1410         void* user_data;
1411
1412         vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1413
1414         vc_state_e current_state;
1415         vc_state_e before_state;
1416
1417         vc_client_get_before_state(vc, &current_state, &before_state);
1418
1419         if (NULL != changed_callback) {
1420                 vc_client_use_callback(vc);
1421                 changed_callback(before_state, current_state, user_data);
1422                 vc_client_not_use_callback(vc);
1423                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1424         } else {
1425                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1426         }
1427
1428         return EINA_FALSE;
1429 }
1430
1431 static Eina_Bool __vc_notify_result(void *data)
1432 {
1433         char* temp_text;
1434         int event;
1435         vc_cmd_list_h vc_cmd_list = NULL;
1436
1437         vc_result_cb callback = NULL;
1438         void* user_data = NULL;
1439
1440         vc_client_get_result_cb(g_vc, &callback, &user_data);
1441
1442         if (NULL == callback) {
1443                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1444                 return EINA_FALSE;
1445         }
1446
1447         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1448                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1449                 return EINA_FALSE;
1450         }
1451
1452         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1453
1454         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1455
1456         vc_cmd_print_list(vc_cmd_list);
1457
1458         vc_client_use_callback(g_vc);
1459         callback(event, vc_cmd_list, temp_text, user_data);
1460         vc_client_not_use_callback(g_vc);
1461
1462         SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1463
1464         vc_cmd_list_destroy(vc_cmd_list, true);
1465
1466         /* Release result */
1467         if (NULL != temp_text)  free(temp_text);
1468
1469         return EINA_FALSE;
1470 }
1471
1472 void __vc_cb_result(void)
1473 {
1474         ecore_timer_add(0, __vc_notify_result, NULL);
1475
1476         return;
1477 }
1478
1479 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1480 {
1481         if (0 != __vc_get_feature_enabled()) {
1482                 return VC_ERROR_NOT_SUPPORTED;
1483         }
1484         if (0 != __vc_check_privilege()) {
1485                 return VC_ERROR_PERMISSION_DENIED;
1486         }
1487
1488         if (NULL == callback)
1489                 return VC_ERROR_INVALID_PARAMETER;
1490
1491         vc_state_e state;
1492         if (0 != vc_client_get_client_state(g_vc, &state)) {
1493                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1494                 return VC_ERROR_INVALID_STATE;
1495         }
1496
1497         /* check state */
1498         if (state != VC_STATE_INITIALIZED) {
1499                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1500                 return VC_ERROR_INVALID_STATE;
1501         }
1502
1503         vc_client_set_result_cb(g_vc, callback, user_data);
1504
1505         return 0;
1506 }
1507
1508 int vc_unset_result_cb(void)
1509 {
1510         if (0 != __vc_get_feature_enabled()) {
1511                 return VC_ERROR_NOT_SUPPORTED;
1512         }
1513         if (0 != __vc_check_privilege()) {
1514                 return VC_ERROR_PERMISSION_DENIED;
1515         }
1516
1517         vc_state_e state;
1518         if (0 != vc_client_get_client_state(g_vc, &state)) {
1519                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1520                 return VC_ERROR_INVALID_STATE;
1521         }
1522
1523         /* check state */
1524         if (state != VC_STATE_INITIALIZED) {
1525                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1526                 return VC_ERROR_INVALID_STATE;
1527         }
1528
1529         vc_client_set_result_cb(g_vc, NULL, NULL);
1530
1531         return 0;
1532 }
1533
1534 int __vc_cb_service_state(int state)
1535 {
1536         vc_service_state_e current_state = (vc_service_state_e)state;
1537         vc_service_state_e before_state;
1538         vc_client_get_service_state(g_vc, &before_state);
1539
1540         if (current_state == before_state) {
1541                 return 0;
1542         }
1543
1544         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1545                 before_state, current_state);
1546
1547         /* Save service state */
1548         vc_client_set_service_state(g_vc, current_state);
1549
1550         vc_service_state_changed_cb callback = NULL;
1551         void* service_user_data;
1552         vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1553
1554         if (NULL != callback) {
1555                 vc_client_use_callback(g_vc);
1556                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1557                 vc_client_not_use_callback(g_vc);
1558                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1559         } else {
1560                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1561         }
1562
1563         return 0;
1564 }
1565
1566 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1567 {
1568         if (0 != __vc_get_feature_enabled()) {
1569                 return VC_ERROR_NOT_SUPPORTED;
1570         }
1571         if (0 != __vc_check_privilege()) {
1572                 return VC_ERROR_PERMISSION_DENIED;
1573         }
1574
1575         if (NULL == callback)
1576                 return VC_ERROR_INVALID_PARAMETER;
1577
1578         vc_state_e state;
1579         if (0 != vc_client_get_client_state(g_vc, &state)) {
1580                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1581                 return VC_ERROR_INVALID_STATE;
1582         }
1583
1584         /* check state */
1585         if (state != VC_STATE_INITIALIZED) {
1586                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1587                 return VC_ERROR_INVALID_STATE;
1588         }
1589
1590         vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1591
1592         return 0;
1593 }
1594
1595 int vc_unset_service_state_changed_cb(void)
1596 {
1597         if (0 != __vc_get_feature_enabled()) {
1598                 return VC_ERROR_NOT_SUPPORTED;
1599         }
1600         if (0 != __vc_check_privilege()) {
1601                 return VC_ERROR_PERMISSION_DENIED;
1602         }
1603
1604         vc_state_e state;
1605         if (0 != vc_client_get_client_state(g_vc, &state)) {
1606                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1607                 return VC_ERROR_INVALID_STATE;
1608         }
1609
1610         /* check state */
1611         if (state != VC_STATE_INITIALIZED) {
1612                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1613                 return VC_ERROR_INVALID_STATE;
1614         }
1615
1616         vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1617
1618         return 0;
1619 }
1620
1621 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1622 {
1623         if (0 != __vc_get_feature_enabled()) {
1624                 return VC_ERROR_NOT_SUPPORTED;
1625         }
1626         if (0 != __vc_check_privilege()) {
1627                 return VC_ERROR_PERMISSION_DENIED;
1628         }
1629
1630         if (callback == NULL)
1631                 return VC_ERROR_INVALID_PARAMETER;
1632
1633         vc_state_e state;
1634         if (0 != vc_client_get_client_state(g_vc, &state)) {
1635                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1636                 return VC_ERROR_INVALID_STATE;
1637         }
1638
1639         /* check state */
1640         if (state != VC_STATE_INITIALIZED) {
1641                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1642                 return VC_ERROR_INVALID_STATE;
1643         }
1644
1645         vc_client_set_state_changed_cb(g_vc, callback, user_data);
1646
1647         return 0;
1648 }
1649
1650 int vc_unset_state_changed_cb(void)
1651 {
1652         if (0 != __vc_get_feature_enabled()) {
1653                 return VC_ERROR_NOT_SUPPORTED;
1654         }
1655         if (0 != __vc_check_privilege()) {
1656                 return VC_ERROR_PERMISSION_DENIED;
1657         }
1658
1659         vc_state_e state;
1660         if (0 != vc_client_get_client_state(g_vc, &state)) {
1661                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1662                 return VC_ERROR_INVALID_STATE;
1663         }
1664
1665         /* check state */
1666         if (state != VC_STATE_INITIALIZED) {
1667                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1668                 return VC_ERROR_INVALID_STATE;
1669         }
1670
1671         vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1672
1673         return 0;
1674 }
1675
1676 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1677 {
1678         if (0 != __vc_get_feature_enabled()) {
1679                 return VC_ERROR_NOT_SUPPORTED;
1680         }
1681         if (0 != __vc_check_privilege()) {
1682                 return VC_ERROR_PERMISSION_DENIED;
1683         }
1684
1685         if (NULL == callback)
1686                 return VC_ERROR_INVALID_PARAMETER;
1687
1688         vc_state_e state;
1689         if (0 != vc_client_get_client_state(g_vc, &state)) {
1690                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1691                 return VC_ERROR_INVALID_STATE;
1692         }
1693
1694         /* check state */
1695         if (state != VC_STATE_INITIALIZED) {
1696                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1697                 return VC_ERROR_INVALID_STATE;
1698         }
1699
1700         vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1701
1702         return 0;
1703 }
1704
1705 int vc_unset_current_language_changed_cb(void)
1706 {
1707         if (0 != __vc_get_feature_enabled()) {
1708                 return VC_ERROR_NOT_SUPPORTED;
1709         }
1710         if (0 != __vc_check_privilege()) {
1711                 return VC_ERROR_PERMISSION_DENIED;
1712         }
1713
1714         vc_state_e state;
1715         if (0 != vc_client_get_client_state(g_vc, &state)) {
1716                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1717                 return VC_ERROR_INVALID_STATE;
1718         }
1719
1720         /* check state */
1721         if (state != VC_STATE_INITIALIZED) {
1722                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1723                 return VC_ERROR_INVALID_STATE;
1724         }
1725
1726         vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1727
1728         return 0;
1729 }
1730
1731 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1732 {
1733         if (0 != __vc_get_feature_enabled()) {
1734                 return VC_ERROR_NOT_SUPPORTED;
1735         }
1736         if (0 != __vc_check_privilege()) {
1737                 return VC_ERROR_PERMISSION_DENIED;
1738         }
1739
1740         if (NULL == callback)
1741                 return VC_ERROR_INVALID_PARAMETER;
1742
1743         vc_state_e state;
1744         if (0 != vc_client_get_client_state(g_vc, &state)) {
1745                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1746                 return VC_ERROR_INVALID_STATE;
1747         }
1748
1749         /* check state */
1750         if (state != VC_STATE_INITIALIZED) {
1751                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1752                 return VC_ERROR_INVALID_STATE;
1753         }
1754
1755         vc_client_set_error_cb(g_vc, callback,  user_data);
1756
1757         return 0;
1758 }
1759
1760 int vc_unset_error_cb(void)
1761 {
1762         if (0 != __vc_get_feature_enabled()) {
1763                 return VC_ERROR_NOT_SUPPORTED;
1764         }
1765         if (0 != __vc_check_privilege()) {
1766                 return VC_ERROR_PERMISSION_DENIED;
1767         }
1768
1769         vc_state_e state;
1770         if (0 != vc_client_get_client_state(g_vc, &state)) {
1771                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
1772                 return VC_ERROR_INVALID_STATE;
1773         }
1774
1775         /* check state */
1776         if (state != VC_STATE_INITIALIZED) {
1777                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
1778                 return VC_ERROR_INVALID_STATE;
1779         }
1780
1781         vc_client_set_error_cb(g_vc, NULL, NULL);
1782
1783         return 0;
1784 }
1785
1786 /* Authority */
1787 int vc_auth_enable(void)
1788 {
1789         /* check state */
1790         vc_state_e state;
1791         if (0 != vc_client_get_client_state(g_vc, &state)) {
1792                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1793                 return VC_ERROR_INVALID_STATE;
1794         }
1795
1796         if (VC_STATE_READY != state) {
1797                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1798                 return VC_ERROR_INVALID_STATE;
1799         }
1800
1801         /* check already authority */
1802         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1803         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1804                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1805                 return VC_ERROR_INVALID_STATE;
1806         }
1807
1808         if (VC_AUTH_STATE_NONE != auth_state) {
1809                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
1810                 return VC_ERROR_INVALID_STATE;
1811         }
1812
1813         /* request authority */
1814         int mgr_pid = -1;
1815         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1816                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1817                 return VC_ERROR_OPERATION_FAILED;
1818         }
1819
1820         if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
1821                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
1822                 return VC_ERROR_OPERATION_FAILED;
1823         }
1824
1825         /* set authority into handle */
1826         bool is_foreground = false;
1827         if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
1828                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
1829                 return VC_ERROR_OPERATION_FAILED;
1830         }
1831
1832         if (is_foreground) {
1833                 auth_state = VC_AUTH_STATE_VALID;
1834         } else {
1835                 auth_state = VC_AUTH_STATE_INVALID;
1836         }
1837
1838         if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
1839                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1840                 return VC_ERROR_OPERATION_FAILED;
1841         }
1842
1843         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1844
1845         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
1846
1847         return VC_ERROR_NONE;
1848 }
1849
1850 int vc_auth_disable(void)
1851 {
1852         /* check state */
1853         vc_state_e state;
1854         if (0 != vc_client_get_client_state(g_vc, &state)) {
1855                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1856                 return VC_ERROR_INVALID_STATE;
1857         }
1858
1859         if (VC_STATE_READY != state) {
1860                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1861                 return VC_ERROR_INVALID_STATE;
1862         }
1863
1864         /* check autority */
1865         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
1866         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1867                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1868                 return VC_ERROR_INVALID_STATE;
1869         }
1870
1871         if (VC_AUTH_STATE_NONE == auth_state) {
1872                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
1873                 return VC_ERROR_INVALID_STATE;
1874         }
1875
1876         if (0 != vc_auth_unset_state_changed_cb()) {
1877                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
1878         }
1879
1880         /* request return authority by dbus */
1881         int mgr_pid = -1;
1882         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
1883                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
1884                 return VC_ERROR_OPERATION_FAILED;
1885         }
1886
1887         if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
1888                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
1889                 return VC_ERROR_OPERATION_FAILED;
1890         }
1891
1892         /* unset authority from handle */
1893         if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
1894                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
1895                 return VC_ERROR_OPERATION_FAILED;
1896         }
1897
1898         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
1899
1900         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
1901
1902         return VC_ERROR_NONE;
1903 }
1904
1905 int vc_auth_get_state(vc_auth_state_e* state)
1906 {
1907         /* check state */
1908         vc_state_e vc_state;
1909         if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
1910                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1911                 return VC_ERROR_INVALID_STATE;
1912         }
1913
1914         if (VC_STATE_READY != vc_state) {
1915                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
1916                 return VC_ERROR_INVALID_STATE;
1917         }
1918
1919         /* get autority */
1920         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
1921         if (0 != vc_client_get_auth_state(g_vc, &temp)) {
1922                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
1923                 return VC_ERROR_INVALID_STATE;
1924         }
1925
1926         *state = temp;
1927
1928         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
1929
1930         return VC_ERROR_NONE;
1931 }
1932
1933 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
1934 {
1935         /* check parameter */
1936         if (NULL == callback) {
1937                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
1938                 return VC_ERROR_INVALID_PARAMETER;
1939         }
1940
1941         /* check auth */
1942         vc_auth_state_e auth_state;
1943         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1944                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1945                 return VC_ERROR_INVALID_STATE;
1946         }
1947
1948         if (VC_AUTH_STATE_NONE == auth_state) {
1949                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
1950                 return VC_ERROR_INVALID_STATE;
1951         }
1952
1953         /* set cb into handle */
1954         if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
1955                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
1956                 return VC_ERROR_OPERATION_FAILED;
1957         }
1958
1959         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
1960
1961         return VC_ERROR_NONE;
1962 }
1963
1964 int vc_auth_unset_state_changed_cb(void)
1965 {
1966         /* check auth */
1967         vc_auth_state_e auth_state;
1968         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
1969                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
1970                 return VC_ERROR_INVALID_STATE;
1971         }
1972
1973         if (VC_AUTH_STATE_NONE == auth_state) {
1974                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
1975                 return VC_ERROR_INVALID_STATE;
1976         }
1977
1978         /* unset cb from handle */
1979         if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
1980                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
1981                 return VC_ERROR_OPERATION_FAILED;
1982         }
1983
1984         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
1985
1986         return VC_ERROR_NONE;
1987 }
1988
1989 int vc_auth_start(void)
1990 {
1991         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1992
1993         vc_state_e state;
1994         if (0 != vc_client_get_client_state(g_vc, &state)) {
1995                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1996                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1997                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1998                 return VC_ERROR_INVALID_STATE;
1999         }
2000
2001         /* check state */
2002         if (state != VC_STATE_READY) {
2003                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2004                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2005                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2006                 return VC_ERROR_INVALID_STATE;
2007         }
2008
2009         /* Check service state */
2010         vc_service_state_e service_state = -1;
2011         vc_client_get_service_state(g_vc, &service_state);
2012         if (service_state != VC_SERVICE_STATE_READY) {
2013                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2014                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2015                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2016                 return VC_ERROR_INVALID_STATE;
2017         }
2018
2019         /* Check authority */
2020         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2021         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2022                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2023                 return VC_ERROR_OPERATION_FAILED;
2024         }
2025
2026         if (VC_AUTH_STATE_VALID != auth_state) {
2027                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2028                 return VC_ERROR_OPERATION_FAILED;
2029         }
2030
2031         /* get mgr_pid */
2032         int mgr_pid = -1;
2033         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2034                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2035                 return VC_ERROR_OPERATION_FAILED;
2036         }
2037
2038         int ret;
2039         int count = 0;
2040         /* Request */
2041         ret = -1;
2042         count = 0;
2043         while (0 != ret) {
2044                 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2045                 if (0 != ret) {
2046                         if (VC_ERROR_TIMED_OUT != ret) {
2047                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2048                                 break;
2049                         } else {
2050                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2051                                 usleep(10000);
2052                                 count++;
2053                                 if (VC_RETRY_COUNT == count) {
2054                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2055                                         break;
2056                                 }
2057                         }
2058                 } else {
2059                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2060                 }
2061         }
2062
2063         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2064         SLOG(LOG_DEBUG, TAG_VCC, " ");
2065
2066         return ret;
2067 }
2068
2069 int vc_auth_stop(void)
2070 {
2071         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
2072
2073         vc_state_e state;
2074         if (0 != vc_client_get_client_state(g_vc, &state)) {
2075                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2076                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2077                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2078                 return VC_ERROR_INVALID_STATE;
2079         }
2080
2081         /* check state */
2082         if (state != VC_STATE_READY) {
2083                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2084                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2085                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2086                 return VC_ERROR_INVALID_STATE;
2087         }
2088
2089         /* Check service state */
2090         vc_service_state_e service_state = -1;
2091         vc_client_get_service_state(g_vc, &service_state);
2092         if (service_state != VC_SERVICE_STATE_RECORDING) {
2093                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2094                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2095                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2096                 return VC_ERROR_INVALID_STATE;
2097         }
2098
2099         /* Check authority */
2100         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2101         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2102                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2103                 return VC_ERROR_OPERATION_FAILED;
2104         }
2105
2106         if (VC_AUTH_STATE_VALID != auth_state) {
2107                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2108                 return VC_ERROR_OPERATION_FAILED;
2109         }
2110
2111         /* get mgr_pid */
2112         int mgr_pid = -1;
2113         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2114                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2115                 return VC_ERROR_OPERATION_FAILED;
2116         }
2117
2118         int ret = -1;
2119         int count = 0;
2120         /* do request */
2121         while (0 != ret) {
2122                 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2123                 if (0 != ret) {
2124                         if (VC_ERROR_TIMED_OUT != ret) {
2125                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2126                                 break;
2127                         } else {
2128                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2129                                 usleep(10000);
2130                                 count++;
2131                                 if (VC_RETRY_COUNT == count) {
2132                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2133                                         break;
2134                                 }
2135                         }
2136                 } else {
2137                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2138                 }
2139         }
2140
2141         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2142         SLOG(LOG_DEBUG, TAG_VCC, " ");
2143
2144         return ret;
2145 }
2146
2147 int vc_auth_cancel(void)
2148 {
2149         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2150
2151         vc_state_e state;
2152         if (0 != vc_client_get_client_state(g_vc, &state)) {
2153                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2154                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2155                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2156                 return VC_ERROR_INVALID_STATE;
2157         }
2158
2159         /* check state */
2160         if (state != VC_STATE_READY) {
2161                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2162                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2163                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2164                 return VC_ERROR_INVALID_STATE;
2165         }
2166
2167         /* Check service state */
2168         vc_service_state_e service_state = -1;
2169         vc_client_get_service_state(g_vc, &service_state);
2170         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2171                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2172                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2173                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2174                 return VC_ERROR_INVALID_STATE;
2175         }
2176
2177         /* Check authority */
2178         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2179         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2180                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2181                 return VC_ERROR_OPERATION_FAILED;
2182         }
2183
2184         if (VC_AUTH_STATE_VALID != auth_state) {
2185                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2186                 return VC_ERROR_OPERATION_FAILED;
2187         }
2188
2189         /* get mgr_pid */
2190         int mgr_pid = -1;
2191         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2192                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2193                 return VC_ERROR_OPERATION_FAILED;
2194         }
2195
2196         int ret = -1;
2197         int count = 0;
2198         while (0 != ret) {
2199                 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2200                 if (0 != ret) {
2201                         if (VC_ERROR_TIMED_OUT != ret) {
2202                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2203                                 break;
2204                         } else {
2205                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2206                                 usleep(10000);
2207                                 count++;
2208                                 if (VC_RETRY_COUNT == count) {
2209                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2210                                         break;
2211                                 }
2212                         }
2213                 } else {
2214                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2215                 }
2216         }
2217
2218         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2219         SLOG(LOG_DEBUG, TAG_VCC, " ");
2220
2221         return ret;
2222 }