client/vc.c

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