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