client/vc.c

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