client/vc.c

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