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