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