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