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[32];
 168                 snprintf(uid, 32, "%d", getuid());
 169                 ret = true;
 170                 ret = __check_privilege(uid, VC_PRIVILEGE);
 171                 __check_privilege_deinitialize();
 172                 if (false == ret) {
 173                         //LCOV_EXCL_START
 174                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Permission is denied");
 175                         pthread_mutex_unlock(&g_cynara_mutex);
 176                         return VC_ERROR_PERMISSION_DENIED;
 177                         //LCOV_EXCL_STOP
 178                 }
 179         }
 180
 181         g_privilege_allowed = true;
 182         pthread_mutex_unlock(&g_cynara_mutex);
 183         return VC_ERROR_NONE;
 184 }
 185
 186 //LCOV_EXCL_START
 187 static const char* __vc_get_error_code(vc_error_e err)
 188 {
 189         switch (err) {
 190         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
 191         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
 192         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
 193         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
 194         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
 195         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
 196         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
 197         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
 198         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
 199         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
 200         default:                                return "Invalid error code";
 201         }
 202         return NULL;
 203 }
 204
 205 static int __vc_convert_config_error_code(vc_config_error_e code)
 206 {
 207         if (code == VC_CONFIG_ERROR_NONE)                       return VC_ERROR_NONE;
 208         if (code == VC_CONFIG_ERROR_OUT_OF_MEMORY)              return VC_ERROR_OUT_OF_MEMORY;
 209         if (code == VC_CONFIG_ERROR_IO_ERROR)                   return VC_ERROR_IO_ERROR;
 210         if (code == VC_CONFIG_ERROR_INVALID_PARAMETER)          return VC_ERROR_INVALID_PARAMETER;
 211         if (code == VC_CONFIG_ERROR_INVALID_STATE)              return VC_ERROR_INVALID_STATE;
 212         if (code == VC_CONFIG_ERROR_INVALID_LANGUAGE)           return VC_ERROR_INVALID_LANGUAGE;
 213         if (code == VC_CONFIG_ERROR_ENGINE_NOT_FOUND)           return VC_ERROR_ENGINE_NOT_FOUND;
 214         if (code == VC_CONFIG_ERROR_OPERATION_FAILED)           return VC_ERROR_OPERATION_FAILED;
 215
 216         return VC_ERROR_NONE;
 217 }
 218
 219 static void __vc_lang_changed_cb(const char* before_lang, const char* current_lang)
 220 {
 221         SLOG(LOG_DEBUG, TAG_VCC, "Lang changed : Before lang(%s) Current lang(%s)",
 222                  before_lang, current_lang);
 223
 224         vc_current_language_changed_cb callback;
 225         void* lang_user_data;
 226         vc_client_get_current_lang_changed_cb(g_vc, &callback, &lang_user_data);
 227
 228         if (NULL != callback) {
 229                 vc_client_use_callback(g_vc);
 230                 callback(before_lang, current_lang, lang_user_data);
 231                 vc_client_not_use_callback(g_vc);
 232                 SLOG(LOG_DEBUG, TAG_VCC, "Language changed callback is called");
 233         } else {
 234                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Language changed callback is null");
 235         }
 236
 237         return;
 238 }
 239
 240 static Eina_Bool __notify_auth_changed_cb(void *data)
 241 {
 242         vc_auth_state_changed_cb callback = NULL;
 243         void* user_data;
 244
 245         vc_client_get_auth_state_changed_cb(g_vc, &callback, &user_data);
 246
 247         vc_auth_state_e before = -1;
 248         vc_auth_state_e current = -1;
 249
 250         vc_client_get_before_auth_state(g_vc, &before, &current);
 251
 252         if (NULL != callback) {
 253                 vc_client_use_callback(g_vc);
 254                 callback(before, current, user_data);
 255                 vc_client_not_use_callback(g_vc);
 256                 SLOG(LOG_DEBUG, TAG_VCC, "Auth state changed callback is called");
 257         } else {
 258                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Auth state changed callback is null");
 259         }
 260
 261         return EINA_FALSE;
 262 }
 263
 264 static Eina_Bool __focus_changed_cb(void *data, int type, void *event)
 265 {
 266         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Focus changed");
 267
 268         int ret;
 269         if (ECORE_WL2_EVENT_FOCUS_IN == type) {
 270                 SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set foreground");
 271                 ret = vc_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 == 20) { // 200 ms * 20 = 4 sec
 613                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 614                         return;
 615                 }
 616
 617                 ret = vc_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 int __vc_cb_error_to_app(int pid, int reason, const char* msg)
1717 {
1718         SLOG(LOG_INFO, TAG_VCC, "[INFO] send error to app(%d)", pid);
1719
1720         vc_h vc;
1721         if (0 != vc_client_get_handle(pid, &vc)) {
1722                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get vc handle");
1723                 return VC_ERROR_INVALID_PARAMETER;
1724         }
1725
1726         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
1727
1728         vc_client_set_error(vc, reason);
1729         ecore_main_loop_thread_safe_call_async(__vc_notify_error, (void*)vc);
1730
1731         return VC_ERROR_NONE;
1732 }
1733
1734 static void __vc_notify_state_changed(void *data)
1735 {
1736         vc_h vc = (vc_h)data;
1737
1738         vc_state_changed_cb changed_callback = NULL;
1739         void* user_data;
1740
1741         vc_client_get_state_changed_cb(vc, &changed_callback, &user_data);
1742
1743         vc_state_e current_state;
1744         vc_state_e before_state;
1745
1746         vc_client_get_before_state(vc, &current_state, &before_state);
1747
1748         if (NULL != changed_callback) {
1749                 vc_client_use_callback(vc);
1750                 changed_callback(before_state, current_state, user_data);
1751                 vc_client_not_use_callback(vc);
1752                 SLOG(LOG_DEBUG, TAG_VCC, "State changed callback is called");
1753         } else {
1754                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] State changed callback is null");
1755         }
1756 }
1757
1758 static Eina_Bool __vc_notify_result(void *data)
1759 {
1760         char* temp_text;
1761         int event;
1762         vc_cmd_list_h vc_cmd_list = NULL;
1763
1764         vc_result_cb callback = NULL;
1765         void* user_data = NULL;
1766
1767         vc_client_get_result_cb(g_vc, &callback, &user_data);
1768
1769         if (NULL == callback) {
1770                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL");
1771                 return EINA_FALSE;
1772         }
1773
1774         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1775                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list");
1776                 return EINA_FALSE;
1777         }
1778
1779         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(),  vc_cmd_list, false);
1780
1781         SECURE_SLOG(LOG_INFO, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event);
1782
1783         vc_cmd_print_list(vc_cmd_list);
1784
1785         vc_client_use_callback(g_vc);
1786         callback(event, vc_cmd_list, temp_text, user_data);
1787         vc_client_not_use_callback(g_vc);
1788
1789         SLOG(LOG_INFO, TAG_VCC, "Client result callback called");
1790
1791         vc_cmd_list_destroy(vc_cmd_list, true);
1792         vc_cmd_list = NULL;
1793
1794         /* Release result */
1795         FREE(temp_text);
1796
1797         return EINA_FALSE;
1798 }
1799
1800 void __vc_cb_result(void)
1801 {
1802         ecore_timer_add(0, __vc_notify_result, NULL);
1803
1804         return;
1805 }
1806 //LCOV_EXCL_STOP
1807
1808 int vc_get_result(vc_result_cb callback, void* user_data)
1809 {
1810         if (0 != __vc_get_feature_enabled()) {
1811                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
1812         }
1813         if (0 != __vc_check_privilege()) {
1814                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
1815         }
1816
1817         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Get result");
1818
1819         vc_state_e state;
1820         if (0 != vc_client_get_client_state(g_vc, &state)) {
1821                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
1822                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1823                 return VC_ERROR_INVALID_STATE;
1824         }
1825
1826         /* check state */
1827         if (state != VC_STATE_READY) {
1828                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
1829                 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
1830                 return VC_ERROR_INVALID_STATE;
1831         }
1832
1833         if (NULL == callback) {
1834                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Client result callback is NULL"); //LCOV_EXCL_LINE
1835                 return VC_ERROR_INVALID_PARAMETER;
1836         }
1837
1838         char* temp_text = NULL;
1839         int event = 0;
1840         vc_cmd_list_h vc_cmd_list = NULL;
1841
1842         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1843                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to create command list"); //LCOV_EXCL_LINE
1844                 return VC_ERROR_INVALID_PARAMETER;
1845         }
1846
1847         int ret = vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1848         if (0 != ret || NULL == temp_text) {
1849                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get result, ret(%d) temp_text(%s)", ret, temp_text); //LCOV_EXCL_LINE
1850                 return ret;
1851         }
1852
1853         SLOG(LOG_DEBUG, TAG_VCC, "Result info : result text(%s) event(%d)", temp_text, event); //LCOV_EXCL_LINE
1854
1855         vc_cmd_print_list(vc_cmd_list);
1856
1857         vc_client_use_callback(g_vc);
1858         callback(event, vc_cmd_list, temp_text, user_data);
1859         vc_client_not_use_callback(g_vc);
1860
1861         vc_cmd_list_destroy(vc_cmd_list, true);
1862         vc_cmd_list = NULL;
1863
1864         /* Release result */
1865         FREE(temp_text);
1866
1867         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
1868
1869         return VC_ERROR_NONE;
1870 }
1871
1872 int vc_set_result_cb(vc_result_cb callback, void* user_data)
1873 {
1874         if (0 != __vc_get_feature_enabled()) {
1875                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
1876         }
1877         if (0 != __vc_check_privilege()) {
1878                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
1879         }
1880
1881         if (NULL == callback)
1882                 return VC_ERROR_INVALID_PARAMETER;
1883
1884         vc_state_e state;
1885         if (0 != vc_client_get_client_state(g_vc, &state)) {
1886                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1887                 return VC_ERROR_INVALID_STATE;
1888         }
1889
1890         /* check state */
1891         if (state != VC_STATE_INITIALIZED) {
1892                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1893                 return VC_ERROR_INVALID_STATE;
1894         }
1895
1896         vc_client_set_result_cb(g_vc, callback, user_data);
1897
1898         return 0;
1899 }
1900
1901 int vc_unset_result_cb(void)
1902 {
1903         if (0 != __vc_get_feature_enabled()) {
1904                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
1905         }
1906         if (0 != __vc_check_privilege()) {
1907                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
1908         }
1909
1910         vc_state_e state;
1911         if (0 != vc_client_get_client_state(g_vc, &state)) {
1912                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
1913                 return VC_ERROR_INVALID_STATE;
1914         }
1915
1916         /* check state */
1917         if (state != VC_STATE_INITIALIZED) {
1918                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1919                 return VC_ERROR_INVALID_STATE;
1920         }
1921
1922         vc_client_set_result_cb(g_vc, NULL, NULL);
1923
1924         return 0;
1925 }
1926
1927 //LCOV_EXCL_START
1928 int __vc_cb_service_state(int state)
1929 {
1930         vc_service_state_e current_state = (vc_service_state_e)state;
1931         vc_service_state_e before_state;
1932         vc_client_get_service_state(g_vc, &before_state);
1933
1934         if (current_state == before_state) {
1935                 return 0;
1936         }
1937
1938         SLOG(LOG_DEBUG, TAG_VCC, "Service State changed : Before(%d) Current(%d)",
1939                 before_state, current_state);
1940
1941         /* Save service state */
1942         vc_client_set_service_state(g_vc, current_state);
1943
1944         vc_service_state_changed_cb callback = NULL;
1945         void* service_user_data;
1946         vc_client_get_service_state_changed_cb(g_vc, &callback, &service_user_data);
1947
1948         if (NULL != callback) {
1949                 vc_client_use_callback(g_vc);
1950                 callback((vc_service_state_e)before_state, (vc_service_state_e)current_state, service_user_data);
1951                 vc_client_not_use_callback(g_vc);
1952                 SLOG(LOG_DEBUG, TAG_VCC, "Service state changed callback is called");
1953         } else {
1954                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Service state changed callback is null");
1955         }
1956
1957         return 0;
1958 }
1959
1960 int __vc_cb_manager_pid(int manager_pid)
1961 {
1962         SLOG(LOG_DEBUG, TAG_VCC, "Manager pid is changed : %d", manager_pid); //LCOV_EXCL_LINE
1963
1964         /* Save service state */
1965         vc_client_set_mgr_pid(g_vc, manager_pid);
1966
1967         return 0;
1968 }
1969 //LCOV_EXCL_STOP
1970
1971 int vc_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1972 {
1973         if (0 != __vc_get_feature_enabled()) {
1974                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
1975         }
1976         if (0 != __vc_check_privilege()) {
1977                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
1978         }
1979
1980         if (NULL == callback)
1981                 return VC_ERROR_INVALID_PARAMETER;
1982
1983         vc_state_e state;
1984         if (0 != vc_client_get_client_state(g_vc, &state)) {
1985                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : A handle is not available");
1986                 return VC_ERROR_INVALID_STATE;
1987         }
1988
1989         /* check state */
1990         if (state != VC_STATE_INITIALIZED) {
1991                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set result callback : Current state is not 'Initialized'");
1992                 return VC_ERROR_INVALID_STATE;
1993         }
1994
1995         vc_client_set_service_state_changed_cb(g_vc, callback, user_data);
1996
1997         return 0;
1998 }
1999
2000 int vc_unset_service_state_changed_cb(void)
2001 {
2002         if (0 != __vc_get_feature_enabled()) {
2003                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2004         }
2005         if (0 != __vc_check_privilege()) {
2006                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2007         }
2008
2009         vc_state_e state;
2010         if (0 != vc_client_get_client_state(g_vc, &state)) {
2011                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : A handle is not available");
2012                 return VC_ERROR_INVALID_STATE;
2013         }
2014
2015         /* check state */
2016         if (state != VC_STATE_INITIALIZED) {
2017                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset result callback : Current state is not 'Initialized'");
2018                 return VC_ERROR_INVALID_STATE;
2019         }
2020
2021         vc_client_set_service_state_changed_cb(g_vc, NULL, NULL);
2022
2023         return 0;
2024 }
2025
2026 int vc_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
2027 {
2028         if (0 != __vc_get_feature_enabled()) {
2029                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2030         }
2031         if (0 != __vc_check_privilege()) {
2032                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2033         }
2034
2035         if (callback == NULL)
2036                 return VC_ERROR_INVALID_PARAMETER;
2037
2038         vc_state_e state;
2039         if (0 != vc_client_get_client_state(g_vc, &state)) {
2040                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : A handle is not available");
2041                 return VC_ERROR_INVALID_STATE;
2042         }
2043
2044         /* check state */
2045         if (state != VC_STATE_INITIALIZED) {
2046                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2047                 return VC_ERROR_INVALID_STATE;
2048         }
2049
2050         vc_client_set_state_changed_cb(g_vc, callback, user_data);
2051
2052         return 0;
2053 }
2054
2055 int vc_unset_state_changed_cb(void)
2056 {
2057         if (0 != __vc_get_feature_enabled()) {
2058                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2059         }
2060         if (0 != __vc_check_privilege()) {
2061                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2062         }
2063
2064         vc_state_e state;
2065         if (0 != vc_client_get_client_state(g_vc, &state)) {
2066                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : A handle is not available");
2067                 return VC_ERROR_INVALID_STATE;
2068         }
2069
2070         /* check state */
2071         if (state != VC_STATE_INITIALIZED) {
2072                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2073                 return VC_ERROR_INVALID_STATE;
2074         }
2075
2076         vc_client_set_state_changed_cb(g_vc, NULL, NULL);
2077
2078         return 0;
2079 }
2080
2081 int vc_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2082 {
2083         if (0 != __vc_get_feature_enabled()) {
2084                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2085         }
2086         if (0 != __vc_check_privilege()) {
2087                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2088         }
2089
2090         if (NULL == callback)
2091                 return VC_ERROR_INVALID_PARAMETER;
2092
2093         vc_state_e state;
2094         if (0 != vc_client_get_client_state(g_vc, &state)) {
2095                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : A handle is not available");
2096                 return VC_ERROR_INVALID_STATE;
2097         }
2098
2099         /* check state */
2100         if (state != VC_STATE_INITIALIZED) {
2101                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set current language changed : Current state is not 'Initialized'");
2102                 return VC_ERROR_INVALID_STATE;
2103         }
2104
2105         vc_client_set_current_lang_changed_cb(g_vc, callback, user_data);
2106
2107         return 0;
2108 }
2109
2110 int vc_unset_current_language_changed_cb(void)
2111 {
2112         if (0 != __vc_get_feature_enabled()) {
2113                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2114         }
2115         if (0 != __vc_check_privilege()) {
2116                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2117         }
2118
2119         vc_state_e state;
2120         if (0 != vc_client_get_client_state(g_vc, &state)) {
2121                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : A handle is not available");
2122                 return VC_ERROR_INVALID_STATE;
2123         }
2124
2125         /* check state */
2126         if (state != VC_STATE_INITIALIZED) {
2127                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2128                 return VC_ERROR_INVALID_STATE;
2129         }
2130
2131         vc_client_set_current_lang_changed_cb(g_vc, NULL, NULL);
2132
2133         return 0;
2134 }
2135
2136 int vc_set_error_cb(vc_error_cb callback, void* user_data)
2137 {
2138         if (0 != __vc_get_feature_enabled()) {
2139                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2140         }
2141         if (0 != __vc_check_privilege()) {
2142                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2143         }
2144
2145         if (NULL == callback)
2146                 return VC_ERROR_INVALID_PARAMETER;
2147
2148         vc_state_e state;
2149         if (0 != vc_client_get_client_state(g_vc, &state)) {
2150                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : A handle is not available");
2151                 return VC_ERROR_INVALID_STATE;
2152         }
2153
2154         /* check state */
2155         if (state != VC_STATE_INITIALIZED) {
2156                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set error callback : Current state is not 'Initialized'");
2157                 return VC_ERROR_INVALID_STATE;
2158         }
2159
2160         vc_client_set_error_cb(g_vc, callback,  user_data);
2161
2162         return 0;
2163 }
2164
2165 int vc_unset_error_cb(void)
2166 {
2167         if (0 != __vc_get_feature_enabled()) {
2168                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2169         }
2170         if (0 != __vc_check_privilege()) {
2171                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2172         }
2173
2174         vc_state_e state;
2175         if (0 != vc_client_get_client_state(g_vc, &state)) {
2176                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : A handle is not available");
2177                 return VC_ERROR_INVALID_STATE;
2178         }
2179
2180         /* check state */
2181         if (state != VC_STATE_INITIALIZED) {
2182                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2183                 return VC_ERROR_INVALID_STATE;
2184         }
2185
2186         vc_client_set_error_cb(g_vc, NULL, NULL);
2187
2188         return 0;
2189 }
2190
2191 int vc_set_invocation_name(const char* name)
2192 {
2193         if (0 != __vc_get_feature_enabled()) {
2194                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2195         }
2196         if (0 != __vc_check_privilege()) {
2197                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2198         }
2199
2200         vc_state_e state;
2201         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set invocation name");
2202
2203         int ret = vc_client_get_client_state(g_vc, &state);
2204         if (0 != ret) {
2205                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2206                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2207                 return ret;
2208         }
2209
2210         /* check state */
2211         if (state != VC_STATE_READY) {
2212                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'");
2213                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2214                 return VC_ERROR_INVALID_STATE;
2215         }
2216
2217         ret = vc_client_set_invocation_name(g_vc, name);
2218         if (0 != ret) {
2219                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set invocation name");
2220         }
2221         return ret;
2222 }
2223
2224 //LCOV_EXCL_START
2225 int vc_set_server_dialog(const char* app_id, const char* credential)
2226 {
2227         vc_state_e state;
2228         int ret = -1;
2229
2230         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Set server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2231         if (0 != __vc_get_feature_enabled()) {
2232                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2233         }
2234         if (0 != __vc_check_privilege()) {
2235                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2236         }
2237
2238         if (NULL == credential) {
2239                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Credential is NULL");
2240                 return VC_ERROR_INVALID_PARAMETER;
2241         }
2242
2243         if (0 != vc_client_get_client_state(g_vc, &state)) {
2244                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2245                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2246                 return VC_ERROR_INVALID_STATE;
2247         }
2248
2249         /* check state */
2250         if (state != VC_STATE_READY) {
2251                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2252                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2253                 return VC_ERROR_INVALID_STATE;
2254         }
2255
2256         /* Check service state */
2257         vc_service_state_e service_state = -1;
2258         vc_client_get_service_state(g_vc, &service_state);
2259         if (service_state != VC_SERVICE_STATE_READY) {
2260                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2261                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2262                 return VC_ERROR_INVALID_STATE;
2263         }
2264
2265         char* tmp_appid = NULL;
2266         if (NULL == app_id) {
2267                 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2268                 if (0 != ret || NULL == tmp_appid) {
2269                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2270                         FREE(tmp_appid);
2271                         return VC_ERROR_INVALID_PARAMETER;
2272                 }
2273         } else {
2274                 tmp_appid = strdup(app_id);
2275         }
2276         int pid = getpid();
2277
2278         SLOG(LOG_DEBUG, TAG_VCC, "Set server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2279
2280         int count = 0;
2281         bool is_prepared = false;
2282         do {
2283                 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2284                 if (0 != ret) {
2285                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2286                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2287                                 if (0 == vc_prepare_sync()) {
2288                                         is_prepared = true;
2289                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2290                                 }
2291                         } else if (VC_ERROR_TIMED_OUT != ret) {
2292                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request set server dialog to vc service : %s", __vc_get_error_code(ret));
2293                                 break;
2294                         } else {
2295                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request set server dialog : %s", __vc_get_error_code(ret));
2296                                 usleep(10000);
2297                                 count++;
2298                                 if (VC_RETRY_COUNT == count) {
2299                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2300                                         break;
2301                                 }
2302                         }
2303                 }
2304         } while (0 != ret);
2305
2306         FREE(tmp_appid);
2307
2308         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2309
2310         return ret;
2311 }
2312
2313 int vc_unset_server_dialog(const char* app_id)
2314 {
2315         vc_state_e state;
2316         int ret = -1;
2317
2318         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Unset server dialog, pid(%d), app_id(%s)", getpid(), app_id);
2319         if (0 != __vc_get_feature_enabled()) {
2320                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2321         }
2322         if (0 != __vc_check_privilege()) {
2323                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2324         }
2325
2326         if (0 != vc_client_get_client_state(g_vc, &state)) {
2327                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2328                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2329                 return VC_ERROR_INVALID_STATE;
2330         }
2331
2332         /* check state */
2333         if (state != VC_STATE_READY) {
2334                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
2335                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2336                 return VC_ERROR_INVALID_STATE;
2337         }
2338
2339         /* Check service state */
2340         vc_service_state_e service_state = -1;
2341         vc_client_get_service_state(g_vc, &service_state);
2342         if (service_state != VC_SERVICE_STATE_READY) {
2343                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
2344                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2345                 return VC_ERROR_INVALID_STATE;
2346         }
2347
2348         char* tmp_appid = NULL;
2349         if (NULL == app_id) {
2350                 ret = app_manager_get_app_id(getpid(), &tmp_appid);
2351                 if (0 != ret || NULL == tmp_appid) {
2352                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] app_id is NULL");
2353                         FREE(tmp_appid);
2354                         return VC_ERROR_INVALID_PARAMETER;
2355                 }
2356         } else {
2357                 tmp_appid = strdup(app_id);
2358         }
2359         int pid = getpid();
2360
2361         SLOG(LOG_DEBUG, TAG_VCC, "Unset server dialog : pid(%d), app_id(%s)", pid, tmp_appid);
2362
2363         int count = 0;
2364         bool is_prepared = false;
2365         char* credential = strdup("#NULL");
2366         do {
2367                 ret = vc_dbus_set_server_dialog(pid, tmp_appid, credential);
2368                 if (0 != ret) {
2369                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2370                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2371                                 if (0 == vc_prepare_sync()) {
2372                                         is_prepared = true;
2373                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2374                                 }
2375                         } else if (VC_ERROR_TIMED_OUT != ret) {
2376                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request unset server dialog to vc service : %s", __vc_get_error_code(ret));
2377                                 break;
2378                         } else {
2379                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request unset server dialog : %s", __vc_get_error_code(ret));
2380                                 usleep(10000);
2381                                 count++;
2382                                 if (VC_RETRY_COUNT == count) {
2383                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2384                                         break;
2385                                 }
2386                         }
2387                 }
2388         } while (0 != ret);
2389
2390         FREE(tmp_appid);
2391         FREE(credential);
2392
2393         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2394
2395         return ret;
2396 }
2397 //LCOV_EXCL_STOP
2398
2399 int vc_request_dialog(const char* disp_text, const char* utt_text, bool auto_start)
2400 {
2401         vc_state_e state;
2402
2403         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request dialog");
2404         if (0 != __vc_get_feature_enabled()) {
2405                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
2406         }
2407         if (0 != __vc_check_privilege()) {
2408                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
2409         }
2410
2411         if (0 != vc_client_get_client_state(g_vc, &state)) {
2412                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
2413                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2414                 return VC_ERROR_INVALID_STATE;
2415         }
2416
2417         /* check state */
2418         if (state != VC_STATE_READY) {
2419                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'READY'"); //LCOV_EXCL_LINE
2420                 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2421                 return VC_ERROR_INVALID_STATE;
2422         }
2423
2424         /* Check service state */
2425         vc_service_state_e service_state = -1;
2426         vc_client_get_service_state(g_vc, &service_state);
2427         if (service_state != VC_SERVICE_STATE_READY) {
2428                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'"); //LCOV_EXCL_LINE
2429                 SLOG(LOG_DEBUG, TAG_VCC, "@@@"); //LCOV_EXCL_LINE
2430                 return VC_ERROR_INVALID_STATE;
2431         }
2432
2433         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);
2434         int ret = vc_dbus_request_dialog(getpid(), disp_text, utt_text, auto_start);
2435         if (0 != ret) {
2436                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request dialog, ret(%d)", ret);
2437                 return VC_ERROR_OPERATION_FAILED;
2438         }
2439
2440         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2441
2442         return VC_ERROR_NONE;
2443 }
2444
2445 //LCOV_EXCL_START
2446 /* Authority */
2447 int vc_auth_enable(void)
2448 {
2449         /* check state */
2450         vc_state_e state;
2451         if (0 != vc_client_get_client_state(g_vc, &state)) {
2452                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2453                 return VC_ERROR_INVALID_STATE;
2454         }
2455
2456         if (VC_STATE_READY != state) {
2457                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2458                 return VC_ERROR_INVALID_STATE;
2459         }
2460
2461         /* check already authority */
2462         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2463         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2464                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2465                 return VC_ERROR_INVALID_STATE;
2466         }
2467
2468         if (VC_AUTH_STATE_NONE != auth_state) {
2469                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Already authority enabled");
2470                 return VC_ERROR_INVALID_STATE;
2471         }
2472
2473         /* request authority */
2474         int mgr_pid = -1;
2475         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2476                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2477                 return VC_ERROR_OPERATION_FAILED;
2478         }
2479
2480         if (0 != vc_dbus_request_auth_enable(g_vc->handle, mgr_pid)) {
2481                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority enabled");
2482                 return VC_ERROR_OPERATION_FAILED;
2483         }
2484
2485         /* set authority into handle */
2486         bool is_foreground = false;
2487         if (0 != vc_client_get_is_foreground(g_vc, &is_foreground)) {
2488                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get is_foreground");
2489                 return VC_ERROR_OPERATION_FAILED;
2490         }
2491
2492         if (is_foreground) {
2493                 auth_state = VC_AUTH_STATE_VALID;
2494         } else {
2495                 auth_state = VC_AUTH_STATE_INVALID;
2496         }
2497
2498         if (0 != vc_client_set_auth_state(g_vc, auth_state)) {
2499                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2500                 return VC_ERROR_OPERATION_FAILED;
2501         }
2502
2503         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2504
2505         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth enable");
2506
2507         return VC_ERROR_NONE;
2508 }
2509
2510 int vc_auth_disable(void)
2511 {
2512         /* check state */
2513         vc_state_e state;
2514         if (0 != vc_client_get_client_state(g_vc, &state)) {
2515                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2516                 return VC_ERROR_INVALID_STATE;
2517         }
2518
2519         if (VC_STATE_READY != state) {
2520                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2521                 return VC_ERROR_INVALID_STATE;
2522         }
2523
2524         /* check authority */
2525         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2526         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2527                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2528                 return VC_ERROR_INVALID_STATE;
2529         }
2530
2531         if (VC_AUTH_STATE_NONE == auth_state) {
2532                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] No authority");
2533                 return VC_ERROR_INVALID_STATE;
2534         }
2535
2536         if (0 != vc_auth_unset_state_changed_cb()) {
2537                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset state changed cb");
2538         }
2539
2540         /* request return authority by dbus */
2541         int mgr_pid = -1;
2542         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2543                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2544                 return VC_ERROR_OPERATION_FAILED;
2545         }
2546
2547         if (0 != vc_dbus_request_auth_disable(g_vc->handle, mgr_pid)) {
2548                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to authority disable");
2549                 return VC_ERROR_OPERATION_FAILED;
2550         }
2551
2552         /* unset authority from handle */
2553         if (0 != vc_client_set_auth_state(g_vc, VC_AUTH_STATE_NONE)) {
2554                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state");
2555                 return VC_ERROR_OPERATION_FAILED;
2556         }
2557
2558         ecore_timer_add(0, __notify_auth_changed_cb, NULL);
2559
2560         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Auth disable");
2561
2562         return VC_ERROR_NONE;
2563 }
2564
2565 int vc_auth_get_state(vc_auth_state_e* state)
2566 {
2567         /* check state */
2568         vc_state_e vc_state;
2569         if (0 != vc_client_get_client_state(g_vc, &vc_state)) {
2570                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2571                 return VC_ERROR_INVALID_STATE;
2572         }
2573
2574         if (VC_STATE_READY != vc_state) {
2575                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Current state is not 'READY'");
2576                 return VC_ERROR_INVALID_STATE;
2577         }
2578
2579         /* get authority */
2580         vc_auth_state_e temp = VC_AUTH_STATE_NONE;
2581         if (0 != vc_client_get_auth_state(g_vc, &temp)) {
2582                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] handle is not available");
2583                 return VC_ERROR_INVALID_STATE;
2584         }
2585
2586         *state = temp;
2587
2588         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Current auth state is %d", *state);
2589
2590         return VC_ERROR_NONE;
2591 }
2592
2593 int vc_auth_set_state_changed_cb(vc_auth_state_changed_cb callback, void* user_data)
2594 {
2595         /* check parameter */
2596         if (NULL == callback) {
2597                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL Parameter");
2598                 return VC_ERROR_INVALID_PARAMETER;
2599         }
2600
2601         /* check auth */
2602         vc_auth_state_e auth_state;
2603         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2604                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2605                 return VC_ERROR_INVALID_STATE;
2606         }
2607
2608         if (VC_AUTH_STATE_NONE == auth_state) {
2609                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auth is not enabled");
2610                 return VC_ERROR_INVALID_STATE;
2611         }
2612
2613         /* set cb into handle */
2614         if (0 != vc_client_set_auth_state_changed_cb(g_vc, callback, user_data)) {
2615                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to set auth state changed cb");
2616                 return VC_ERROR_OPERATION_FAILED;
2617         }
2618
2619         SLOG(LOG_DEBUG,  TAG_VCC, "[SUCCESS] Set auth state changed cb");
2620
2621         return VC_ERROR_NONE;
2622 }
2623
2624 int vc_auth_unset_state_changed_cb(void)
2625 {
2626         /* check auth */
2627         vc_auth_state_e auth_state;
2628         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2629                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Handle is not available");
2630                 return VC_ERROR_INVALID_STATE;
2631         }
2632
2633         if (VC_AUTH_STATE_NONE == auth_state) {
2634                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Auto is not enabled");
2635                 return VC_ERROR_INVALID_STATE;
2636         }
2637
2638         /* unset cb from handle */
2639         if (0 != vc_client_unset_auth_state_changed_cb(g_vc)) {
2640                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to unset auth state changed cb");
2641                 return VC_ERROR_OPERATION_FAILED;
2642         }
2643
2644         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Unset auth state changed cb");
2645
2646         return VC_ERROR_NONE;
2647 }
2648
2649 int vc_auth_start(void)
2650 {
2651         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request start");
2652
2653         vc_state_e state;
2654         if (0 != vc_client_get_client_state(g_vc, &state)) {
2655                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2656                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2657                 return VC_ERROR_INVALID_STATE;
2658         }
2659
2660         /* check state */
2661         if (state != VC_STATE_READY) {
2662                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'READY'");
2663                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2664                 return VC_ERROR_INVALID_STATE;
2665         }
2666
2667         /* Check service state */
2668         vc_service_state_e service_state = -1;
2669         vc_client_get_service_state(g_vc, &service_state);
2670         if (service_state != VC_SERVICE_STATE_READY) {
2671                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'READY'");
2672                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2673                 return VC_ERROR_INVALID_STATE;
2674         }
2675
2676         /* Check authority */
2677         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2678         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2679                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2680                 return VC_ERROR_OPERATION_FAILED;
2681         }
2682
2683         if (VC_AUTH_STATE_VALID != auth_state) {
2684                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2685                 return VC_ERROR_OPERATION_FAILED;
2686         }
2687
2688         /* get mgr_pid */
2689         int mgr_pid = -1;
2690         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2691                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2692                 return VC_ERROR_OPERATION_FAILED;
2693         }
2694
2695         int ret = -1;
2696         int count = 0;
2697         bool is_prepared = false;
2698         /* Request */
2699         while (0 != ret) {
2700                 ret = vc_dbus_request_auth_start(g_vc->handle, mgr_pid);
2701                 if (0 != ret) {
2702                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2703                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2704                                 if (0 == vc_prepare_sync()) {
2705                                         is_prepared = true;
2706                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2707                                 }
2708                         } else if (VC_ERROR_TIMED_OUT != ret) {
2709                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request auth start : %s", __vc_get_error_code(ret));
2710                                 break;
2711                         } else {
2712                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth start : %s", __vc_get_error_code(ret));
2713                                 usleep(10000);
2714                                 count++;
2715                                 if (VC_RETRY_COUNT == count) {
2716                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2717                                         break;
2718                                 }
2719                         }
2720                 } else {
2721                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth start");
2722                 }
2723         }
2724
2725         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2726
2727         return ret;
2728 }
2729
2730 int vc_auth_stop(void)
2731 {
2732         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request stop");
2733
2734         vc_state_e state;
2735         if (0 != vc_client_get_client_state(g_vc, &state)) {
2736                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2737                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2738                 return VC_ERROR_INVALID_STATE;
2739         }
2740
2741         /* check state */
2742         if (state != VC_STATE_READY) {
2743                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: client state is not 'Ready'");
2744                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2745                 return VC_ERROR_INVALID_STATE;
2746         }
2747
2748         /* Check service state */
2749         vc_service_state_e service_state = -1;
2750         vc_client_get_service_state(g_vc, &service_state);
2751         if (service_state != VC_SERVICE_STATE_RECORDING) {
2752                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING'");
2753                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2754                 return VC_ERROR_INVALID_STATE;
2755         }
2756
2757         /* Check authority */
2758         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2759         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2760                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2761                 return VC_ERROR_OPERATION_FAILED;
2762         }
2763
2764         if (VC_AUTH_STATE_VALID != auth_state) {
2765                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2766                 return VC_ERROR_OPERATION_FAILED;
2767         }
2768
2769         /* get mgr_pid */
2770         int mgr_pid = -1;
2771         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2772                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2773                 return VC_ERROR_OPERATION_FAILED;
2774         }
2775
2776         int ret = -1;
2777         int count = 0;
2778         bool is_prepared = false;
2779         /* do request */
2780         while (0 != ret) {
2781                 ret = vc_dbus_request_auth_stop(g_vc->handle, mgr_pid);
2782                 if (0 != ret) {
2783                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2784                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2785                                 if (0 == vc_prepare_sync()) {
2786                                         is_prepared = true;
2787                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2788                                 }
2789                         } else if (VC_ERROR_TIMED_OUT != ret) {
2790                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth stop: %s", __vc_get_error_code(ret));
2791                                 break;
2792                         } else {
2793                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth stop: %s", __vc_get_error_code(ret));
2794                                 usleep(10000);
2795                                 count++;
2796                                 if (VC_RETRY_COUNT == count) {
2797                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2798                                         break;
2799                                 }
2800                         }
2801                 } else {
2802                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth stop");
2803                 }
2804         }
2805
2806         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2807
2808         return ret;
2809 }
2810
2811 int vc_auth_cancel(void)
2812 {
2813         SLOG(LOG_DEBUG, TAG_VCC, "@@@ [Client] Request cancel");
2814
2815         vc_state_e state;
2816         if (0 != vc_client_get_client_state(g_vc, &state)) {
2817                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not available");
2818                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2819                 return VC_ERROR_INVALID_STATE;
2820         }
2821
2822         /* check state */
2823         if (state != VC_STATE_READY) {
2824                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state is not 'Ready'");
2825                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2826                 return VC_ERROR_INVALID_STATE;
2827         }
2828
2829         /* Check service state */
2830         vc_service_state_e service_state = -1;
2831         vc_client_get_service_state(g_vc, &service_state);
2832         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
2833                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
2834                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2835                 return VC_ERROR_INVALID_STATE;
2836         }
2837
2838         /* Check authority */
2839         vc_auth_state_e auth_state = VC_AUTH_STATE_NONE;
2840         if (0 != vc_client_get_auth_state(g_vc, &auth_state)) {
2841                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get auth state");
2842                 return VC_ERROR_OPERATION_FAILED;
2843         }
2844
2845         if (VC_AUTH_STATE_VALID != auth_state) {
2846                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Not auth valid");
2847                 return VC_ERROR_OPERATION_FAILED;
2848         }
2849
2850         /* get mgr_pid */
2851         int mgr_pid = -1;
2852         if (0 != vc_client_get_mgr_pid(g_vc, &mgr_pid)) {
2853                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get mgr info");
2854                 return VC_ERROR_OPERATION_FAILED;
2855         }
2856
2857         int ret = -1;
2858         int count = 0;
2859         bool is_prepared = false;
2860         while (0 != ret) {
2861                 ret = vc_dbus_request_auth_cancel(g_vc->handle, mgr_pid);
2862                 if (0 != ret) {
2863                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
2864                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
2865                                 if (0 == vc_prepare_sync()) {
2866                                         is_prepared = true;
2867                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
2868                                 }
2869                         } else if (VC_ERROR_TIMED_OUT != ret) {
2870                                 SLOG(LOG_DEBUG, TAG_VCC, "[ERROR] Fail to request auth cancel: %s", __vc_get_error_code(ret));
2871                                 break;
2872                         } else {
2873                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request auth cancel: %s", __vc_get_error_code(ret));
2874                                 usleep(10000);
2875                                 count++;
2876                                 if (VC_RETRY_COUNT == count) {
2877                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
2878                                         break;
2879                                 }
2880                         }
2881                 } else {
2882                         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] request auth cancel");
2883                 }
2884         }
2885
2886         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
2887
2888         return ret;
2889 }
2890
2891 static void __start_tts_streaming_thread(void* data, Ecore_Thread* thread)
2892 {
2893         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] Start tts streaming thread");
2894
2895         vc_tts_streaming_cb callback = NULL;
2896         void* user_data = NULL;
2897
2898         vc_client_get_tts_streaming_cb(g_vc, &callback, &user_data);
2899         if (NULL == callback) {
2900                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] tts streaming callback is null");
2901                 return;
2902         }
2903
2904         while (1) {
2905                 int ret = -1;
2906                 int cnt = 0;
2907
2908                 /* get tts data */
2909                 vc_tts_data_s *tts_data = NULL;
2910                 ret = vc_data_get_first_tts_data(&tts_data);
2911                 if (0 != ret || NULL == tts_data) {
2912                         /* empty queue */
2913                         SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG] No tts data. Waiting mode");
2914
2915                         /* waiting */
2916                         while (1) {
2917                                 usleep(10000);
2918                                 if (0 < vc_data_get_tts_data_size()) {
2919                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Resume thread");
2920                                         break;
2921                                 }
2922                                 if (200 < cnt) {
2923                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Wrong request, there's no pcm data");
2924                                         vc_data_clear_tts_data(&tts_data);
2925                                         return;
2926                                 }
2927                                 cnt++;
2928                         }
2929                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish to wait for new tts data come");
2930
2931                         /* resume tts thread */
2932                         vc_data_clear_tts_data(&tts_data);
2933                         continue;
2934                 }
2935
2936                 if (NULL != tts_data) {
2937                         SLOG(LOG_DEBUG, TAG_VCC, "tts streaming callback is called");
2938                         vc_client_use_callback(g_vc);
2939                         callback(tts_data->event, tts_data->data, tts_data->data_size, tts_data->utt_id, user_data);
2940                         vc_client_not_use_callback(g_vc);
2941
2942                         /* If no tts data and EVENT_FINISH */
2943                         if (0 >= vc_data_get_tts_data_size() && VC_TTS_EVENT_FINISH == tts_data->event) {
2944                                 SLOG(LOG_INFO, TAG_VCC, "[INFO] Finish tts");
2945                                 FREE(tts_data)
2946                                 break;
2947                         }
2948                         FREE(tts_data);
2949                 }
2950         }
2951 }
2952
2953 static void __end_tts_streaming_thread(void* data, Ecore_Thread* thread)
2954 {
2955         SLOG(LOG_DEBUG, TAG_VCC, "[SUCCESS] End tts streaming thread");
2956         g_tts_thread = NULL;
2957 }
2958
2959 int __vc_cb_tts_streaming(int utt_id, vc_tts_event_e event, char* buffer, int len)
2960 {
2961         /* add tts data */
2962         vc_tts_data_s* temp_tts_data = NULL;
2963         temp_tts_data = (vc_tts_data_s*)calloc(1, sizeof(vc_tts_data_s));
2964         if (NULL == temp_tts_data) {
2965                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Out of memory");
2966                 return VC_ERROR_OUT_OF_MEMORY;
2967         }
2968
2969         temp_tts_data->data = NULL;
2970         temp_tts_data->data_size = 0;
2971
2972         if (0 < len) {
2973                 temp_tts_data->data = (char*)calloc(len + 5, sizeof(char));
2974                 if (NULL != temp_tts_data->data) {
2975                         memcpy(temp_tts_data->data, buffer, len);
2976                         temp_tts_data->data_size = len;
2977                         SLOG(LOG_DEBUG, TAG_VCC, "[DEBUG][memcpy] data(%p) size(%d)",
2978                                         temp_tts_data->data, temp_tts_data->data_size);
2979                 } else {
2980                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] fail to allocate memory");
2981                 }
2982         } else {
2983                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] tts data is NULL");
2984         }
2985
2986         temp_tts_data->utt_id = utt_id;
2987         temp_tts_data->event = event;
2988
2989         int ret = vc_data_add_tts_data(temp_tts_data);
2990         if (0 != ret) {
2991                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to add tts data");
2992                 FREE(temp_tts_data->data);
2993                 FREE(temp_tts_data);
2994         }
2995
2996         bool is_canceled = ecore_thread_check(g_tts_thread);
2997         if (NULL == g_tts_thread || TRUE == is_canceled) {
2998                 SLOG(LOG_INFO, TAG_VCC, "ecore thread run : __start_tts_streaming_thread ");
2999                 g_tts_thread = ecore_thread_run(__start_tts_streaming_thread, __end_tts_streaming_thread, NULL, NULL);
3000         }
3001
3002         return ret;
3003 }
3004
3005 int vc_tts_request(const char* text, const char* language, bool to_vc_manager, int* utt_id)
3006 {
3007         vc_state_e state;
3008         int ret = -1;
3009         int pid = getpid();
3010
3011         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Request tts");
3012
3013         if (0 != __vc_get_feature_enabled()) {
3014                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3015         }
3016         if (0 != __vc_check_privilege()) {
3017                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3018         }
3019
3020         if (0 != vc_client_get_client_state(g_vc, &state)) {
3021                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3022                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3023                 return VC_ERROR_INVALID_STATE;
3024         }
3025
3026         /* check state */
3027         if (state != VC_STATE_READY) {
3028                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3029                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3030                 return VC_ERROR_INVALID_STATE;
3031         }
3032
3033         /* Check service state */
3034         vc_service_state_e service_state = -1;
3035         vc_client_get_service_state(g_vc, &service_state);
3036         if (service_state != VC_SERVICE_STATE_READY) {
3037                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3038                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3039                 return VC_ERROR_INVALID_STATE;
3040         }
3041
3042         SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts request, pid(%d), text(%s), language(%s), to_vc_manager(%d)", pid, text, language, to_vc_manager);
3043
3044         int count = 0;
3045         bool is_prepared = false;
3046         do {
3047                 ret = vc_dbus_request_tts(pid, text, language, to_vc_manager, utt_id);
3048                 if (0 != ret) {
3049                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3050                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3051                                 if (0 == vc_prepare_sync()) {
3052                                         is_prepared = true;
3053                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3054                                 }
3055                         } else if (VC_ERROR_TIMED_OUT != ret) {
3056                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request tts to vc service : %s", __vc_get_error_code(ret));
3057                                 break;
3058                         } else {
3059                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry request tts : %s", __vc_get_error_code(ret));
3060                                 usleep(10000);
3061                                 count++;
3062                                 if (VC_RETRY_COUNT == count) {
3063                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to request");
3064                                         break;
3065                                 }
3066                         }
3067                 }
3068         } while (0 != ret);
3069
3070         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3071
3072         return ret;
3073 }
3074
3075 int vc_tts_cancel(int utt_id)
3076 {
3077         vc_state_e state;
3078         int ret = -1;
3079         int pid = getpid();
3080
3081         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Cancel tts");
3082
3083         if (0 != __vc_get_feature_enabled()) {
3084                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3085         }
3086         if (0 != __vc_check_privilege()) {
3087                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3088         }
3089
3090         if (0 != vc_client_get_client_state(g_vc, &state)) {
3091                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3092                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3093                 return VC_ERROR_INVALID_STATE;
3094         }
3095
3096         /* check state */
3097         if (state != VC_STATE_READY) {
3098                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3099                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3100                 return VC_ERROR_INVALID_STATE;
3101         }
3102
3103         /* Check service state */
3104         vc_service_state_e service_state = -1;
3105         vc_client_get_service_state(g_vc, &service_state);
3106         if (service_state != VC_SERVICE_STATE_READY) {
3107                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3108                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3109                 return VC_ERROR_INVALID_STATE;
3110         }
3111
3112         SLOG(LOG_DEBUG, TAG_VCC, "@@@ tts cancel, pid(%d), utt_id(%d)", pid, utt_id);
3113
3114         ret = vc_data_clear_tts_data_by_uttid(utt_id);
3115         if (0 != ret) {
3116                 SLOG(LOG_INFO, TAG_VCC, "[INFO] There's no data in client pcm queue");
3117         }
3118
3119         int count = 0;
3120         bool is_prepared = false;
3121         do {
3122                 ret = vc_dbus_cancel_tts(pid, utt_id);
3123                 if (0 != ret) {
3124                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3125                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3126                                 if (0 == vc_prepare_sync()) {
3127                                         is_prepared = true;
3128                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3129                                 }
3130                         } else if (VC_ERROR_TIMED_OUT != ret) {
3131                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel tts to vc service : %s", __vc_get_error_code(ret));
3132                                 break;
3133                         } else {
3134                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry cancel tts : %s", __vc_get_error_code(ret));
3135                                 usleep(10000);
3136                                 count++;
3137                                 if (VC_RETRY_COUNT == count) {
3138                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to cancel");
3139                                         break;
3140                                 }
3141                         }
3142                 }
3143         } while (0 != ret);
3144
3145         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3146
3147         return ret;
3148 }
3149
3150 int vc_tts_get_synthesized_audio_details(int* rate, vc_audio_channel_e* channel, vc_audio_type_e* audio_type)
3151 {
3152         vc_state_e state;
3153         int ret = -1;
3154         int pid = getpid();
3155
3156         SLOG(LOG_DEBUG, TAG_VCC, "@@@ Get tts audio format");
3157
3158         if (0 != __vc_get_feature_enabled()) {
3159                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3160         }
3161         if (0 != __vc_check_privilege()) {
3162                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3163         }
3164
3165         if (0 != vc_client_get_client_state(g_vc, &state)) {
3166                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] A handle is not valid");
3167                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3168                 return VC_ERROR_INVALID_STATE;
3169         }
3170
3171         /* check state */
3172         if (state != VC_STATE_READY) {
3173                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
3174                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3175                 return VC_ERROR_INVALID_STATE;
3176         }
3177
3178         /* Check service state */
3179         vc_service_state_e service_state = -1;
3180         vc_client_get_service_state(g_vc, &service_state);
3181         if (service_state != VC_SERVICE_STATE_READY) {
3182                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
3183                 SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3184                 return VC_ERROR_INVALID_STATE;
3185         }
3186
3187         SLOG(LOG_DEBUG, TAG_VCC, "@@@ get tts audio format, pid(%d)", pid);
3188
3189         int count = 0;
3190         bool is_prepared = false;
3191         do {
3192                 ret = vc_dbus_get_tts_audio_format(pid, rate, channel, audio_type);
3193                 if (0 != ret) {
3194                         if (VC_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
3195                                 vc_client_set_client_state(g_vc, VC_STATE_INITIALIZED);
3196                                 if (0 == vc_prepare_sync()) {
3197                                         is_prepared = true;
3198                                         SLOG(LOG_INFO, TAG_VCC, "[INFO] Success vc_prepare_sync");
3199                                 }
3200                         } else if (VC_ERROR_TIMED_OUT != ret) {
3201                                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format : %s", __vc_get_error_code(ret));
3202                                 break;
3203                         } else {
3204                                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] retry to get tts audio format : %s", __vc_get_error_code(ret));
3205                                 usleep(10000);
3206                                 count++;
3207                                 if (VC_RETRY_COUNT == count) {
3208                                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to get tts audio format");
3209                                         break;
3210                                 }
3211                         }
3212                 }
3213         } while (0 != ret);
3214
3215         SLOG(LOG_DEBUG, TAG_VCC, "@@@");
3216
3217         return ret;
3218 }
3219
3220 int vc_tts_set_streaming_cb(vc_tts_streaming_cb callback, void* user_data)
3221 {
3222         if (0 != __vc_get_feature_enabled()) {
3223                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3224         }
3225         if (0 != __vc_check_privilege()) {
3226                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3227         }
3228
3229         if (NULL == callback)
3230                 return VC_ERROR_INVALID_PARAMETER;
3231
3232         vc_state_e state;
3233         if (0 != vc_client_get_client_state(g_vc, &state)) {
3234                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : A handle is not available");
3235                 return VC_ERROR_INVALID_STATE;
3236         }
3237
3238         /* check state */
3239         if (state != VC_STATE_INITIALIZED) {
3240                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts streaming callback : Current state(%d) is not 'Initialized'", state);
3241                 return VC_ERROR_INVALID_STATE;
3242         }
3243
3244         vc_client_set_tts_streaming_cb(g_vc, callback,  user_data);
3245
3246         return 0;
3247 }
3248
3249 int vc_tts_unset_streaming_cb(void)
3250 {
3251         if (0 != __vc_get_feature_enabled()) {
3252                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3253         }
3254         if (0 != __vc_check_privilege()) {
3255                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3256         }
3257
3258         vc_state_e state;
3259         if (0 != vc_client_get_client_state(g_vc, &state)) {
3260                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : A handle is not available");
3261                 return VC_ERROR_INVALID_STATE;
3262         }
3263
3264         /* check state */
3265         if (state != VC_STATE_INITIALIZED) {
3266                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts streaming callback : Current state(%d) is not 'Initialized'", state);
3267                 return VC_ERROR_INVALID_STATE;
3268         }
3269
3270         vc_client_set_tts_streaming_cb(g_vc, NULL, NULL);
3271
3272         return 0;
3273 }
3274
3275 int __vc_cb_utterance_status(int utt_id, int utt_status)
3276 {
3277         vc_tts_utterance_status_cb callback = NULL;
3278         void* user_data = NULL;
3279
3280         vc_client_get_tts_utterance_status_cb(g_vc, &callback, &user_data);
3281         if (NULL == callback) {
3282                 SLOG(LOG_WARN, TAG_VCC, "[WARNING] Utterance status callback is null");
3283                 return -1;
3284         }
3285
3286         SLOG(LOG_DEBUG, TAG_VCC, "Utterance status callback is called");
3287         vc_client_use_callback(g_vc);
3288         callback(utt_id, (vc_tts_utterance_status_e)utt_status, user_data);
3289         vc_client_not_use_callback(g_vc);
3290
3291         return 0;
3292 }
3293
3294 int vc_tts_set_utterance_status_cb(vc_tts_utterance_status_cb callback, void* user_data)
3295 {
3296         if (0 != __vc_get_feature_enabled()) {
3297                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3298         }
3299         if (0 != __vc_check_privilege()) {
3300                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3301         }
3302
3303         if (NULL == callback)
3304                 return VC_ERROR_INVALID_PARAMETER;
3305
3306         vc_state_e state;
3307         if (0 != vc_client_get_client_state(g_vc, &state)) {
3308                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : A handle is not available");
3309                 return VC_ERROR_INVALID_STATE;
3310         }
3311
3312         /* check state */
3313         if (state != VC_STATE_INITIALIZED) {
3314                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Set tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3315                 return VC_ERROR_INVALID_STATE;
3316         }
3317
3318         vc_client_set_tts_utterance_status_cb(g_vc, callback,  user_data);
3319
3320         return 0;
3321 }
3322
3323 int vc_tts_unset_utterance_status_cb(void)
3324 {
3325         if (0 != __vc_get_feature_enabled()) {
3326                 return VC_ERROR_NOT_SUPPORTED;  //LCOV_EXCL_LINE
3327         }
3328         if (0 != __vc_check_privilege()) {
3329                 return VC_ERROR_PERMISSION_DENIED;      //LCOV_EXCL_LINE
3330         }
3331
3332         vc_state_e state;
3333         if (0 != vc_client_get_client_state(g_vc, &state)) {
3334                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : A handle is not available");
3335                 return VC_ERROR_INVALID_STATE;
3336         }
3337
3338         /* check state */
3339         if (state != VC_STATE_INITIALIZED) {
3340                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Unset tts utterance status callback : Current state(%d) is not 'Initialized'", state);
3341                 return VC_ERROR_INVALID_STATE;
3342         }
3343
3344         vc_client_set_tts_utterance_status_cb(g_vc, NULL, NULL);
3345
3346         return 0;
3347 }
3348 //LCOV_EXCL_STOP