client/vc.c

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