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