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