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