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