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