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