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