client/vc.c

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