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