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