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         int ret = 0;
1060         char* invocation_name = NULL;
1061         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1062                 ret = __vc_get_invocation_name(&invocation_name);
1063                 if (0 != ret || NULL == invocation_name) {
1064                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1065                         return ret;
1066                 }
1067         }
1068
1069         ret = vc_cmd_parser_delete_file(getpid(), type);
1070         if (0 != ret)
1071                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1072
1073         ret = vc_cmd_parser_save_file(getpid(), (vc_cmd_type_e)type, list->list, invocation_name);
1074         if (0 != ret) {
1075                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to save command list : %s", __vc_get_error_code(ret));
1076         } else {
1077                 int count = 0;
1078                 do {
1079                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1080                         if (0 != ret) {
1081                                 if (VC_ERROR_TIMED_OUT != ret) {
1082                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1083                                         break;
1084                                 } else {
1085                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1086                                         usleep(10000);
1087                                         count++;
1088                                         if (VC_RETRY_COUNT == count) {
1089                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1090                                                 break;
1091                                         }
1092                                 }
1093                         }
1094                 } while (0 != ret);
1095         }
1096
1097         if (NULL != invocation_name) {
1098                 free(invocation_name);
1099                 invocation_name = NULL;
1100         }
1101
1102         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1103         SLOG(LOG_DEBUG, TAG_VCC, " ");
1104
1105         return ret;
1106 }
1107
1108 int vc_unset_command_list(int type)
1109 {
1110         if (0 != __vc_get_feature_enabled()) {
1111                 return VC_ERROR_NOT_SUPPORTED;
1112         }
1113         if (0 != __vc_check_privilege()) {
1114                 return VC_ERROR_PERMISSION_DENIED;
1115         }
1116
1117         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Unset Command list");
1118
1119         vc_state_e state;
1120         if (0 != vc_client_get_client_state(g_vc, &state)) {
1121                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1122                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1123                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1124                 return VC_ERROR_INVALID_STATE;
1125         }
1126
1127         /* check state */
1128         if (state != VC_STATE_READY) {
1129                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1130                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1131                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1132                 return VC_ERROR_INVALID_STATE;
1133         }
1134
1135         int count = 0;
1136         int ret = -1;
1137         while (0 != ret) {
1138                 ret = vc_dbus_request_unset_command(g_vc->handle, (vc_cmd_type_e)type);
1139                 if (0 != ret) {
1140                         if (VC_ERROR_TIMED_OUT != ret) {
1141                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset command to daemon : %s", __vc_get_error_code(ret));
1142                                 break;
1143                         } else {
1144                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset command : %s", __vc_get_error_code(ret));
1145                                 usleep(10000);
1146                                 count++;
1147                                 if (VC_RETRY_COUNT == count) {
1148                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1149                                         break;
1150                                 }
1151                         }
1152                 }
1153         }
1154
1155         ret = vc_cmd_parser_delete_file(getpid(), (vc_cmd_type_e)type);
1156         if (0 != ret) {
1157                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
1158                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] cmd_type(%d), Fail to delete command list : %s", type, __vc_get_error_code(ret));
1159         }
1160
1161         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1162         SLOG(LOG_DEBUG, TAG_VCC, " ");
1163
1164         return ret;
1165 }
1166
1167 int vc_set_command_list_from_file(const char* file_path, int type)
1168 {
1169         if (0 != __vc_get_feature_enabled()) {
1170                 return VC_ERROR_NOT_SUPPORTED;
1171         }
1172         if (0 != __vc_check_privilege()) {
1173                 return VC_ERROR_PERMISSION_DENIED;
1174         }
1175
1176         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set Command list from file");
1177
1178         vc_state_e state;
1179         if (0 != vc_client_get_client_state(g_vc, &state)) {
1180                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1181                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1182                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1183                 return VC_ERROR_INVALID_STATE;
1184         }
1185
1186         /* check state */
1187         if (state != VC_STATE_READY) {
1188                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1189                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1190                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1191                 return VC_ERROR_INVALID_STATE;
1192         }
1193
1194         /* check type */
1195         if ((VC_COMMAND_TYPE_FOREGROUND != type) && (VC_COMMAND_TYPE_BACKGROUND != type)) {
1196                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
1197                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1198                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1199                 return VC_ERROR_INVALID_PARAMETER;
1200         }
1201
1202         int ret = 0;
1203         char* invocation_name = NULL;
1204         if (VC_COMMAND_TYPE_BACKGROUND == type) {
1205                 ret = __vc_get_invocation_name(&invocation_name);
1206                 if (0 != ret || NULL == invocation_name) {
1207                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get invocation name, ret(%d)", ret);
1208                         return ret;
1209                 }
1210         }
1211
1212         ret = vc_cmd_parser_delete_file(getpid(), type);
1213         if (0 != ret)
1214                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to delete file, type(%d), ret(%d)", type, ret);
1215
1216         ret = vc_json_set_commands_from_file(file_path, (vc_cmd_type_e)type, invocation_name);
1217         if (0 != ret) {
1218                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set commands from file : %s", __vc_get_error_code(ret));
1219         } else {
1220                 int count = 0;
1221                 do {
1222                         ret = vc_dbus_request_set_command(g_vc->handle, (vc_cmd_type_e)type);
1223                         if (0 != ret) {
1224                                 if (VC_ERROR_TIMED_OUT != ret) {
1225                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set command to daemon : %s", __vc_get_error_code(ret));
1226                                         break;
1227                                 } else {
1228                                         SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set command : %s", __vc_get_error_code(ret));
1229                                         usleep(10000);
1230                                         count++;
1231                                         if (VC_RETRY_COUNT == count) {
1232                                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1233                                                 break;
1234                                         }
1235                                 }
1236                         }
1237                 } while (0 != ret);
1238         }
1239
1240         if (NULL != invocation_name) {
1241                 free(invocation_name);
1242                 invocation_name = NULL;
1243         }
1244
1245         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1246         SLOG(LOG_DEBUG, TAG_VCC, " ");
1247         return ret;
1248 }
1249
1250 #if 0
1251 int vc_get_exclusive_command_option(bool* value)
1252 {
1253         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get exclusive command");
1254
1255         vc_state_e state;
1256         if (0 != vc_client_get_client_state(g_vc, &state)) {
1257                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1258                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1259                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1260                 return VC_ERROR_INVALID_STATE;
1261         }
1262
1263         /* check state */
1264         if (state != VC_STATE_READY) {
1265                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1266                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1267                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1268                 return VC_ERROR_INVALID_STATE;
1269         }
1270
1271         int ret = vc_client_get_exclusive_cmd(g_vc, value);
1272         if (0 != ret) {
1273                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1274                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1275                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1276                 return ret;
1277         }
1278
1279         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1280         SLOG(LOG_DEBUG, TAG_VCC, " ");
1281
1282         return ret;
1283 }
1284
1285 int vc_set_exclusive_command_option(bool value)
1286 {
1287         if (0 != __vc_get_feature_enabled()) {
1288                 return VC_ERROR_NOT_SUPPORTED;
1289         }
1290         if (0 != __vc_check_privilege()) {
1291                 return VC_ERROR_PERMISSION_DENIED;
1292         }
1293
1294         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Set exclusive command");
1295
1296         vc_state_e state;
1297         if (0 != vc_client_get_client_state(g_vc, &state)) {
1298                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1299                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1300                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1301                 return VC_ERROR_INVALID_STATE;
1302         }
1303
1304         /* check state */
1305         if (state != VC_STATE_READY) {
1306                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
1307                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1308                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1309                 return VC_ERROR_INVALID_STATE;
1310         }
1311
1312         int ret = vc_client_set_exclusive_cmd(g_vc, value);
1313         if (0 != ret) {
1314                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set exclusive option : %d", ret);
1315                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1316                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1317                 return ret;
1318         }
1319
1320         int count = 0;
1321         do {
1322                 ret = vc_dbus_request_set_exclusive_command(g_vc->handle, value);
1323                 if (0 != ret) {
1324                         if (VC_ERROR_TIMED_OUT != ret) {
1325                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set exclusive command to daemon : %s", __vc_get_error_code(ret));
1326                                 break;
1327                         } else {
1328                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set exclusive command : %s", __vc_get_error_code(ret));
1329                                 usleep(10000);
1330                                 count++;
1331                                 if (VC_RETRY_COUNT == count) {
1332                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1333                                         break;
1334                                 }
1335                         }
1336                 }
1337         } while (0 != ret);
1338
1339         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1340         SLOG(LOG_DEBUG, TAG_VCC, " ");
1341
1342         return ret;
1343 }
1344 #endif
1345
1346 #if 0
1347 int vc_request_start(bool stop_by_silence)
1348 {
1349         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
1350
1351         vc_state_e state;
1352         if (0 != vc_client_get_client_state(g_vc, &state)) {
1353                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1354                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1355                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1356                 return VC_ERROR_INVALID_STATE;
1357         }
1358
1359         /* check state */
1360         if (state != VC_STATE_READY) {
1361                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
1362                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1363                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1364                 return VC_ERROR_INVALID_STATE;
1365         }
1366
1367         /* Check service state */
1368         vc_service_state_e service_state = -1;
1369         vc_client_get_service_state(g_vc, &service_state);
1370         if (service_state != VC_SERVICE_STATE_READY) {
1371                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
1372                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1373                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1374                 return VC_ERROR_INVALID_STATE;
1375         }
1376
1377         int ret;
1378         int count = 0;
1379
1380         /* Request */
1381         ret = -1;
1382         count = 0;
1383         while (0 != ret) {
1384                 ret = vc_dbus_request_start(g_vc->handle, stop_by_silence);
1385                 if (0 != ret) {
1386                         if (VC_ERROR_TIMED_OUT != ret) {
1387                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to start request start : %s", __vc_get_error_code(ret));
1388                                 break;
1389                         } else {
1390                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry start request start : %s", __vc_get_error_code(ret));
1391                                 usleep(10000);
1392                                 count++;
1393                                 if (VC_RETRY_COUNT == count) {
1394                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1395                                         break;
1396                                 }
1397                         }
1398                 } else {
1399                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] start interrupt");
1400                 }
1401         }
1402
1403         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1404         SLOG(LOG_DEBUG, TAG_VCC, " ");
1405
1406         return ret;
1407 }
1408
1409 int vc_request_stop(void)
1410 {
1411         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
1412
1413         vc_state_e state;
1414         if (0 != vc_client_get_client_state(g_vc, &state)) {
1415                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1416                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1417                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1418                 return VC_ERROR_INVALID_STATE;
1419         }
1420
1421         /* check state */
1422         if (state != VC_STATE_READY) {
1423                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
1424                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1425                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1426                 return VC_ERROR_INVALID_STATE;
1427         }
1428
1429         /* Check service state */
1430         vc_service_state_e service_state = -1;
1431         vc_client_get_service_state(g_vc, &service_state);
1432         if (service_state != VC_SERVICE_STATE_RECORDING) {
1433                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
1434                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1435                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1436                 return VC_ERROR_INVALID_STATE;
1437         }
1438
1439         int ret = -1;
1440         int count = 0;
1441         /* do request */
1442         while (0 != ret) {
1443                 ret = vc_dbus_request_stop(g_vc->handle);
1444                 if (0 != ret) {
1445                         if (VC_ERROR_TIMED_OUT != ret) {
1446                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to stop request : %s", __vc_get_error_code(ret));
1447                                 break;
1448                         } else {
1449                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry stop request : %s", __vc_get_error_code(ret));
1450                                 usleep(10000);
1451                                 count++;
1452                                 if (VC_RETRY_COUNT == count) {
1453                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1454                                         break;
1455                                 }
1456                         }
1457                 } else {
1458                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Stop interrupt");
1459                 }
1460         }
1461
1462         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1463         SLOG(LOG_DEBUG, TAG_VCC, " ");
1464
1465         return ret;
1466 }
1467
1468 int vc_request_cancel(void)
1469 {
1470         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel Interrupt");
1471
1472         vc_state_e state;
1473         if (0 != vc_client_get_client_state(g_vc, &state)) {
1474                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1475                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1476                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1477                 return VC_ERROR_INVALID_STATE;
1478         }
1479
1480         /* check state */
1481         if (state != VC_STATE_READY) {
1482                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
1483                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1484                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1485                 return VC_ERROR_INVALID_STATE;
1486         }
1487
1488         /* Check service state */
1489         vc_service_state_e service_state = -1;
1490         vc_client_get_service_state(g_vc, &service_state);
1491         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1492                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1493                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
1494                 SLOG(LOG_DEBUG, TAG_VCC, " ");
1495                 return VC_ERROR_INVALID_STATE;
1496         }
1497
1498         int ret = -1;
1499         int count = 0;
1500         while (0 != ret) {
1501                 ret = vc_dbus_request_cancel(g_vc->handle);
1502                 if (0 != ret) {
1503                         if (VC_ERROR_TIMED_OUT != ret) {
1504                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to cancel request : %s", __vc_get_error_code(ret));
1505                                 break;
1506                         } else {
1507                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel request : %s", __vc_get_error_code(ret));
1508                                 usleep(10000);
1509                                 count++;
1510                                 if (VC_RETRY_COUNT == count) {
1511                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
1512                                         break;
1513                                 }
1514                         }
1515                 } else {
1516                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Cancel interrupt");
1517                 }
1518         }
1519
1520         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1521         SLOG(LOG_DEBUG, TAG_VCC, " ");
1522
1523         return ret;
1524 }
1525 #endif
1526
1527 Eina_Bool __vc_notify_error(void *data)
1528 {
1529         vc_h vc = (vc_h)data;
1530
1531         vc_error_cb callback = NULL;
1532         void* user_data;
1533         int reason;
1534
1535         vc_client_get_error_cb(vc, &callback, &user_data);
1536         vc_client_get_error(vc, &reason);
1537
1538         if (NULL != callback) {
1539                 vc_client_use_callback(vc);
1540                 callback(reason, user_data);
1541                 vc_client_not_use_callback(vc);
1542                 SLOG(LOG_DEBUG, TAG_VCC, "Error callback is called");
1543         } else {
1544                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Error callback is null");
1545         }
1546
1547         return EINA_FALSE;
1548 }
1549
1550 int __vc_cb_error(int reason, int daemon_pid, char* msg)
1551 {
1552         vc_state_e state;
1553         if (0 != vc_client_get_client_state(g_vc, &state)) {
1554                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid client");
1555                 return -1;
1556         }
1557
1558         /* check state */
1559         if (state != VC_STATE_READY) {
1560                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] not connected client yet");
1561                 return -1;
1562         }
1563
1564         if (VC_ERROR_SERVICE_RESET == reason) {
1565                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] VC daemon reset");
1566
1567                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
1568                 __vc_notify_state_changed(g_vc);
1569
1570                 if (0 != vc_prepare()) {
1571                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to prepare");
1572                 }
1573         }
1574
1575         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1576
1577         vc_client_set_error(g_vc, reason);
1578         ecore_timer_add(0, __vc_notify_error, g_vc);
1579
1580         return 0;
1581 }
1582
1583 Eina_Bool __vc_notify_state_changed(void *data)
1584 {
1585         vc_h vc = (vc_h)data;
1586
1587         vc_state_changed_cb changed_callback = NULL;
1588         void* user_data;
1589
1590         vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1591
1592         vc_state_e current_state;
1593         vc_state_e before_state;
1594
1595         vc_client_get_before_state(vc, &current_state, &before_state);
1596
1597         if (NULL != changed_callback) {
1598                 vc_client_use_callback(vc);
1599                 changed_callback(before_state, current_state, user_data);
1600                 vc_client_not_use_callback(vc);
1601                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1602         } else {
1603                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1604         }
1605
1606         return EINA_FALSE;
1607 }
1608
1609 static Eina_Bool __vc_notify_result(void *data)
1610 {
1611         char* temp_text;
1612         int event;
1613         vc_cmd_list_h vc_cmd_list = NULL;
1614
1615         vc_result_cb callback = NULL;
1616         void* user_data = NULL;
1617
1618         vc_client_get_result_cb(g_vc, &callback, &user_data);
1619
1620         if (NULL == callback) {
1621                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1622                 return EINA_FALSE;
1623         }
1624
1625         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1626                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1627                 return EINA_FALSE;
1628         }
1629
1630         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1631
1632         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1633
1634         vc_cmd_print_list(vc_cmd_list);
1635
1636         vc_client_use_callback(g_vc);
1637         callback(event, vc_cmd_list, temp_text, user_data);
1638         vc_client_not_use_callback(g_vc);
1639
1640         SLOG(LOG_DEBUG, TAG_VCC, "Client result callback called");
1641
1642         vc_cmd_list_destroy(vc_cmd_list, true);
1643
1644         /* Release result */
1645         if (NULL != temp_text)  free(temp_text);
1646
1647         return EINA_FALSE;
1648 }
1649
1650 void __vc_cb_result(void)
1651 {
1652         ecore_timer_add(0, __vc_notify_result, NULL);
1653
1654         return;
1655 }
1656
1657 int vc_get_result(vc_result_cb callback, void* user_data)
1658 {
1659         if (0 != __vc_get_feature_enabled()) {
1660                 return VC_ERROR_NOT_SUPPORTED;
1661         }
1662         if (0 != __vc_check_privilege()) {
1663                 return VC_ERROR_PERMISSION_DENIED;
1664         }
1665
1666         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Get result");
1667
1668         if (NULL == callback) {
1669                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1670                 return VC_ERROR_INVALID_PARAMETER;
1671         }
1672
1673         char* temp_text = NULL;
1674         int event = 0;
1675         vc_cmd_list_h vc_cmd_list = NULL;
1676
1677         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1678                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1679                 return VC_ERROR_INVALID_PARAMETER;
1680         }
1681
1682         int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1683         if (0 != ret || NULL == temp_text) {
1684                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text);
1685                 return ret;
1686         }
1687
1688         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1689
1690         vc_cmd_print_list(vc_cmd_list);
1691
1692         vc_client_use_callback(g_vc);
1693         callback(event, vc_cmd_list, temp_text, user_data);
1694         vc_client_not_use_callback(g_vc);
1695
1696         vc_cmd_list_destroy(vc_cmd_list, true);
1697
1698         /* Release result */
1699         if (NULL != temp_text) {
1700                 free(temp_text);
1701                 temp_text = NULL;
1702         }
1703
1704         SLOG(LOG_DEBUG, TAG_VCC, "=====");
1705         SLOG(LOG_DEBUG, TAG_VCC, " ");
1706
1707         return VC_ERROR_NONE;
1708 }
1709
1710 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1711 {
1712         if (0 != __vc_get_feature_enabled()) {
1713                 return VC_ERROR_NOT_SUPPORTED;
1714         }
1715         if (0 != __vc_check_privilege()) {
1716                 return VC_ERROR_PERMISSION_DENIED;
1717         }
1718
1719         if (NULL == callback)
1720                 return VC_ERROR_INVALID_PARAMETER;
1721
1722         vc_state_e state;
1723         if (0 != vc_client_get_client_state(g_vc, &state)) {
1724                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1725                 return VC_ERROR_INVALID_STATE;
1726         }
1727
1728         /* check state */
1729         if (state != VC_STATE_INITIALIZED) {
1730                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1731                 return VC_ERROR_INVALID_STATE;
1732         }
1733
1734         vc_client_set_result_cb(g_vc, callback, user_data);
1735
1736         return 0;
1737 }
1738
1739 int vc_unset_result_cb(void)
1740 {
1741         if (0 != __vc_get_feature_enabled()) {
1742                 return VC_ERROR_NOT_SUPPORTED;
1743         }
1744         if (0 != __vc_check_privilege()) {
1745                 return VC_ERROR_PERMISSION_DENIED;
1746         }
1747
1748         vc_state_e state;
1749         if (0 != vc_client_get_client_state(g_vc, &state)) {
1750                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1751                 return VC_ERROR_INVALID_STATE;
1752         }
1753
1754         /* check state */
1755         if (state != VC_STATE_INITIALIZED) {
1756                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1757                 return VC_ERROR_INVALID_STATE;
1758         }
1759
1760         vc_client_set_result_cb(g_vc, NULL, NULL);
1761
1762         return 0;
1763 }
1764
1765 int __vc_cb_service_state(int state)
1766 {
1767         vc_service_state_e current_state = (vc_service_state_e)state;
1768         vc_service_state_e before_state;
1769         vc_client_get_service_state(g_vc, &before_state);
1770
1771         if (current_state == before_state) {
1772                 return 0;
1773         }
1774
1775         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1776                 before_state, current_state);
1777
1778         /* Save service state */
1779         vc_client_set_service_state(g_vc, current_state);
1780
1781         vc_service_state_changed_cb callback = NULL;
1782         void* service_user_data;
1783         vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1784
1785         if (NULL != callback) {
1786                 vc_client_use_callback(g_vc);
1787                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1788                 vc_client_not_use_callback(g_vc);
1789                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1790         } else {
1791                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1792         }
1793
1794         return 0;
1795 }
1796
1797 int __vc_cb_manager_pid(int manager_pid)
1798 {
1799         SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid);
1800
1801         /* Save service state */
1802         vc_client_set_mgr_pid(g_vc, manager_pid);
1803
1804         return 0;
1805 }
1806
1807 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1808 {
1809         if (0 != __vc_get_feature_enabled()) {
1810                 return VC_ERROR_NOT_SUPPORTED;
1811         }
1812         if (0 != __vc_check_privilege()) {
1813                 return VC_ERROR_PERMISSION_DENIED;
1814         }
1815
1816         if (NULL == callback)
1817                 return VC_ERROR_INVALID_PARAMETER;
1818
1819         vc_state_e state;
1820         if (0 != vc_client_get_client_state(g_vc, &state)) {
1821                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1822                 return VC_ERROR_INVALID_STATE;
1823         }
1824
1825         /* check state */
1826         if (state != VC_STATE_INITIALIZED) {
1827                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1828                 return VC_ERROR_INVALID_STATE;
1829         }
1830
1831         vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1832
1833         return 0;
1834 }
1835
1836 int vc_unset_service_state_changed_cb(void)
1837 {
1838         if (0 != __vc_get_feature_enabled()) {
1839                 return VC_ERROR_NOT_SUPPORTED;
1840         }
1841         if (0 != __vc_check_privilege()) {
1842                 return VC_ERROR_PERMISSION_DENIED;
1843         }
1844
1845         vc_state_e state;
1846         if (0 != vc_client_get_client_state(g_vc, &state)) {
1847                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1848                 return VC_ERROR_INVALID_STATE;
1849         }
1850
1851         /* check state */
1852         if (state != VC_STATE_INITIALIZED) {
1853                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1854                 return VC_ERROR_INVALID_STATE;
1855         }
1856
1857         vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
1858
1859         return 0;
1860 }
1861
1862 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1863 {
1864         if (0 != __vc_get_feature_enabled()) {
1865                 return VC_ERROR_NOT_SUPPORTED;
1866         }
1867         if (0 != __vc_check_privilege()) {
1868                 return VC_ERROR_PERMISSION_DENIED;
1869         }
1870
1871         if (callback == NULL)
1872                 return VC_ERROR_INVALID_PARAMETER;
1873
1874         vc_state_e state;
1875         if (0 != vc_client_get_client_state(g_vc, &state)) {
1876                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
1877                 return VC_ERROR_INVALID_STATE;
1878         }
1879
1880         /* check state */
1881         if (state != VC_STATE_INITIALIZED) {
1882                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1883                 return VC_ERROR_INVALID_STATE;
1884         }
1885
1886         vc_client_set_state_changed_cb(g_vc, callback, user_data);
1887
1888         return 0;
1889 }
1890
1891 int vc_unset_state_changed_cb(void)
1892 {
1893         if (0 != __vc_get_feature_enabled()) {
1894                 return VC_ERROR_NOT_SUPPORTED;
1895         }
1896         if (0 != __vc_check_privilege()) {
1897                 return VC_ERROR_PERMISSION_DENIED;
1898         }
1899
1900         vc_state_e state;
1901         if (0 != vc_client_get_client_state(g_vc, &state)) {
1902                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
1903                 return VC_ERROR_INVALID_STATE;
1904         }
1905
1906         /* check state */
1907         if (state != VC_STATE_INITIALIZED) {
1908                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1909                 return VC_ERROR_INVALID_STATE;
1910         }
1911
1912         vc_client_set_state_changed_cb(g_vc, NULL, NULL);
1913
1914         return 0;
1915 }
1916
1917 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1918 {
1919         if (0 != __vc_get_feature_enabled()) {
1920                 return VC_ERROR_NOT_SUPPORTED;
1921         }
1922         if (0 != __vc_check_privilege()) {
1923                 return VC_ERROR_PERMISSION_DENIED;
1924         }
1925
1926         if (NULL == callback)
1927                 return VC_ERROR_INVALID_PARAMETER;
1928
1929         vc_state_e state;
1930         if (0 != vc_client_get_client_state(g_vc, &state)) {
1931                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
1932                 return VC_ERROR_INVALID_STATE;
1933         }
1934
1935         /* check state */
1936         if (state != VC_STATE_INITIALIZED) {
1937                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1938                 return VC_ERROR_INVALID_STATE;
1939         }
1940
1941         vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
1942
1943         return 0;
1944 }
1945
1946 int vc_unset_current_language_changed_cb(void)
1947 {
1948         if (0 != __vc_get_feature_enabled()) {
1949                 return VC_ERROR_NOT_SUPPORTED;
1950         }
1951         if (0 != __vc_check_privilege()) {
1952                 return VC_ERROR_PERMISSION_DENIED;
1953         }
1954
1955         vc_state_e state;
1956         if (0 != vc_client_get_client_state(g_vc, &state)) {
1957                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
1958                 return VC_ERROR_INVALID_STATE;
1959         }
1960
1961         /* check state */
1962         if (state != VC_STATE_INITIALIZED) {
1963                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1964                 return VC_ERROR_INVALID_STATE;
1965         }
1966
1967         vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
1968
1969         return 0;
1970 }
1971
1972 int vc_set_error_cb(vc_error_cb callback, void* user_data)
1973 {
1974         if (0 != __vc_get_feature_enabled()) {
1975                 return VC_ERROR_NOT_SUPPORTED;
1976         }
1977         if (0 != __vc_check_privilege()) {
1978                 return VC_ERROR_PERMISSION_DENIED;
1979         }
1980
1981         if (NULL == callback)
1982                 return VC_ERROR_INVALID_PARAMETER;
1983
1984         vc_state_e state;
1985         if (0 != vc_client_get_client_state(g_vc, &state)) {
1986                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
1987                 return VC_ERROR_INVALID_STATE;
1988         }
1989
1990         /* check state */
1991         if (state != VC_STATE_INITIALIZED) {
1992                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
1993                 return VC_ERROR_INVALID_STATE;
1994         }
1995
1996         vc_client_set_error_cb(g_vc, callback,  user_data);
1997
1998         return 0;
1999 }
2000
2001 int vc_unset_error_cb(void)
2002 {
2003         if (0 != __vc_get_feature_enabled()) {
2004                 return VC_ERROR_NOT_SUPPORTED;
2005         }
2006         if (0 != __vc_check_privilege()) {
2007                 return VC_ERROR_PERMISSION_DENIED;
2008         }
2009
2010         vc_state_e state;
2011         if (0 != vc_client_get_client_state(g_vc, &state)) {
2012                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2013                 return VC_ERROR_INVALID_STATE;
2014         }
2015
2016         /* check state */
2017         if (state != VC_STATE_INITIALIZED) {
2018                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2019                 return VC_ERROR_INVALID_STATE;
2020         }
2021
2022         vc_client_set_error_cb(g_vc, NULL, NULL);
2023
2024         return 0;
2025 }
2026
2027 int vc_set_invocation_name(const char* name)
2028 {
2029         if (0 != __vc_get_feature_enabled()) {
2030                 return VC_ERROR_NOT_SUPPORTED;
2031         }
2032         if (0 != __vc_check_privilege()) {
2033                 return VC_ERROR_PERMISSION_DENIED;
2034         }
2035
2036         vc_state_e state;
2037         SLOG(LOG_DEBUG, TAG_VCC, "===== Set invocation name");
2038
2039         int ret = vc_client_get_client_state(g_vc, &state);
2040         if (0 != ret) {
2041                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2042                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2043                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2044                 return ret;
2045         }
2046
2047         /* check state */
2048         if (state != VC_STATE_READY) {
2049                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2050                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2051                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2052                 return VC_ERROR_INVALID_STATE;
2053         }
2054
2055         ret = vc_client_set_invocation_name(g_vc, name);
2056         if (0 != ret) {
2057                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2058         }
2059         return ret;
2060 }
2061
2062 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2063 {
2064         vc_state_e state;
2065
2066         SLOG(LOG_DEBUG, TAG_VCC, "===== Request dialog");
2067         if (0 != __vc_get_feature_enabled()) {
2068                 return VC_ERROR_NOT_SUPPORTED;
2069         }
2070         if (0 != __vc_check_privilege()) {
2071                 return VC_ERROR_PERMISSION_DENIED;
2072         }
2073
2074         if (0 != vc_client_get_client_state(g_vc, &state)) {
2075                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2076                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2077                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2078                 return VC_ERROR_INVALID_STATE;
2079         }
2080
2081         /* check state */
2082         if (state != VC_STATE_READY) {
2083                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2084                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2085                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2086                 return VC_ERROR_INVALID_STATE;
2087         }
2088
2089         /* Check service state */
2090         vc_service_state_e service_state = -1;
2091         vc_client_get_service_state(g_vc, &service_state);
2092         if (service_state != VC_SERVICE_STATE_READY) {
2093                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2094                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2095                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2096                 return VC_ERROR_INVALID_STATE;
2097         }
2098
2099         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);
2100         int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2101         if (0 != ret) {
2102                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set foreground (true) : %d", ret);
2103                 return VC_ERROR_OPERATION_FAILED;
2104         }
2105
2106         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2107         SLOG(LOG_DEBUG, TAG_VCC, " ");
2108
2109         return VC_ERROR_NONE;
2110 }
2111
2112 /* Authority */
2113 int vc_auth_enable(void)
2114 {
2115         /* check state */
2116         vc_state_e state;
2117         if (0 != vc_client_get_client_state(g_vc, &state)) {
2118                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2119                 return VC_ERROR_INVALID_STATE;
2120         }
2121
2122         if (VC_STATE_READY != state) {
2123                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2124                 return VC_ERROR_INVALID_STATE;
2125         }
2126
2127         /* check already authority */
2128         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2129         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2130                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2131                 return VC_ERROR_INVALID_STATE;
2132         }
2133
2134         if (VC_AUTH_STATE_NONE != auth_state) {
2135                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2136                 return VC_ERROR_INVALID_STATE;
2137         }
2138
2139         /* request authority */
2140         int mgr_pid = -1;
2141         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2142                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2143                 return VC_ERROR_OPERATION_FAILED;
2144         }
2145
2146         if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2147                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2148                 return VC_ERROR_OPERATION_FAILED;
2149         }
2150
2151         /* set authority into handle */
2152         bool is_foreground = false;
2153         if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2154                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2155                 return VC_ERROR_OPERATION_FAILED;
2156         }
2157
2158         if (is_foreground) {
2159                 auth_state = VC_AUTH_STATE_VALID;
2160         } else {
2161                 auth_state = VC_AUTH_STATE_INVALID;
2162         }
2163
2164         if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2165                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2166                 return VC_ERROR_OPERATION_FAILED;
2167         }
2168
2169         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2170
2171         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2172
2173         return VC_ERROR_NONE;
2174 }
2175
2176 int vc_auth_disable(void)
2177 {
2178         /* check state */
2179         vc_state_e state;
2180         if (0 != vc_client_get_client_state(g_vc, &state)) {
2181                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2182                 return VC_ERROR_INVALID_STATE;
2183         }
2184
2185         if (VC_STATE_READY != state) {
2186                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2187                 return VC_ERROR_INVALID_STATE;
2188         }
2189
2190         /* check autority */
2191         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2192         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2193                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2194                 return VC_ERROR_INVALID_STATE;
2195         }
2196
2197         if (VC_AUTH_STATE_NONE == auth_state) {
2198                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2199                 return VC_ERROR_INVALID_STATE;
2200         }
2201
2202         if (0 != vc_auth_unset_state_changed_cb()) {
2203                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2204         }
2205
2206         /* request return authority by dbus */
2207         int mgr_pid = -1;
2208         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2209                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2210                 return VC_ERROR_OPERATION_FAILED;
2211         }
2212
2213         if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2214                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disble");
2215                 return VC_ERROR_OPERATION_FAILED;
2216         }
2217
2218         /* unset authority from handle */
2219         if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2220                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2221                 return VC_ERROR_OPERATION_FAILED;
2222         }
2223
2224         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2225
2226         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2227
2228         return VC_ERROR_NONE;
2229 }
2230
2231 int vc_auth_get_state(vc_auth_state_e* state)
2232 {
2233         /* check state */
2234         vc_state_e vc_state;
2235         if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2236                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2237                 return VC_ERROR_INVALID_STATE;
2238         }
2239
2240         if (VC_STATE_READY != vc_state) {
2241                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2242                 return VC_ERROR_INVALID_STATE;
2243         }
2244
2245         /* get autority */
2246         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2247         if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2248                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2249                 return VC_ERROR_INVALID_STATE;
2250         }
2251
2252         *state = temp;
2253
2254         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2255
2256         return VC_ERROR_NONE;
2257 }
2258
2259 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2260 {
2261         /* check parameter */
2262         if (NULL == callback) {
2263                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2264                 return VC_ERROR_INVALID_PARAMETER;
2265         }
2266
2267         /* check auth */
2268         vc_auth_state_e auth_state;
2269         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2270                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2271                 return VC_ERROR_INVALID_STATE;
2272         }
2273
2274         if (VC_AUTH_STATE_NONE == auth_state) {
2275                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2276                 return VC_ERROR_INVALID_STATE;
2277         }
2278
2279         /* set cb into handle */
2280         if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2281                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2282                 return VC_ERROR_OPERATION_FAILED;
2283         }
2284
2285         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
2286
2287         return VC_ERROR_NONE;
2288 }
2289
2290 int vc_auth_unset_state_changed_cb(void)
2291 {
2292         /* check auth */
2293         vc_auth_state_e auth_state;
2294         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2295                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2296                 return VC_ERROR_INVALID_STATE;
2297         }
2298
2299         if (VC_AUTH_STATE_NONE == auth_state) {
2300                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2301                 return VC_ERROR_INVALID_STATE;
2302         }
2303
2304         /* unset cb from handle */
2305         if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2306                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2307                 return VC_ERROR_OPERATION_FAILED;
2308         }
2309
2310         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2311
2312         return VC_ERROR_NONE;
2313 }
2314
2315 int vc_auth_start(void)
2316 {
2317         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request start");
2318
2319         vc_state_e state;
2320         if (0 != vc_client_get_client_state(g_vc, &state)) {
2321                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2322                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2323                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2324                 return VC_ERROR_INVALID_STATE;
2325         }
2326
2327         /* check state */
2328         if (state != VC_STATE_READY) {
2329                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2330                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2331                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2332                 return VC_ERROR_INVALID_STATE;
2333         }
2334
2335         /* Check service state */
2336         vc_service_state_e service_state = -1;
2337         vc_client_get_service_state(g_vc, &service_state);
2338         if (service_state != VC_SERVICE_STATE_READY) {
2339                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2340                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2341                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2342                 return VC_ERROR_INVALID_STATE;
2343         }
2344
2345         /* Check authority */
2346         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2347         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2348                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2349                 return VC_ERROR_OPERATION_FAILED;
2350         }
2351
2352         if (VC_AUTH_STATE_VALID != auth_state) {
2353                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2354                 return VC_ERROR_OPERATION_FAILED;
2355         }
2356
2357         /* get mgr_pid */
2358         int mgr_pid = -1;
2359         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2360                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2361                 return VC_ERROR_OPERATION_FAILED;
2362         }
2363
2364         int ret;
2365         int count = 0;
2366         /* Request */
2367         ret = -1;
2368         count = 0;
2369         while (0 != ret) {
2370                 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2371                 if (0 != ret) {
2372                         if (VC_ERROR_TIMED_OUT != ret) {
2373                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2374                                 break;
2375                         } else {
2376                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2377                                 usleep(10000);
2378                                 count++;
2379                                 if (VC_RETRY_COUNT == count) {
2380                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2381                                         break;
2382                                 }
2383                         }
2384                 } else {
2385                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2386                 }
2387         }
2388
2389         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2390         SLOG(LOG_DEBUG, TAG_VCC, " ");
2391
2392         return ret;
2393 }
2394
2395 int vc_auth_stop(void)
2396 {
2397         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request stop");
2398
2399         vc_state_e state;
2400         if (0 != vc_client_get_client_state(g_vc, &state)) {
2401                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2402                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2403                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2404                 return VC_ERROR_INVALID_STATE;
2405         }
2406
2407         /* check state */
2408         if (state != VC_STATE_READY) {
2409                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2410                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2411                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2412                 return VC_ERROR_INVALID_STATE;
2413         }
2414
2415         /* Check service state */
2416         vc_service_state_e service_state = -1;
2417         vc_client_get_service_state(g_vc, &service_state);
2418         if (service_state != VC_SERVICE_STATE_RECORDING) {
2419                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2420                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2421                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2422                 return VC_ERROR_INVALID_STATE;
2423         }
2424
2425         /* Check authority */
2426         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2427         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2428                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2429                 return VC_ERROR_OPERATION_FAILED;
2430         }
2431
2432         if (VC_AUTH_STATE_VALID != auth_state) {
2433                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2434                 return VC_ERROR_OPERATION_FAILED;
2435         }
2436
2437         /* get mgr_pid */
2438         int mgr_pid = -1;
2439         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2440                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2441                 return VC_ERROR_OPERATION_FAILED;
2442         }
2443
2444         int ret = -1;
2445         int count = 0;
2446         /* do request */
2447         while (0 != ret) {
2448                 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2449                 if (0 != ret) {
2450                         if (VC_ERROR_TIMED_OUT != ret) {
2451                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2452                                 break;
2453                         } else {
2454                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2455                                 usleep(10000);
2456                                 count++;
2457                                 if (VC_RETRY_COUNT == count) {
2458                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2459                                         break;
2460                                 }
2461                         }
2462                 } else {
2463                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2464                 }
2465         }
2466
2467         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2468         SLOG(LOG_DEBUG, TAG_VCC, " ");
2469
2470         return ret;
2471 }
2472
2473 int vc_auth_cancel(void)
2474 {
2475         SLOG(LOG_DEBUG, TAG_VCC, "===== [Client] Request cancel");
2476
2477         vc_state_e state;
2478         if (0 != vc_client_get_client_state(g_vc, &state)) {
2479                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2480                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2481                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2482                 return VC_ERROR_INVALID_STATE;
2483         }
2484
2485         /* check state */
2486         if (state != VC_STATE_READY) {
2487                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2488                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2489                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2490                 return VC_ERROR_INVALID_STATE;
2491         }
2492
2493         /* Check service state */
2494         vc_service_state_e service_state = -1;
2495         vc_client_get_service_state(g_vc, &service_state);
2496         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2497                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2498                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
2499                 SLOG(LOG_DEBUG, TAG_VCC, " ");
2500                 return VC_ERROR_INVALID_STATE;
2501         }
2502
2503         /* Check authority */
2504         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2505         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2506                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2507                 return VC_ERROR_OPERATION_FAILED;
2508         }
2509
2510         if (VC_AUTH_STATE_VALID != auth_state) {
2511                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2512                 return VC_ERROR_OPERATION_FAILED;
2513         }
2514
2515         /* get mgr_pid */
2516         int mgr_pid = -1;
2517         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2518                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2519                 return VC_ERROR_OPERATION_FAILED;
2520         }
2521
2522         int ret = -1;
2523         int count = 0;
2524         while (0 != ret) {
2525                 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2526                 if (0 != ret) {
2527                         if (VC_ERROR_TIMED_OUT != ret) {
2528                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2529                                 break;
2530                         } else {
2531                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2532                                 usleep(10000);
2533                                 count++;
2534                                 if (VC_RETRY_COUNT == count) {
2535                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2536                                         break;
2537                                 }
2538                         }
2539                 } else {
2540                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2541                 }
2542         }
2543
2544         SLOG(LOG_DEBUG, TAG_VCC, "=====");
2545         SLOG(LOG_DEBUG, TAG_VCC, " ");
2546
2547         return ret;
2548 }