client/vc_mgr.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 <system_info.h>
  19 #include <cynara-client.h>
  20 #include <cynara-error.h>
  21 #include <cynara-session.h>
  22 #include <pthread.h>
  23 #include <math.h>
  24
  25 #include "vc_cmd_db.h"
  26 #include "vc_config_mgr.h"
  27 #include "vc_command.h"
  28 #include "vc_info_parser.h"
  29 #include "vc_json_parser.h"
  30 #include "vc_main.h"
  31 #include "vc_mgr_core.h"
  32 #include "vc_mgr_client.h"
  33 #include "vc_mgr_tidl.h"
  34 #include "vc_mgr_data.h"
  35 #include "vc_mgr_ducking.h"
  36 #include "voice_control_command.h"
  37 #include "voice_control_command_expand.h"
  38 #include "voice_control_common.h"
  39 #include "voice_control_manager.h"
  40 #include "voice_control_manager_internal.h"
  41
  42
  43 #define VC_MANAGER_CONFIG_HANDLE        10000000
  44
  45 static Ecore_Timer* g_send_hello_timer = NULL;
  46 static Ecore_Timer* g_request_init_timer = NULL;
  47 static int g_tidl_send_hello_count = 0;
  48
  49 static int g_pid;
  50
  51 static int g_daemon_pid = 0;
  52
  53 static int g_feature_enabled = -1;
  54
  55 static bool g_privilege_allowed = false;
  56
  57 static cynara *p_cynara = NULL;
  58 static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER;
  59
  60 /* for TTS feedback */
  61 static Ecore_Thread* g_feedback_thread = NULL;
  62
  63 static pthread_mutex_t g_feedback_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
  64 static pthread_mutex_t g_vc_tts_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
  65
  66 static Eina_Bool __vc_mgr_notify_state_changed(void *data);
  67
  68 static const char* __vc_mgr_get_error_code(vc_error_e err)
  69 {
  70         switch (err) {
  71         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
  72         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
  73         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
  74         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
  75         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
  76         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
  77         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
  78         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
  79         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
  80         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
  81         default:                                return "Invalid error code";
  82         }
  83         return NULL;
  84 }
  85
  86 static void __vc_mgr_lang_changed_cb(const char* previous_lang, const char* current_lang)
  87 {
  88         SLOG(LOG_INFO, TAG_VCM, "Lang changed : previous lang(%s) current lang(%s)",
  89                                 previous_lang, current_lang);
  90
  91         vc_current_language_changed_cb callback = NULL;
  92         void* lang_user_data;
  93         vc_mgr_client_get_current_lang_changed_cb(&callback, &lang_user_data);
  94
  95         if (NULL != callback) {
  96                 vc_mgr_client_use_callback();
  97                 callback(previous_lang, current_lang, lang_user_data);
  98                 vc_mgr_client_not_use_callback();
  99                 SLOG(LOG_INFO, TAG_VCM, "Language changed callback is called");
 100         } else {
 101                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Language changed callback is null");
 102         }
 103
 104         return;
 105 }
 106
 107 static int __vc_mgr_get_feature_enabled()
 108 {
 109         if (0 == g_feature_enabled) {
 110                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
 111                 return VC_ERROR_NOT_SUPPORTED;
 112         } else if (-1 == g_feature_enabled) {
 113                 bool vc_supported = false;
 114                 bool mic_supported = false;
 115                 if (0 == system_info_get_platform_bool(VC_MGR_FEATURE_PATH, &vc_supported)) {
 116                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
 117                                 if (false == vc_supported || false == mic_supported) {
 118                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
 119                                         g_feature_enabled = 0;
 120                                         return VC_ERROR_NOT_SUPPORTED;
 121                                 }
 122
 123                                 g_feature_enabled = 1;
 124                         }
 125                 }
 126         }
 127
 128         return VC_ERROR_NONE;
 129 }
 130
 131 static int __check_privilege_initialize()
 132 {
 133         int ret = cynara_initialize(&p_cynara, NULL);
 134         if (NULL == p_cynara || CYNARA_API_SUCCESS != ret) {
 135                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to initialize(%d)", ret);
 136                 return ret;
 137         }
 138
 139         return ret == CYNARA_API_SUCCESS;
 140 }
 141
 142 static int __check_privilege(const char* uid, const char * privilege)
 143 {
 144         FILE *fp = NULL;
 145         char label_path[1024] = "/proc/self/attr/current";
 146         char smack_label[1024] = {'\0',};
 147
 148         if (!p_cynara) {
 149                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] p_cynara is NULL");
 150                 return false;
 151         }
 152
 153         fp = fopen(label_path, "r");
 154         if (fp != NULL) {
 155                 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
 156                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to fread");
 157
 158                 fclose(fp);
 159         }
 160
 161         pid_t pid = getpid();
 162         char *session = cynara_session_from_pid(pid);
 163         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 164         if (session)
 165                 free(session);
 166         session = NULL;
 167
 168         if (ret != CYNARA_API_ACCESS_ALLOWED) {
 169                 SLOG(LOG_INFO, TAG_VCM, "[Client]cynara_check returned %d(Denied), p_cynara(%p), label(%s), session(%s), uid(%s), priv(%s)", ret, p_cynara, smack_label, session, uid, privilege);
 170                 return false;
 171         }
 172
 173         return true;
 174 }
 175
 176 static void __check_privilege_deinitialize()
 177 {
 178         if (p_cynara) {
 179                 int ret = cynara_finish(p_cynara);
 180                 if (ret != CYNARA_API_SUCCESS)
 181                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cynara finish %d", ret);
 182         }
 183         p_cynara = NULL;
 184 }
 185
 186 static int __vc_mgr_check_privilege()
 187 {
 188         if (true == g_privilege_allowed)
 189                 return VC_ERROR_NONE;
 190
 191         pthread_mutex_lock(&g_cynara_mutex);
 192
 193         if (false == g_privilege_allowed) {
 194                 bool ret = true;
 195                 ret = __check_privilege_initialize();
 196                 if (false == ret) {
 197                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] privilege initialize is failed");
 198                         g_privilege_allowed = false;
 199                         pthread_mutex_unlock(&g_cynara_mutex);
 200                         return VC_ERROR_PERMISSION_DENIED;
 201                 }
 202
 203                 char uid[32];
 204                 snprintf(uid, 32, "%d", getuid());
 205                 ret = true;
 206                 ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
 207                 if (false == ret) {
 208                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
 209                         __check_privilege_deinitialize();
 210                         g_privilege_allowed = false;
 211                         pthread_mutex_unlock(&g_cynara_mutex);
 212                         return VC_ERROR_PERMISSION_DENIED;
 213                 }
 214
 215                 ret = __check_privilege(uid, VC_MGR_PRIVILEGE);
 216                 if (false == ret) {
 217                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Permission is denied(%s)(%s)", VC_MGR_PRIVILEGE, uid);
 218                         __check_privilege_deinitialize();
 219                         g_privilege_allowed = false;
 220                         pthread_mutex_unlock(&g_cynara_mutex);
 221                         return VC_ERROR_PERMISSION_DENIED;
 222                 }
 223
 224                 __check_privilege_deinitialize();
 225         }
 226
 227         g_privilege_allowed = true;
 228         pthread_mutex_unlock(&g_cynara_mutex);
 229         return VC_ERROR_NONE;
 230 }
 231
 232 int __check_mgr_feature_privilege()
 233 {
 234         if (0 != __vc_mgr_get_feature_enabled()) {
 235                 SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
 236                 return VC_ERROR_NOT_SUPPORTED;
 237         }
 238
 239         if (0 != __vc_mgr_check_privilege()) {
 240                 return VC_ERROR_PERMISSION_DENIED;
 241         }
 242
 243         return VC_ERROR_NONE;
 244 }
 245
 246 int vc_mgr_initialize(void)
 247 {
 248         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Initialize");
 249
 250         int ret;
 251         ret = __check_mgr_feature_privilege();
 252         if (VC_ERROR_NONE != ret)
 253                 return ret;
 254
 255         /* check handle */
 256         if (true == vc_mgr_client_is_valid()) {
 257                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already initialized");
 258                 return VC_ERROR_NONE;
 259         }
 260
 261         if (0 != vc_mgr_tidl_open_connection()) {
 262                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open tidl connection");
 263                 return VC_ERROR_OPERATION_FAILED;
 264         }
 265
 266         if (0 != vc_mgr_client_create()) {
 267                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create client!!!!!");
 268                 return VC_ERROR_OUT_OF_MEMORY;
 269         }
 270
 271         g_pid = getpid();
 272         ret = vc_config_mgr_initialize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 273         if (0 != ret) {
 274                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to init config manager : %d", ret);
 275                 vc_mgr_client_destroy();
 276                 return VC_ERROR_OPERATION_FAILED;
 277         }
 278
 279         ret = vc_config_mgr_set_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_lang_changed_cb);
 280         if (0 != ret) {
 281                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set callback : %d", ret);
 282                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 283                 vc_mgr_client_destroy();
 284                 return VC_ERROR_OPERATION_FAILED;
 285         }
 286
 287         ret = vc_mgr_client_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE);
 288         if (0 != ret) {
 289                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %d", ret);
 290                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 291                 vc_mgr_client_destroy();
 292                 return ret;
 293         }
 294
 295         ret = vc_mgr_ducking_create();
 296         if (VC_ERROR_NONE != ret) {
 297                 SLOG(LOG_INFO, TAG_VCM, "[INFO] Fail to ducking create : %d", ret);
 298         }
 299
 300         SLOG(LOG_ERROR, TAG_VCM, "[Success] pid(%d)", g_pid);
 301
 302         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Initialize DONE");
 303
 304         return VC_ERROR_NONE;
 305 }
 306
 307 static void __vc_mgr_internal_unprepare()
 308 {
 309         int ret = vc_mgr_tidl_request_finalize(g_pid);
 310         if (0 != ret) {
 311                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
 312         }
 313
 314         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
 315         return;
 316 }
 317
 318 int vc_mgr_deinitialize(void)
 319 {
 320         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Deinitialize");
 321
 322         int ret;
 323         ret = __check_mgr_feature_privilege();
 324         if (VC_ERROR_NONE != ret)
 325                 return ret;
 326
 327         if (false == vc_mgr_client_is_valid()) {
 328                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NOT initialized");
 329                 return VC_ERROR_INVALID_STATE;
 330         }
 331
 332         vc_state_e state;
 333         vc_mgr_client_get_client_state(&state);
 334
 335         /* check state */
 336         switch (state) {
 337         case VC_STATE_READY:
 338                 __vc_mgr_internal_unprepare();
 339                 /* no break. need to next step*/
 340         case VC_STATE_INITIALIZED:
 341                 if (NULL != g_send_hello_timer) {
 342                         SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
 343                         ecore_timer_del(g_send_hello_timer);
 344                         g_send_hello_timer = NULL;
 345                 }
 346                 if (g_request_init_timer) {
 347                         SLOG(LOG_DEBUG, TAG_VCM, "Connect idler is deleted");
 348                         ecore_timer_del(g_request_init_timer);
 349                         g_request_init_timer = NULL;
 350                 }
 351
 352                 vc_config_mgr_unset_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE);
 353                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 354
 355                 /* Free client resources */
 356                 vc_mgr_client_destroy();
 357                 g_pid = 0;
 358                 break;
 359         case VC_STATE_NONE:
 360                 break;
 361         }
 362
 363         SLOG(LOG_DEBUG, TAG_VCM, "Success: destroy");
 364
 365         int cnt = VC_COMMAND_TYPE_FOREGROUND;
 366         do {
 367                 ret = vc_cmd_parser_delete_file(getpid(), cnt);
 368                 if (0 != ret)
 369                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", cnt, ret);
 370         } while (VC_COMMAND_TYPE_EXCLUSIVE >= ++cnt);
 371
 372         ret = vc_db_finalize();
 373         if (0 != ret) {
 374                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to finalize DB, ret(%d)", ret);
 375         }
 376
 377         ret = vc_mgr_ducking_destroy();
 378         if (VC_ERROR_NONE != ret) {
 379                 SLOG(LOG_INFO, TAG_VCM, "[INFO] Fail to ducking destroy : %d", ret);
 380         }
 381
 382         if (0 != vc_mgr_tidl_close_connection()) {
 383                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection");
 384         }
 385
 386         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Deinitialize DONE");
 387
 388         return VC_ERROR_NONE;
 389 }
 390
 391 static void __notify_error(void *data)
 392 {
 393         vc_mgr_core_notify_error();
 394 }
 395
 396 static Eina_Bool __request_initialize(void *data)
 397 {
 398         /* request initialization */
 399         int ret = -1;
 400         int service_state = 0;
 401         int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
 402
 403
 404         /* check handle */
 405         if (true == vc_mgr_client_is_valid()) {
 406                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG]  is valid");
 407
 408                 /* Initialize DB */
 409                 ret = vc_db_initialize();
 410                 if (0 != ret) {
 411                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize DB : %d", ret);
 412                         return EINA_TRUE;
 413                 }
 414
 415                 vc_audio_streaming_mode_e streaming_mode;
 416                 vc_mgr_client_get_audio_streaming_mode(&streaming_mode);
 417
 418                 ret = vc_mgr_tidl_request_initialize(g_pid, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid);
 419
 420                 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 421                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
 422
 423                         vc_mgr_client_set_error(VC_ERROR_ENGINE_NOT_FOUND);
 424                         ecore_main_loop_thread_safe_call_async(__notify_error, NULL);
 425
 426                         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 427                         g_request_init_timer = NULL;
 428                         return EINA_FALSE;
 429
 430                 } else if (0 != ret) {
 431                         SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Fail to connection. Retry to connect : %s", __vc_mgr_get_error_code(ret));
 432                         ret = vc_db_finalize();
 433                         if (0 != ret) {
 434                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to finalize DB : %d", ret);
 435                         }
 436                         return EINA_TRUE;
 437                 } else {
 438                         /* Success to connect */
 439                 }
 440
 441                 /* Set service state */
 442                 vc_service_state_e previous_service_state;
 443                 vc_mgr_client_get_service_state(&previous_service_state);
 444                 vc_mgr_client_set_service_state((vc_service_state_e)service_state);
 445
 446                 vc_service_state_changed_cb service_changed_callback = NULL;
 447                 void* user_data = NULL;
 448                 vc_mgr_client_get_service_state_changed_cb(&service_changed_callback, &user_data);
 449
 450                 if (NULL != service_changed_callback) {
 451                         vc_mgr_client_use_callback();
 452                         service_changed_callback(previous_service_state, service_state, user_data);
 453                         vc_mgr_client_not_use_callback();
 454                         SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called");
 455                 } else {
 456                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
 457                 }
 458
 459                 /* Set foreground */
 460                 vc_mgr_client_set_foreground(foreground, true);
 461
 462                 SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Connected daemon");
 463
 464                 /* Set client state */
 465                 vc_mgr_client_set_client_state(VC_STATE_READY);
 466
 467                 vc_state_changed_cb changed_callback = NULL;
 468                 user_data = NULL;
 469                 vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data);
 470
 471                 vc_state_e current_state;
 472                 vc_state_e previous_state;
 473
 474                 vc_mgr_client_get_previous_state(&current_state, &previous_state);
 475
 476                 if (NULL != changed_callback) {
 477                         vc_mgr_client_use_callback();
 478                         changed_callback(previous_state, current_state, user_data);
 479                         vc_mgr_client_not_use_callback();
 480                         SLOG(LOG_INFO, TAG_VCM, "State changed callback is called");
 481                 } else {
 482                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
 483                 }
 484         } else {
 485                 SLOG(LOG_ERROR, TAG_VCM, "[Not ERROR]  is not valid. It is destroyed."); //LCOV_EXCL_LINE
 486                 g_request_init_timer = NULL;
 487                 return EINA_FALSE;
 488         }
 489
 490         SLOG(LOG_ERROR, TAG_VCM, "@@@");
 491
 492         g_request_init_timer = NULL;
 493         return EINA_FALSE;
 494 }
 495
 496
 497 static Eina_Bool __send_hello_message(void *data)
 498 {
 499         /* Send hello */
 500         if (0 != vc_mgr_tidl_request_hello()) {
 501                 if (g_tidl_send_hello_count == VCM_TIDL_RETRY_COUNT) {
 502                         g_tidl_send_hello_count = 0;
 503                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request hello !! send error to manager");
 504                         vc_mgr_core_send_error(VC_ERROR_TIMED_OUT, -1, "voice_framework.error.vcfw.connect_engine_fail");
 505                         g_send_hello_timer = NULL;
 506                         return EINA_FALSE;
 507                 } else {
 508                         g_tidl_send_hello_count++;
 509                         return EINA_TRUE;
 510                 }
 511         }
 512
 513         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
 514
 515         if (NULL == g_request_init_timer) {
 516                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new idler for preparation");
 517                 g_request_init_timer = ecore_timer_add(0.0, __request_initialize, NULL);
 518         } else {
 519                 SLOG(LOG_INFO, TAG_VCM, "[INFO] idler handle is already created");
 520         }
 521
 522         g_send_hello_timer = NULL;
 523         return EINA_FALSE;
 524 }
 525
 526 int vc_mgr_prepare(void)
 527 {
 528         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Prepare");
 529
 530         int ret;
 531         ret = __check_mgr_feature_privilege();
 532         if (VC_ERROR_NONE != ret)
 533                 return ret;
 534
 535         vc_state_e state;
 536         if (0 != vc_mgr_client_get_client_state(&state)) {
 537                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 538                 return VC_ERROR_INVALID_STATE;
 539         }
 540
 541         /* check state */
 542         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 543
 544         if (NULL == g_send_hello_timer) {
 545                 g_tidl_send_hello_count = 0;
 546                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new timer for preparation");
 547                 ecore_thread_main_loop_begin();
 548                 g_send_hello_timer = ecore_timer_add(0.1, __send_hello_message, NULL);
 549                 ecore_thread_main_loop_end();
 550         } else {
 551                 SLOG(LOG_INFO, TAG_VCM, "[INFO] timer handle is already created");
 552         }
 553
 554         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Calling Prepare DONE");
 555
 556         return VC_ERROR_NONE;
 557 }
 558
 559 int vc_mgr_unprepare(void)
 560 {
 561         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unprepare");
 562
 563         int ret;
 564         ret = __check_mgr_feature_privilege();
 565         if (VC_ERROR_NONE != ret)
 566                 return ret;
 567
 568         vc_state_e state;
 569         if (0 != vc_mgr_client_get_client_state(&state)) {
 570                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 571                 return VC_ERROR_INVALID_STATE;
 572         }
 573
 574         /* check state */
 575         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 576
 577         __vc_mgr_internal_unprepare();
 578
 579         vc_mgr_client_set_client_state(VC_STATE_INITIALIZED);
 580         ecore_timer_add(0, __vc_mgr_notify_state_changed, NULL);
 581
 582         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Unprepare DONE");
 583
 584         return VC_ERROR_NONE;
 585 }
 586
 587 int vc_mgr_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 588 {
 589         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Foreach Supported Language");
 590
 591         int ret;
 592         ret = __check_mgr_feature_privilege();
 593         if (VC_ERROR_NONE != ret)
 594                 return ret;
 595
 596         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 597
 598         vc_state_e state;
 599         if (0 != vc_mgr_client_get_client_state(&state)) {
 600                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 601                 return VC_ERROR_INVALID_STATE;
 602         }
 603
 604         ret = vc_config_mgr_get_language_list(callback, user_data);
 605         if (0 != ret) {
 606                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 607                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get languages : %s", __vc_mgr_get_error_code(ret));
 608         }
 609
 610         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Foreach Supported Language DONE");
 611
 612         return VC_ERROR_NONE;
 613 }
 614
 615 int vc_mgr_get_current_language(char** language)
 616 {
 617         int ret;
 618         ret = __check_mgr_feature_privilege();
 619         if (VC_ERROR_NONE != ret)
 620                 return ret;
 621
 622         RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 623
 624         vc_state_e state;
 625         if (0 != vc_mgr_client_get_client_state(&state)) {
 626                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 627                 return VC_ERROR_INVALID_STATE;
 628         }
 629
 630         ret = vc_config_mgr_get_default_language(language);
 631         if (0 != ret) {
 632                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 633                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get current languages : %s", __vc_mgr_get_error_code(ret));
 634         } else {
 635                 SLOG(LOG_ERROR, TAG_VCM, "[Get current language] language : %s", *language);
 636         }
 637
 638         return ret;
 639 }
 640
 641 int vc_mgr_get_state(vc_state_e* state)
 642 {
 643         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get State");
 644
 645         int ret;
 646         ret = __check_mgr_feature_privilege();
 647         if (VC_ERROR_NONE != ret)
 648                 return ret;
 649
 650         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 651
 652         vc_state_e temp;
 653         if (0 != vc_mgr_client_get_client_state(&temp)) {
 654                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 655                 return VC_ERROR_INVALID_STATE;
 656         }
 657
 658         *state = temp;
 659
 660         switch (*state) {
 661         case VC_STATE_NONE:             SLOG(LOG_INFO, TAG_VCM, "Current state is 'None'");             break;
 662         case VC_STATE_INITIALIZED:      SLOG(LOG_INFO, TAG_VCM, "Current state is 'Created'");          break;
 663         case VC_STATE_READY:            SLOG(LOG_INFO, TAG_VCM, "Current state is 'Ready'");            break;
 664         default:                        SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
 665         }
 666
 667         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get State DONE");
 668
 669         return VC_ERROR_NONE;
 670 }
 671
 672 int vc_mgr_get_service_state(vc_service_state_e* state)
 673 {
 674         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get Service State");
 675
 676         int ret;
 677         ret = __check_mgr_feature_privilege();
 678         if (VC_ERROR_NONE != ret)
 679                 return ret;
 680
 681         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 682
 683         vc_state_e client_state;
 684         if (0 != vc_mgr_client_get_client_state(&client_state)) {
 685                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 686                 return VC_ERROR_INVALID_STATE;
 687         }
 688
 689         /* check state */
 690         RETVM_IF(client_state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Current state is not 'READY'");
 691
 692         /* get service state */
 693         vc_service_state_e service_state;
 694         if (0 != vc_mgr_client_get_service_state(&service_state)) {
 695                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state");
 696                 return VC_ERROR_OPERATION_FAILED;
 697         }
 698
 699         *state = service_state;
 700
 701         switch (*state) {
 702         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'");            break;
 703         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'");           break;
 704         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'");       break;
 705         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Processing'");      break;
 706         default:                                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
 707         }
 708
 709         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get Service State DONE");
 710
 711         return VC_ERROR_NONE;
 712 }
 713
 714 int vc_mgr_set_demandable_client_rule(const char* rule)
 715 {
 716         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s)", rule);
 717
 718         int ret;
 719         ret = __check_mgr_feature_privilege();
 720         if (VC_ERROR_NONE != ret)
 721                 return ret;
 722
 723         RETVM_IF(NULL == rule, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 724
 725         vc_state_e state;
 726         if (0 != vc_mgr_client_get_client_state(&state)) {
 727                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 728                 return VC_ERROR_INVALID_STATE;
 729         }
 730
 731         /* check state */
 732         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 733
 734         ret = vc_mgr_core_set_demandable_client_rule(rule);
 735
 736         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s) DONE", rule);
 737
 738         return ret;
 739 }
 740
 741 int vc_mgr_unset_demandable_client_rule(void)
 742 {
 743         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Unset Demandable client");
 744
 745         int ret;
 746         ret = __check_mgr_feature_privilege();
 747         if (VC_ERROR_NONE != ret)
 748                 return ret;
 749
 750         vc_state_e state;
 751         if (0 != vc_mgr_client_get_client_state(&state)) {
 752                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 753                 return VC_ERROR_INVALID_STATE;
 754         }
 755
 756         /* check state */
 757         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 758
 759         vc_info_parser_set_demandable_client(NULL);
 760
 761         ret = vc_mgr_tidl_request_demandable_client(g_pid);
 762         if (0 != ret) {
 763                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset client rule to daemon : %s", __vc_mgr_get_error_code(ret));
 764         }
 765
 766         // TODO: check return value correct or not
 767         return VC_ERROR_NONE;
 768 }
 769
 770 int vc_mgr_is_command_format_supported(int format, bool* support)
 771 {
 772         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Is command type supported");
 773
 774         int ret;
 775         ret = __check_mgr_feature_privilege();
 776         if (VC_ERROR_NONE != ret)
 777                 return ret;
 778
 779         RETVM_IF(NULL == support, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 780
 781         vc_state_e state;
 782         if (0 != vc_mgr_client_get_client_state(&state)) {
 783                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 784                 return VC_ERROR_INVALID_STATE;
 785         }
 786
 787         /* check support */
 788         bool non_fixed_support = false;
 789         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 790                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get nonfixed support info");
 791         }
 792
 793         switch (format) {
 794         case VC_CMD_FORMAT_FIXED:               *support = true;                break;
 795         case VC_CMD_FORMAT_FIXED_AND_VFIXED:    *support = true;                break;
 796         case VC_CMD_FORMAT_VFIXED_AND_FIXED:    *support = true;                break;
 797         case VC_CMD_FORMAT_FIXED_AND_NONFIXED:  *support = non_fixed_support;   break;
 798         case VC_CMD_FORMAT_NONFIXED_AND_FIXED:  *support = non_fixed_support;   break;
 799         default:                                *support = false;               break;
 800         }
 801
 802         SLOG(LOG_ERROR, TAG_VCM, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 803
 804         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Is command type supported DONE");
 805
 806         return VC_ERROR_NONE;
 807 }
 808
 809 int vc_mgr_enable_command_type(int cmd_type)
 810 {
 811         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Enable Command Type, cmd_type(%d)", cmd_type);
 812
 813         int ret;
 814         ret = __check_mgr_feature_privilege();
 815         if (VC_ERROR_NONE != ret)
 816                 return ret;
 817
 818         if (VC_COMMAND_TYPE_FOREGROUND > cmd_type || VC_COMMAND_TYPE_EXCLUSIVE < cmd_type) {
 819                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cmd_type is not valid. (%d)", cmd_type);
 820                 return VC_ERROR_INVALID_PARAMETER;
 821         }
 822
 823         vc_state_e state;
 824         if (0 != vc_mgr_client_get_client_state(&state)) {
 825                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 826                 return VC_ERROR_INVALID_STATE;
 827         }
 828
 829         /* check state */
 830         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 831
 832         /* Check service state */
 833         vc_service_state_e service_state = -1;
 834         vc_mgr_client_get_service_state(&service_state);
 835         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
 836
 837         ret = vc_mgr_client_enable_command_type((vc_cmd_type_e)cmd_type);               // enable the cmd type
 838         if (0 != ret) {
 839                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to enable the command type(%d). ret(%d)", cmd_type, ret);
 840         } else {
 841                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to enable the command type(%d)", cmd_type);
 842         }
 843
 844         SLOG(LOG_ERROR, TAG_VCM, "@@@  [Manager] Enable Command Type DONE, ret(%d)", ret);
 845
 846         return ret;
 847 }
 848
 849 int vc_mgr_disable_command_type(int cmd_type)
 850 {
 851         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Disable Command Type, cmd_type(%d)", cmd_type);
 852
 853         int ret;
 854         ret = __check_mgr_feature_privilege();
 855         if (VC_ERROR_NONE != ret)
 856                 return ret;
 857
 858         if (VC_COMMAND_TYPE_FOREGROUND > cmd_type || VC_COMMAND_TYPE_EXCLUSIVE < cmd_type) {
 859                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cmd type is not valid, (%d)", cmd_type);
 860                 return VC_ERROR_INVALID_PARAMETER;
 861         }
 862
 863         vc_state_e state;
 864         if (0 != vc_mgr_client_get_client_state(&state)) {
 865                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 866                 return VC_ERROR_INVALID_STATE;
 867         }
 868
 869         /* check state */
 870         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 871
 872         /* Check service state */
 873         vc_service_state_e service_state = -1;
 874         vc_mgr_client_get_service_state(&service_state);
 875         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
 876
 877         ret = vc_mgr_client_disable_command_type((vc_cmd_type_e)cmd_type);              // enable the cmd type
 878         if (0 != ret) {
 879                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to disable the command type(%d). ret(%d)", cmd_type, ret);
 880         } else {
 881                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to disable the command type(%d)", cmd_type);
 882         }
 883
 884         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Disable Command Type DONE, ret(%d)", ret);
 885
 886         return ret;
 887 }
 888
 889 int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
 890 {
 891         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list");
 892
 893         int ret;
 894         ret = __check_mgr_feature_privilege();
 895         if (VC_ERROR_NONE != ret)
 896                 return ret;
 897
 898         vc_state_e state;
 899         if (0 != vc_mgr_client_get_client_state(&state)) {
 900                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 901                 return VC_ERROR_INVALID_STATE;
 902         }
 903
 904         /* check state */
 905         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 906
 907         /* Check service state */
 908         vc_service_state_e service_state = -1;
 909         vc_mgr_client_get_service_state(&service_state);
 910         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
 911
 912         RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 913
 914         vc_cmd_list_s* list = NULL;
 915         list = (vc_cmd_list_s*)vc_cmd_list;
 916         SLOG(LOG_INFO, TAG_VCM, "[List] (%p) (%p)", list, list->list);
 917
 918         RETVM_IF(NULL == list->list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input command list");
 919
 920         int i;
 921         bool success_save = false;
 922         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
 923                 ret = vc_cmd_parser_delete_file(getpid(), i);
 924                 if (0 != ret)
 925                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
 926
 927                 ret = vc_cmd_parser_save_file(getpid(), i, list->list, NULL);
 928                 if (0 != ret) {
 929                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save file, type(%d), ret(%d)", i, ret);
 930                 } else {
 931                         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Save file, type(%d)", i);
 932                         success_save = true;
 933                 }
 934         }
 935
 936         if (true != success_save) {
 937                 ret = VC_ERROR_INVALID_PARAMETER;
 938                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret));
 939         } else {
 940                 ret = vc_mgr_tidl_request_set_command(g_pid);
 941                 if (0 != ret) {
 942                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
 943                 }
 944         }
 945
 946         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list DONE, ret(%d)", ret);
 947
 948         return ret;
 949 }
 950
 951 int vc_mgr_unset_command_list(void)
 952 {
 953         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unset Command list");
 954
 955         int ret;
 956         ret = __check_mgr_feature_privilege();
 957         if (VC_ERROR_NONE != ret)
 958                 return ret;
 959
 960         vc_state_e state;
 961         if (0 != vc_mgr_client_get_client_state(&state)) {
 962                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 963                 return VC_ERROR_INVALID_STATE;
 964         }
 965
 966         /* check state */
 967         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 968
 969         ret = vc_mgr_tidl_request_unset_command(g_pid);
 970         if (0 != ret) {
 971                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret));
 972         }
 973
 974         int i;
 975         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
 976                 ret = vc_cmd_parser_delete_file(getpid(), i);
 977                 if (0 != ret)
 978                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
 979         }
 980
 981         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unset Command list DONE");
 982
 983         // TODO: check return value correct or not
 984         return VC_ERROR_NONE;
 985 }
 986
 987 int vc_mgr_set_command_list_from_file(const char* file_path, int type)
 988 {
 989         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list from file, type(%d)", type);
 990
 991         int ret;
 992         ret = __check_mgr_feature_privilege();
 993         if (VC_ERROR_NONE != ret)
 994                 return ret;
 995
 996         RETVM_IF(NULL == file_path, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
 997         SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
 998
 999         /* check type */
1000         if (VC_COMMAND_TYPE_FOREGROUND > type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
1001                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid command type: input type is %d", type);
1002                 return VC_ERROR_INVALID_PARAMETER;
1003         }
1004
1005         vc_state_e state;
1006         if (0 != vc_mgr_client_get_client_state(&state)) {
1007                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1008                 return VC_ERROR_INVALID_STATE;
1009         }
1010
1011         /* check state */
1012         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1013
1014         /* Check service state */
1015         vc_service_state_e service_state = -1;
1016         vc_mgr_client_get_service_state(&service_state);
1017         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1018
1019         ret = vc_cmd_parser_delete_file(getpid(), type);
1020         if (0 != ret)
1021                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(4), ret(%d)", ret);
1022
1023         if (0 != vc_json_set_commands_from_file(file_path, type, NULL)) {
1024                 ret = VC_ERROR_INVALID_PARAMETER;
1025                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command list (%d)", ret);
1026         } else {
1027                 ret = vc_mgr_tidl_request_set_command(g_pid);
1028                 if (0 != ret) {
1029                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
1030                 }
1031         }
1032
1033         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list from file DONE, ret(%d)", ret);
1034
1035         return ret;
1036 }
1037
1038 int vc_mgr_set_preloaded_commands_from_file(const char* file_path)
1039 {
1040         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set preloaded command list");
1041
1042         int ret;
1043         ret = __check_mgr_feature_privilege();
1044         if (VC_ERROR_NONE != ret)
1045                 return ret;
1046
1047         RETVM_IF(NULL == file_path, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1048         SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
1049
1050         vc_state_e state;
1051         if (0 != vc_mgr_client_get_client_state(&state)) {
1052                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1053                 return VC_ERROR_INVALID_STATE;
1054         }
1055
1056         /* check state */
1057         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1058
1059         /* Check service state */
1060         vc_service_state_e service_state = -1;
1061         vc_mgr_client_get_service_state(&service_state);
1062         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1063
1064         /* Only support to set background commands for preloaded application */
1065         ret = vc_json_set_commands_from_file(file_path, VC_COMMAND_TYPE_BACKGROUND, NULL);
1066         if (0 != ret)
1067                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to insert preloaded commands into db");
1068
1069         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set preloaded command list DONE, ret(%d)", ret);
1070         return ret;
1071 }
1072
1073 int vc_mgr_set_audio_type(const char* audio_id)
1074 {
1075         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set audio type, audio_id(%s)", audio_id);
1076
1077         int ret;
1078         ret = __check_mgr_feature_privilege();
1079         if (VC_ERROR_NONE != ret)
1080                 return ret;
1081
1082         if (NULL == audio_id || !strncmp(audio_id, "", strlen(audio_id))) {
1083                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1084                 return VC_ERROR_INVALID_PARAMETER;
1085         }
1086
1087         vc_state_e state;
1088         if (0 != vc_mgr_client_get_client_state(&state)) {
1089                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1090                 return VC_ERROR_INVALID_STATE;
1091         }
1092
1093         /* check state */
1094         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1095
1096         /* Check service state */
1097         vc_service_state_e service_state = -1;
1098         vc_mgr_client_get_service_state(&service_state);
1099         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1100
1101         /* Request */
1102         ret = vc_mgr_tidl_request_set_audio_type(g_pid, audio_id);
1103         if (0 != ret) {
1104                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret));
1105         } else {
1106                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set audio type");
1107                 /* Save */
1108                 vc_mgr_client_set_audio_type(audio_id);
1109         }
1110
1111         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set audio type DONE, ret(%d)", ret);
1112
1113         return ret;
1114 }
1115
1116 int vc_mgr_get_audio_type(char** audio_id)
1117 {
1118         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Get audio type");
1119
1120         int ret;
1121         ret = __check_mgr_feature_privilege();
1122         if (VC_ERROR_NONE != ret)
1123                 return ret;
1124
1125         RETVM_IF(NULL == audio_id, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1126
1127         vc_state_e state;
1128         if (0 != vc_mgr_client_get_client_state(&state)) {
1129                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1130                 return VC_ERROR_INVALID_STATE;
1131         }
1132
1133         /* check state */
1134         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1135
1136         /* Check service state */
1137         vc_service_state_e service_state = -1;
1138         vc_mgr_client_get_service_state(&service_state);
1139         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1140
1141         char* temp = NULL;
1142
1143         vc_mgr_client_get_audio_type(&temp);
1144
1145         if (NULL == temp) {
1146                 /* Not initiallized */
1147                 ret = -1;
1148                 while (0 != ret) {
1149                         ret = vc_mgr_tidl_request_get_audio_type(g_pid, &temp);
1150                         if (0 != ret) {
1151                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret));
1152                         } else {
1153                                 SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
1154                                 /* Save */
1155                                 vc_mgr_client_set_audio_type(temp);
1156                         }
1157                 }
1158         }
1159
1160         if (NULL != temp) {
1161                 *audio_id = strdup(temp);
1162                 free(temp);
1163                 temp = NULL;
1164         }
1165
1166         // TODO: check return value correct or not
1167         return VC_ERROR_NONE;
1168 }
1169
1170 int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
1171 {
1172         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Foreach current commands");
1173
1174         int ret;
1175         ret = __check_mgr_feature_privilege();
1176         if (VC_ERROR_NONE != ret)
1177                 return ret;
1178
1179         vc_state_e state;
1180         if (0 != vc_mgr_client_get_client_state(&state)) {
1181                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1182                 return VC_ERROR_INVALID_STATE;
1183         }
1184
1185         /* check state */
1186         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1187
1188         /* Check service state */
1189         vc_service_state_e service_state = -1;
1190         vc_mgr_client_get_service_state(&service_state);
1191         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: service state(%d) is not 'READY'", service_state);
1192
1193         RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid Parameter");
1194
1195         vc_cmd_list_h temp_list = NULL;
1196         if (0 != vc_cmd_list_create(&temp_list)) {
1197                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
1198                 return VC_ERROR_INVALID_PARAMETER;
1199         }
1200
1201         *vc_cmd_list = temp_list;
1202
1203         int fg_pid = 0;
1204         int mgr_pid = 0;
1205
1206         /* Get foreground pid */
1207         if (0 != vc_mgr_client_get_foreground(&fg_pid)) {
1208                 /* There is no foreground app for voice control */
1209                 SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
1210         } else {
1211                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
1212         }
1213
1214         if (0 != vc_mgr_client_get_pid(&mgr_pid)) {
1215                 SLOG(LOG_ERROR, TAG_VCM, "[Manager] Fail to get manager pid");
1216                 return VC_ERROR_OPERATION_FAILED;
1217         } else {
1218                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
1219         }
1220
1221         /* Get system command */
1222         ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
1223         if (0 != ret) {
1224                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No system commands");
1225         }
1226
1227         /* Request */
1228         ret = vc_mgr_tidl_request_set_client_info(g_pid);
1229         if (0 != ret) {
1230                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret));
1231         } else {
1232                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set client info");
1233         }
1234
1235         GSList *iter = NULL;
1236         GSList* client_info_list = NULL;
1237         vc_client_info_s *client_info = NULL;
1238         bool is_fgpid = false;
1239
1240         if (0 != vc_info_parser_get_client_info(&client_info_list)) {
1241                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No client");
1242                 return VC_ERROR_NONE;
1243         }
1244
1245         if (VC_NO_FOREGROUND_PID != fg_pid) {
1246                 iter = g_slist_nth(client_info_list, 0);
1247                 while (NULL != iter) {
1248                         client_info = iter->data;
1249                         if (NULL != client_info) {
1250                                 if (fg_pid == client_info->pid) {
1251                                         is_fgpid = true;
1252                                         break;
1253                                 }
1254                         }
1255                         iter = g_slist_next(iter);
1256                 }
1257         }
1258
1259         /* Get foreground commands and widget */
1260         if (true == is_fgpid) {
1261                 /* Get handle */
1262                 SLOG(LOG_INFO, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
1263
1264                 /* Get foreground command */
1265                 if (true == client_info->fg_cmd) {
1266                         ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
1267                         if (0 != ret) {
1268                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
1269                         }
1270                 } else {
1271                         SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground commands");
1272                 }
1273
1274                 /* Check exclusive option */
1275                 if (true == client_info->exclusive_cmd) {
1276                         SLOG(LOG_INFO, TAG_VCM, "[Manager] Exclusive command is ON");
1277
1278                         /* Set background command for exclusive option */
1279                         if (true == client_info->bg_cmd) {
1280                                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Set background command");
1281                                 ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1282                                 if (0 != ret) {
1283                                         SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1284                                 }
1285                         }
1286
1287                         /* need to release client info */
1288                         iter = g_slist_nth(client_info_list, 0);
1289
1290                         while (NULL != iter) {
1291                                 client_info = iter->data;
1292                                 if (NULL != client_info) {
1293                                         free(client_info);
1294                                 }
1295                                 client_info_list = g_slist_remove_link(client_info_list, iter);
1296                                 iter = g_slist_nth(client_info_list, 0);
1297                         }
1298
1299                         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Foreach current commands DONE");
1300
1301                         return VC_ERROR_NONE;
1302                 }
1303         } else {
1304                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground app");
1305         }
1306
1307         /* Get background commands */
1308         if (0 < g_slist_length(client_info_list)) {
1309                 iter = g_slist_nth(client_info_list, 0);
1310
1311                 while (NULL != iter) {
1312                         client_info = iter->data;
1313
1314                         if (NULL != client_info) {
1315                                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
1316                                 if (true == client_info->bg_cmd) {
1317                                         ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1318                                         if (0 != ret) {
1319                                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1320                                         }
1321                                 }
1322                                 free(client_info);
1323                         }
1324                         client_info_list = g_slist_remove_link(client_info_list, iter);
1325
1326                         iter = g_slist_nth(client_info_list, 0);
1327                 }
1328         } else {
1329                 /* NO client */
1330                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No background commands");
1331         }
1332
1333         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Foreach current commands DONE");
1334
1335         // TODO: check return value correct or not
1336         return VC_ERROR_NONE;
1337 }
1338
1339 int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
1340 {
1341         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set recognition mode = %d", mode);
1342
1343         int ret;
1344         ret = __check_mgr_feature_privilege();
1345         if (VC_ERROR_NONE != ret)
1346                 return ret;
1347
1348         /* check vc recognition mode */
1349         if (mode < VC_RECOGNITION_MODE_STOP_BY_SILENCE || mode > VC_RECOGNITION_MODE_MANUAL) {
1350                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] invalid parameter: 'mode' is not supported mode (%d)", mode);
1351                 return VC_ERROR_INVALID_PARAMETER;
1352         }
1353
1354         vc_state_e state;
1355         if (0 != vc_mgr_client_get_client_state(&state)) {
1356                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1357                 return VC_ERROR_INVALID_STATE;
1358         }
1359
1360         /* check state */
1361         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1362
1363         /* Check service state */
1364         vc_service_state_e service_state = -1;
1365         vc_mgr_client_get_service_state(&service_state);
1366         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1367
1368         vc_mgr_client_set_recognition_mode(mode);
1369         return VC_ERROR_NONE;
1370 }
1371
1372 int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
1373 {
1374         int ret;
1375         ret = __check_mgr_feature_privilege();
1376         if (VC_ERROR_NONE != ret)
1377                 return ret;
1378
1379         RETVM_IF(NULL == mode, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter, mode is NULL ptr");
1380
1381         vc_state_e state;
1382         if (0 != vc_mgr_client_get_client_state(&state)) {
1383                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1384                 return VC_ERROR_INVALID_STATE;
1385         }
1386
1387         ret = vc_mgr_client_get_recognition_mode(mode);
1388         if (0 != ret) {
1389                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1390                 return ret;
1391         }
1392
1393         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Get recognition mode = %d", *mode);
1394         return VC_ERROR_NONE;
1395 }
1396
1397 int vc_mgr_set_private_data(const char* key, const char* data)
1398 {
1399         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set private data");
1400
1401         int ret;
1402         ret = __check_mgr_feature_privilege();
1403         if (VC_ERROR_NONE != ret)
1404                 return ret;
1405
1406         RETVM_IF(NULL == key, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1407
1408         vc_state_e state;
1409         if (0 != vc_mgr_client_get_client_state(&state)) {
1410                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1411                 return VC_ERROR_INVALID_STATE;
1412         }
1413
1414         /* check state */
1415         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1416
1417         /* Check service state */
1418         vc_service_state_e service_state = -1;
1419         vc_mgr_client_get_service_state(&service_state);
1420         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1421
1422         ret = vc_mgr_tidl_request_set_private_data(g_pid, key, data);
1423         if (0 != ret) {
1424                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret));
1425                 return ret;
1426         } else {
1427                 SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set private data");
1428         }
1429
1430         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set private data DONE");
1431
1432         return VC_ERROR_NONE;
1433 }
1434
1435 int vc_mgr_get_private_data(const char* key, char** data)
1436 {
1437         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get private data");
1438
1439         int ret;
1440         ret = __check_mgr_feature_privilege();
1441         if (VC_ERROR_NONE != ret)
1442                 return ret;
1443
1444         if (NULL == key || NULL == data) {
1445                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1446                 return VC_ERROR_INVALID_PARAMETER;
1447         }
1448
1449         vc_state_e state;
1450         if (0 != vc_mgr_client_get_client_state(&state)) {
1451                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1452                 return VC_ERROR_INVALID_STATE;
1453         }
1454
1455         /* check state */
1456         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1457
1458         /* Check service state */
1459         vc_service_state_e service_state = -1;
1460         vc_mgr_client_get_service_state(&service_state);
1461         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1462
1463         char* temp = NULL;
1464         ret = vc_mgr_tidl_request_get_private_data(g_pid, key, &temp);
1465         if (0 != ret) {
1466                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret));
1467         } else {
1468                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
1469         }
1470
1471         if (NULL != temp) {
1472                 *data = strdup(temp);
1473                 free(temp);
1474                 temp = NULL;
1475         }
1476
1477         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get private data DONE");
1478
1479         // TODO: check return value correct or not
1480         return VC_ERROR_NONE;
1481 }
1482
1483 int vc_mgr_set_domain(const char* domain)
1484 {
1485         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set domain");
1486
1487         int ret;
1488         ret = __check_mgr_feature_privilege();
1489         if (VC_ERROR_NONE != ret)
1490                 return ret;
1491
1492         RETVM_IF(NULL == domain, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1493
1494         vc_state_e state;
1495         if (0 != vc_mgr_client_get_client_state(&state)) {
1496                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1497                 return VC_ERROR_INVALID_STATE;
1498         }
1499
1500         /* check state */
1501         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1502
1503         /* Check service state */
1504         vc_service_state_e service_state = -1;
1505         vc_mgr_client_get_service_state(&service_state);
1506         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1507
1508         ret = vc_mgr_tidl_request_set_domain(g_pid, domain);
1509         if (0 != ret) {
1510                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret));
1511         } else {
1512                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set domain");
1513         }
1514
1515         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set domain DONE");
1516
1517         return VC_ERROR_NONE;
1518 }
1519
1520 int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
1521 {
1522         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] do action");
1523
1524         int ret;
1525         ret = __check_mgr_feature_privilege();
1526         if (VC_ERROR_NONE != ret)
1527                 return ret;
1528
1529         if (type < VC_SEND_EVENT_TYPE_TEXT || VC_SEND_EVENT_TYPE_HAPTIC_EVENT < type) {
1530                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] send event type is not valid, (%d)", type);
1531                 return VC_ERROR_INVALID_PARAMETER;
1532         }
1533
1534         RETVM_IF(NULL == send_event, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1535
1536         vc_state_e state;
1537         if (0 != vc_mgr_client_get_client_state(&state)) {
1538                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1539                 return VC_ERROR_INVALID_STATE;
1540         }
1541
1542         /* check state */
1543         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1544
1545         /* Check service state */
1546         vc_service_state_e service_state = -1;
1547         vc_mgr_client_get_service_state(&service_state);
1548         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1549
1550         ret = vc_mgr_tidl_request_do_action(g_pid, type, send_event);
1551         if (0 != ret) {
1552                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
1553                 return ret;
1554         } else {
1555                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] do action");
1556         }
1557         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] do action DONE");
1558
1559         return VC_ERROR_NONE;
1560 }
1561
1562 int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* event, const char* request)
1563 {
1564         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send specific engine request");
1565
1566         int ret;
1567         ret = __check_mgr_feature_privilege();
1568         if (VC_ERROR_NONE != ret)
1569                 return ret;
1570
1571         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] specific engine request. engine app id(%s), event(%s), request(%s)", engine_app_id, event, request);
1572
1573         if (NULL == engine_app_id || NULL == event) {
1574                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1575                 return VC_ERROR_INVALID_PARAMETER;
1576         }
1577
1578         if (NULL == request) {
1579                 SLOG(LOG_ERROR, TAG_VCM, "[INFO] Input parameter is NULL. (no request)");
1580         }
1581
1582         vc_state_e state;
1583         if (0 != vc_mgr_client_get_client_state(&state)) {
1584                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1585                 return VC_ERROR_INVALID_STATE;
1586         }
1587
1588         /* check state */
1589         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1590
1591         /* Check service state */
1592         vc_service_state_e service_state = -1;
1593         vc_mgr_client_get_service_state(&service_state);
1594         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1595
1596         ret = vc_mgr_tidl_send_specific_engine_request(g_pid, engine_app_id, event, request);
1597         if (0 != ret) {
1598                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret));
1599                 return ret;
1600         } else {
1601                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] specific engine request");
1602         }
1603         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send specific engine request DONE");
1604
1605         return VC_ERROR_NONE;
1606 }
1607
1608 int vc_mgr_start(bool exclusive_command_option)
1609 {
1610         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request start");
1611
1612         int ret;
1613         ret = __check_mgr_feature_privilege();
1614         if (VC_ERROR_NONE != ret)
1615                 return ret;
1616
1617         vc_state_e state;
1618         if (0 != vc_mgr_client_get_client_state(&state)) {
1619                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1620                 return VC_ERROR_INVALID_STATE;
1621         }
1622
1623         /* check state */
1624         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1625
1626         /* Check service state */
1627         vc_service_state_e service_state = -1;
1628         vc_mgr_client_get_service_state(&service_state);
1629         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
1630
1631         /* Check internal state for async */
1632         vc_internal_state_e internal_state = -1;
1633         vc_mgr_client_get_internal_state(&internal_state);
1634         if (internal_state != VC_INTERNAL_STATE_NONE) {
1635                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is NOT none : %d", internal_state);
1636                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1637         }
1638
1639         vc_mgr_client_set_exclusive_command(exclusive_command_option);
1640
1641         bool start_by_client = false;
1642         if (0 != vc_mgr_client_get_start_by_client(&start_by_client)) {
1643                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
1644         }
1645
1646         int disabled_cmd_type = 0;
1647         if (0 != vc_mgr_client_get_disabled_command_type(&disabled_cmd_type)) {
1648                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get disabled command type");
1649         }
1650
1651         vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
1652         if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
1653                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1654         }
1655
1656         /* Request */
1657         ret = -1;
1658         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STARTING);
1659         ret = vc_mgr_tidl_request_start(g_pid, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type);
1660         if (0 != ret) {
1661                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
1662                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1663         } else {
1664                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] start recognition");
1665         }
1666
1667         vc_mgr_core_initialize_volume_variable();
1668
1669         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request start DONE, ret(%d)", ret);
1670
1671         return ret;
1672 }
1673
1674 int vc_mgr_stop(void)
1675 {
1676         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request stop");
1677
1678         int ret;
1679         ret = __check_mgr_feature_privilege();
1680         if (VC_ERROR_NONE != ret)
1681                 return ret;
1682
1683         vc_state_e state;
1684         if (0 != vc_mgr_client_get_client_state(&state)) {
1685                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1686                 return VC_ERROR_INVALID_STATE;
1687         }
1688
1689         /* check state */
1690         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1691
1692         /* Check service state */
1693         vc_service_state_e service_state = -1;
1694         vc_mgr_client_get_service_state(&service_state);
1695         RETVM_IF(service_state != VC_SERVICE_STATE_RECORDING, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'RECORDING'", service_state);
1696
1697         /* Check internal state for async */
1698         vc_internal_state_e internal_state = -1;
1699         vc_mgr_client_get_internal_state(&internal_state);
1700         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1701                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1702                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1703         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1704                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1705                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1706         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1707                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1708                 return VC_ERROR_IN_PROGRESS_TO_READY;
1709         }
1710
1711         ret = -1;
1712         /* do request */
1713         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STOPPING);
1714         ret = vc_mgr_tidl_request_stop(g_pid);
1715         if (0 != ret) {
1716                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
1717                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1718         } else {
1719                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Stop recognition");
1720         }
1721
1722         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request stop DONE");
1723
1724         return ret;
1725 }
1726
1727 int vc_mgr_cancel(void)
1728 {
1729         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request cancel");
1730
1731         int ret;
1732         ret = __check_mgr_feature_privilege();
1733         if (VC_ERROR_NONE != ret)
1734                 return ret;
1735
1736         vc_state_e state;
1737         if (0 != vc_mgr_client_get_client_state(&state)) {
1738                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1739                 return VC_ERROR_INVALID_STATE;
1740         }
1741
1742         /* check state */
1743         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1744
1745         /* Check service state */
1746         vc_service_state_e service_state = -1;
1747         vc_mgr_client_get_service_state(&service_state);
1748         RETVM_IF(service_state == VC_SERVICE_STATE_NONE, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state is NONE");
1749
1750         vc_internal_state_e internal_state = -1;
1751         vc_mgr_client_get_internal_state(&internal_state);
1752         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1753                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1754                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1755         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1756                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1757                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1758         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1759                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1760                 return VC_ERROR_IN_PROGRESS_TO_READY;
1761         }
1762
1763         ret = -1;
1764         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_CANCELING);
1765         ret = vc_mgr_tidl_request_cancel(g_pid);
1766         if (0 != ret) {
1767                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret));
1768                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1769         } else {
1770                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel recognition");
1771         }
1772
1773         vc_mgr_client_set_exclusive_command(false);
1774
1775         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request cancel DONE");
1776
1777         return ret;
1778 }
1779
1780 // TODO: check called by app direactly meaning
1781 int __vc_mgr_set_volume(float volume)
1782 {
1783         // called by app directly
1784         vc_mgr_core_set_volume(volume);
1785
1786         return VC_ERROR_NONE;
1787 }
1788
1789 int vc_mgr_get_recording_volume(float* volume)
1790 {
1791         int ret;
1792         ret = __check_mgr_feature_privilege();
1793         if (VC_ERROR_NONE != ret)
1794                 return ret;
1795
1796         RETVM_IF(NULL == volume, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1797
1798         vc_service_state_e service_state = -1;
1799         if (0 != vc_mgr_client_get_service_state(&service_state)) {
1800                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1801                 return VC_ERROR_INVALID_STATE;
1802         }
1803
1804         /* check state */
1805         RETVM_IF(VC_SERVICE_STATE_RECORDING != service_state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Service state is not 'RECORDING'");
1806
1807         *volume = vc_mgr_core_get_volume();
1808
1809         return VC_ERROR_NONE;
1810 }
1811
1812 int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
1813 {
1814         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Select result");
1815
1816         int ret;
1817         ret = __check_mgr_feature_privilege();
1818         if (VC_ERROR_NONE != ret)
1819                 return ret;
1820
1821         /* Do not check state for 'restart continuously' mode */
1822
1823         vc_service_state_e service_state = -1;
1824         vc_mgr_client_get_service_state(&service_state);
1825         if (service_state != VC_SERVICE_STATE_PROCESSING) {
1826                 vc_recognition_mode_e recognition_mode;
1827                 vc_mgr_get_recognition_mode(&recognition_mode);
1828
1829                 if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
1830                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continuously'");
1831                         return VC_ERROR_INVALID_STATE;
1832                 }
1833         }
1834
1835         ret = vc_mgr_core_set_selected_results(vc_cmd_list, g_pid);
1836
1837         return ret;
1838 }
1839
1840 int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data)
1841 {
1842         int ret;
1843         ret = __check_mgr_feature_privilege();
1844         if (VC_ERROR_NONE != ret)
1845                 return ret;
1846
1847         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1848
1849         vc_state_e state;
1850         if (0 != vc_mgr_client_get_client_state(&state)) {
1851                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
1852                 return VC_ERROR_INVALID_STATE;
1853         }
1854
1855         /* check state */
1856         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1857
1858         vc_mgr_client_set_all_result_cb(callback, user_data);
1859
1860         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set all result callback");
1861
1862         return VC_ERROR_NONE;
1863 }
1864
1865 int vc_mgr_unset_all_result_cb(void)
1866 {
1867         int ret;
1868         ret = __check_mgr_feature_privilege();
1869         if (VC_ERROR_NONE != ret)
1870                 return ret;
1871
1872         vc_state_e state;
1873         if (0 != vc_mgr_client_get_client_state(&state)) {
1874                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
1875                 return VC_ERROR_INVALID_STATE;
1876         }
1877
1878         /* check state */
1879         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1880
1881         vc_mgr_client_set_all_result_cb(NULL, NULL);
1882
1883         return VC_ERROR_NONE;
1884 }
1885
1886 int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data)
1887 {
1888         int ret;
1889         ret = __check_mgr_feature_privilege();
1890         if (VC_ERROR_NONE != ret)
1891                 return ret;
1892
1893         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1894
1895         vc_state_e state;
1896         if (0 != vc_mgr_client_get_client_state(&state)) {
1897                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
1898                 return VC_ERROR_INVALID_STATE;
1899         }
1900
1901         /* check state */
1902         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1903
1904         vc_mgr_client_set_result_cb(callback, user_data);
1905
1906         return VC_ERROR_NONE;
1907 }
1908
1909 int vc_mgr_unset_result_cb(void)
1910 {
1911         int ret;
1912         ret = __check_mgr_feature_privilege();
1913         if (VC_ERROR_NONE != ret)
1914                 return ret;
1915
1916         vc_state_e state;
1917         if (0 != vc_mgr_client_get_client_state(&state)) {
1918                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
1919                 return VC_ERROR_INVALID_STATE;
1920         }
1921
1922         /* check state */
1923         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1924
1925         vc_mgr_client_set_result_cb(NULL, NULL);
1926
1927         return VC_ERROR_NONE;
1928 }
1929
1930 int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
1931 {
1932         int ret;
1933         ret = __check_mgr_feature_privilege();
1934         if (VC_ERROR_NONE != ret)
1935                 return ret;
1936
1937         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1938
1939         vc_state_e state;
1940         if (0 != vc_mgr_client_get_client_state(&state)) {
1941                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set pre result callback : A handle is not available");
1942                 return VC_ERROR_INVALID_STATE;
1943         }
1944
1945         /* check state */
1946         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1947
1948         vc_mgr_client_set_pre_result_cb(callback, user_data);
1949
1950         return VC_ERROR_NONE;
1951 }
1952
1953 int vc_mgr_unset_pre_result_cb(void)
1954 {
1955         int ret;
1956         ret = __check_mgr_feature_privilege();
1957         if (VC_ERROR_NONE != ret)
1958                 return ret;
1959
1960         vc_state_e state;
1961         if (0 != vc_mgr_client_get_client_state(&state)) {
1962                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset pre result callback : A handle is not available");
1963                 return VC_ERROR_INVALID_STATE;
1964         }
1965
1966         /* check state */
1967         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
1968
1969         vc_mgr_client_set_pre_result_cb(NULL, NULL);
1970
1971         return VC_ERROR_NONE;
1972 }
1973
1974 int vc_mgr_get_error_message(char** err_msg)
1975 {
1976         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get error message");
1977
1978         int ret;
1979         ret = __check_mgr_feature_privilege();
1980         if (VC_ERROR_NONE != ret)
1981                 return ret;
1982
1983         /* check state */
1984         vc_state_e state;
1985         if (0 != vc_mgr_client_get_client_state(&state)) {
1986                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] vc_mgr handle is not available");
1987                 return VC_ERROR_INVALID_STATE;
1988         }
1989
1990         RETVM_IF(NULL == err_msg, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1991
1992         ret = vc_mgr_core_get_error_message(err_msg);
1993
1994         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get error message DONE");
1995
1996         return ret;
1997 }
1998
1999 static Eina_Bool __vc_mgr_notify_state_changed(void *data)
2000 {
2001         vc_state_changed_cb changed_callback = NULL;
2002         void* user_data;
2003
2004         vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data);
2005
2006         vc_state_e current_state;
2007         vc_state_e previous_state;
2008
2009         vc_mgr_client_get_previous_state(&current_state, &previous_state);
2010
2011         if (NULL != changed_callback) {
2012                 vc_mgr_client_use_callback();
2013                 changed_callback(previous_state, current_state, user_data);
2014                 vc_mgr_client_not_use_callback();
2015                 SLOG(LOG_INFO, TAG_VCM, "State changed callback is called");
2016         } else {
2017                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
2018         }
2019
2020         return EINA_FALSE;
2021 }
2022
2023 int vc_mgr_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
2024 {
2025         int ret;
2026         ret = __check_mgr_feature_privilege();
2027         if (VC_ERROR_NONE != ret)
2028                 return ret;
2029
2030         if (callback == NULL)
2031                 return VC_ERROR_INVALID_PARAMETER;
2032
2033         vc_state_e state;
2034         if (0 != vc_mgr_client_get_client_state(&state)) {
2035                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2036                 return VC_ERROR_INVALID_STATE;
2037         }
2038
2039         /* check state */
2040         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2041
2042         vc_mgr_client_set_state_changed_cb(callback, user_data);
2043
2044         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set state changed callback");
2045         return VC_ERROR_NONE;
2046 }
2047
2048 int vc_mgr_unset_state_changed_cb(void)
2049 {
2050         int ret;
2051         ret = __check_mgr_feature_privilege();
2052         if (VC_ERROR_NONE != ret)
2053                 return ret;
2054
2055         vc_state_e state;
2056         if (0 != vc_mgr_client_get_client_state(&state)) {
2057                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2058                 return VC_ERROR_INVALID_STATE;
2059         }
2060
2061         /* check state */
2062         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2063
2064         vc_mgr_client_set_state_changed_cb(NULL, NULL);
2065
2066         return VC_ERROR_NONE;
2067 }
2068
2069 int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
2070 {
2071         int ret;
2072         ret = __check_mgr_feature_privilege();
2073         if (VC_ERROR_NONE != ret)
2074                 return ret;
2075
2076         if (callback == NULL)
2077                 return VC_ERROR_INVALID_PARAMETER;
2078
2079         vc_state_e state;
2080         if (0 != vc_mgr_client_get_client_state(&state)) {
2081                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2082                 return VC_ERROR_INVALID_STATE;
2083         }
2084
2085         /* check state */
2086         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2087
2088         vc_mgr_client_set_service_state_changed_cb(callback, user_data);
2089
2090         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set service state changed callback");
2091         return VC_ERROR_NONE;
2092 }
2093
2094 int vc_mgr_unset_service_state_changed_cb(void)
2095 {
2096         int ret;
2097         ret = __check_mgr_feature_privilege();
2098         if (VC_ERROR_NONE != ret)
2099                 return ret;
2100
2101         vc_state_e state;
2102         if (0 != vc_mgr_client_get_client_state(&state)) {
2103                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2104                 return VC_ERROR_INVALID_STATE;
2105         }
2106
2107         /* check state */
2108         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2109
2110         vc_mgr_client_set_service_state_changed_cb(NULL, NULL);
2111         return VC_ERROR_NONE;
2112 }
2113
2114 int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data)
2115 {
2116         int ret;
2117         ret = __check_mgr_feature_privilege();
2118         if (VC_ERROR_NONE != ret)
2119                 return ret;
2120
2121         if (callback == NULL)
2122                 return VC_ERROR_INVALID_PARAMETER;
2123
2124         vc_state_e state;
2125         if (0 != vc_mgr_client_get_client_state(&state)) {
2126                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2127                 return VC_ERROR_INVALID_STATE;
2128         }
2129
2130         /* check state */
2131         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2132
2133         vc_mgr_client_set_speech_detected_cb(callback, user_data);
2134
2135         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set speech detected callback");
2136         return VC_ERROR_NONE;
2137 }
2138
2139 int vc_mgr_unset_speech_detected_cb(void)
2140 {
2141         int ret;
2142         ret = __check_mgr_feature_privilege();
2143         if (VC_ERROR_NONE != ret)
2144                 return ret;
2145
2146         vc_state_e state;
2147         if (0 != vc_mgr_client_get_client_state(&state)) {
2148                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2149                 return VC_ERROR_INVALID_STATE;
2150         }
2151
2152         /* check state */
2153         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2154
2155         vc_mgr_client_set_speech_detected_cb(NULL, NULL);
2156         return VC_ERROR_NONE;
2157 }
2158
2159 int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2160 {
2161         int ret;
2162         ret = __check_mgr_feature_privilege();
2163         if (VC_ERROR_NONE != ret)
2164                 return ret;
2165
2166         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2167
2168         vc_state_e state;
2169         if (0 != vc_mgr_client_get_client_state(&state)) {
2170                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : A handle is not available");
2171                 return VC_ERROR_INVALID_STATE;
2172         }
2173
2174         /* check state */
2175         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2176
2177         vc_mgr_client_set_current_lang_changed_cb(callback, user_data);
2178
2179         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set current language changed callback");
2180         return VC_ERROR_NONE;
2181 }
2182
2183 int vc_mgr_unset_current_language_changed_cb(void)
2184 {
2185         int ret;
2186         ret = __check_mgr_feature_privilege();
2187         if (VC_ERROR_NONE != ret)
2188                 return ret;
2189
2190         vc_state_e state;
2191         if (0 != vc_mgr_client_get_client_state(&state)) {
2192                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : A handle is not available");
2193                 return VC_ERROR_INVALID_STATE;
2194         }
2195
2196         /* check state */
2197         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2198
2199         vc_mgr_client_set_current_lang_changed_cb(NULL, NULL);
2200
2201         return VC_ERROR_NONE;
2202 }
2203
2204 int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data)
2205 {
2206         int ret;
2207         ret = __check_mgr_feature_privilege();
2208         if (VC_ERROR_NONE != ret)
2209                 return ret;
2210
2211         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2212
2213         vc_state_e state;
2214         if (0 != vc_mgr_client_get_client_state(&state)) {
2215                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2216                 return VC_ERROR_INVALID_STATE;
2217         }
2218
2219         /* check state */
2220         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2221
2222         vc_mgr_client_set_error_cb(callback,  user_data);
2223
2224         return VC_ERROR_NONE;
2225 }
2226
2227 int vc_mgr_unset_error_cb(void)
2228 {
2229         int ret;
2230         ret = __check_mgr_feature_privilege();
2231         if (VC_ERROR_NONE != ret)
2232                 return ret;
2233
2234         vc_state_e state;
2235         if (0 != vc_mgr_client_get_client_state(&state)) {
2236                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2237                 return VC_ERROR_INVALID_STATE;
2238         }
2239
2240         /* check state */
2241         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2242
2243         vc_mgr_client_set_error_cb(NULL, NULL);
2244
2245         return VC_ERROR_NONE;
2246 }
2247
2248 int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data)
2249 {
2250         int ret;
2251         ret = __check_mgr_feature_privilege();
2252         if (VC_ERROR_NONE != ret)
2253                 return ret;
2254
2255         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2256
2257         vc_state_e state;
2258         if (0 != vc_mgr_client_get_client_state(&state)) {
2259                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2260                 return VC_ERROR_INVALID_STATE;
2261         }
2262
2263         /* check state */
2264         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2265
2266         vc_mgr_client_set_dialog_request_cb(callback,  user_data);
2267
2268         return VC_ERROR_NONE;
2269 }
2270
2271 int vc_mgr_unset_dialog_request_cb(void)
2272 {
2273         int ret;
2274         ret = __check_mgr_feature_privilege();
2275         if (VC_ERROR_NONE != ret)
2276                 return ret;
2277
2278         vc_state_e state;
2279         if (0 != vc_mgr_client_get_client_state(&state)) {
2280                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2281                 return VC_ERROR_INVALID_STATE;
2282         }
2283
2284         /* check state */
2285         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2286
2287         vc_mgr_client_set_dialog_request_cb(NULL, NULL);
2288
2289         return VC_ERROR_NONE;
2290 }
2291
2292 int vc_mgr_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* user_data)
2293 {
2294         int ret;
2295         ret = __check_mgr_feature_privilege();
2296         if (VC_ERROR_NONE != ret)
2297                 return ret;
2298
2299         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2300
2301         vc_state_e state;
2302         if (0 != vc_mgr_client_get_client_state(&state)) {
2303                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data set callback : A handle is not available");
2304                 return VC_ERROR_INVALID_STATE;
2305         }
2306
2307         /* check state */
2308         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data set callback : Current state is not 'Initialized'");
2309
2310         vc_mgr_client_set_private_data_set_cb(callback, user_data);
2311
2312         return VC_ERROR_NONE;
2313 }
2314
2315 int vc_mgr_unset_private_data_set_cb(void)
2316 {
2317         int ret;
2318         ret = __check_mgr_feature_privilege();
2319         if (VC_ERROR_NONE != ret)
2320                 return ret;
2321
2322         vc_state_e state;
2323         if (0 != vc_mgr_client_get_client_state(&state)) {
2324                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data set callback : A handle is not available");
2325                 return VC_ERROR_INVALID_STATE;
2326         }
2327
2328         /* check state */
2329         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data set callback : Current state is not 'Initialized'");
2330
2331         vc_mgr_client_set_private_data_set_cb(NULL, NULL);
2332
2333         return VC_ERROR_NONE;
2334 }
2335
2336 int vc_mgr_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callback, void* user_data)
2337 {
2338         int ret;
2339         ret = __check_mgr_feature_privilege();
2340         if (VC_ERROR_NONE != ret)
2341                 return ret;
2342
2343         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2344
2345         vc_state_e state;
2346         if (0 != vc_mgr_client_get_client_state(&state)) {
2347                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data requested callback : A handle is not available");
2348                 return VC_ERROR_INVALID_STATE;
2349         }
2350
2351         /* check state*/
2352         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data requested callback : Current state is not 'Initialized'");
2353
2354         vc_mgr_client_set_private_data_requested_cb(callback, user_data);
2355
2356         return VC_ERROR_NONE;
2357 }
2358
2359 int vc_mgr_unset_private_data_requested_cb(void)
2360 {
2361         int ret;
2362         ret = __check_mgr_feature_privilege();
2363         if (VC_ERROR_NONE != ret)
2364                 return ret;
2365
2366         vc_state_e state;
2367         if (0 != vc_mgr_client_get_client_state(&state)) {
2368                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data requested callback : A handle is not available");
2369                 return VC_ERROR_INVALID_STATE;
2370         }
2371
2372         /* check state */
2373         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data requested callback : Current state is not 'Initialized'");
2374
2375         vc_mgr_client_set_private_data_requested_cb(NULL, NULL);
2376
2377         return VC_ERROR_NONE;
2378 }
2379
2380 int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data)
2381 {
2382         int ret;
2383         ret = __check_mgr_feature_privilege();
2384         if (VC_ERROR_NONE != ret)
2385                 return ret;
2386
2387         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2388
2389         vc_state_e state;
2390         if (0 != vc_mgr_client_get_client_state(&state)) {
2391                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set specific engine result callback : A handle is not available");
2392                 return VC_ERROR_INVALID_STATE;
2393         }
2394
2395         /* check state */
2396         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2397
2398         vc_mgr_client_set_specific_engine_result_cb(callback, user_data);
2399
2400         return VC_ERROR_NONE;
2401 }
2402 int vc_mgr_unset_specific_engine_result_cb(void)
2403 {
2404         if (0 != __vc_mgr_get_feature_enabled()) {
2405                 return VC_ERROR_NOT_SUPPORTED;
2406         }
2407
2408         vc_state_e state;
2409         if (0 != vc_mgr_client_get_client_state(&state)) {
2410                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset specific engine result callback : A handle is not available");
2411                 return VC_ERROR_INVALID_STATE;
2412         }
2413
2414         /* check state */
2415         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2416
2417         vc_mgr_client_set_specific_engine_result_cb(NULL, NULL);
2418
2419         return VC_ERROR_NONE;
2420 }
2421
2422 /* for TTS feedback */
2423 int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data)
2424 {
2425         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback audio format");
2426
2427         int ret;
2428         ret = __check_mgr_feature_privilege();
2429         if (VC_ERROR_NONE != ret)
2430                 return ret;
2431
2432         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2433
2434         vc_state_e state;
2435         if (0 != vc_mgr_client_get_client_state(&state)) {
2436                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback audio format callback : A handle is not available");
2437                 return VC_ERROR_INVALID_STATE;
2438         }
2439
2440         /* check state */
2441         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set feedback audio format callback : Current state is not 'Initialized'");
2442
2443         vc_mgr_client_set_feedback_audio_format_cb(callback, user_data);
2444
2445         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback audio format callback");
2446
2447         return VC_ERROR_NONE;
2448 }
2449
2450 int vc_mgr_unset_feedback_audio_format_cb()
2451 {
2452         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback audio format");
2453
2454         int ret;
2455         ret = __check_mgr_feature_privilege();
2456         if (VC_ERROR_NONE != ret)
2457                 return ret;
2458
2459         vc_state_e state;
2460         if (0 != vc_mgr_client_get_client_state(&state)) {
2461                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback audio format callback : A handle is not available");
2462                 return VC_ERROR_INVALID_STATE;
2463         }
2464
2465         /* check state */
2466         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset feedback audio format callback : Current state is not 'Initialized'");
2467
2468         vc_mgr_client_set_feedback_audio_format_cb(NULL, NULL);
2469
2470         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback audio format callback");
2471
2472         return VC_ERROR_NONE;
2473 }
2474
2475 int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data)
2476 {
2477         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback streaming");
2478
2479         int ret;
2480         ret = __check_mgr_feature_privilege();
2481         if (VC_ERROR_NONE != ret)
2482                 return ret;
2483
2484         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2485
2486         pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
2487
2488         vc_state_e state;
2489         if (0 != vc_mgr_client_get_client_state(&state)) {
2490                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
2491                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2492                 return VC_ERROR_INVALID_STATE;
2493         }
2494
2495         /* check state */
2496         if (VC_STATE_INITIALIZED != state) {
2497                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
2498                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2499                 return VC_ERROR_INVALID_STATE;
2500         }
2501
2502         vc_mgr_client_set_feedback_streaming_cb(callback, user_data);
2503
2504         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2505
2506         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
2507
2508         return VC_ERROR_NONE;
2509 }
2510
2511 int vc_mgr_unset_feedback_streaming_cb()
2512 {
2513         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback streaming");
2514
2515         int ret;
2516         ret = __check_mgr_feature_privilege();
2517         if (VC_ERROR_NONE != ret)
2518                 return ret;
2519
2520         pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
2521
2522         vc_state_e state;
2523         if (0 != vc_mgr_client_get_client_state(&state)) {
2524                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
2525                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2526                 return VC_ERROR_INVALID_STATE;
2527         }
2528
2529         /* check state */
2530         if (VC_STATE_INITIALIZED != state) {
2531                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
2532                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2533                 return VC_ERROR_INVALID_STATE;
2534         }
2535
2536         vc_mgr_client_set_feedback_streaming_cb(NULL, NULL);
2537
2538         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2539
2540         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
2541
2542         return VC_ERROR_NONE;
2543 }
2544
2545 int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* user_data)
2546 {
2547         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set vc tts streaming callback");
2548
2549         int ret;
2550         ret = __check_mgr_feature_privilege();
2551         if (VC_ERROR_NONE != ret)
2552                 return ret;
2553
2554         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2555
2556         pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
2557
2558         vc_state_e state;
2559         if (0 != vc_mgr_client_get_client_state(&state)) {
2560                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
2561                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2562                 return VC_ERROR_INVALID_STATE;
2563         }
2564
2565         /* check state */
2566         if (VC_STATE_INITIALIZED != state) {
2567                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
2568                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2569                 return VC_ERROR_INVALID_STATE;
2570         }
2571
2572         vc_mgr_client_set_vc_tts_streaming_cb(callback, user_data);
2573
2574         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2575
2576         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
2577
2578         return VC_ERROR_NONE;
2579 }
2580
2581 int vc_mgr_unset_vc_tts_streaming_cb()
2582 {
2583         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset vc tts streaming callback");
2584
2585         int ret;
2586         ret = __check_mgr_feature_privilege();
2587         if (VC_ERROR_NONE != ret)
2588                 return ret;
2589
2590         pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
2591
2592         vc_state_e state;
2593         if (0 != vc_mgr_client_get_client_state(&state)) {
2594                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
2595                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2596                 return VC_ERROR_INVALID_STATE;
2597         }
2598
2599         /* check state */
2600         if (VC_STATE_INITIALIZED != state) {
2601                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
2602                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2603                 return VC_ERROR_INVALID_STATE;
2604         }
2605
2606         vc_mgr_client_set_vc_tts_streaming_cb(NULL, NULL);
2607
2608         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2609
2610         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
2611
2612         return VC_ERROR_NONE;
2613 }
2614
2615 static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
2616 {
2617         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Start thread");
2618
2619         vc_feedback_data_s* feedback_data = NULL;
2620
2621         while (1) {
2622                 int ret = -1;
2623                 int cnt = 0;
2624
2625                 /* get feedback data */
2626                 ret = vc_mgr_data_get_feedback_data(&feedback_data);
2627                 if (0 != ret || NULL == feedback_data) {
2628                         /* empty queue */
2629                         SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No feedback data. Waiting mode");
2630
2631                         /* waiting */
2632                         while (1) {
2633                                 if (ecore_thread_check(thread) == EINA_TRUE) {
2634                                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Stop feedback is called");
2635                                         return;
2636                                 }
2637
2638                                 usleep(10000);
2639
2640                                 if (0 < vc_mgr_data_get_feedback_data_size()) {
2641                                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Resume thread");
2642                                         break;
2643                                 }
2644                                 if (200 < cnt) {
2645                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Wrong request, there's no pcm data");
2646                                         vc_mgr_data_clear_feedback_data(&feedback_data);
2647                                         return;
2648                                 }
2649                                 cnt++;
2650                         }
2651                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish to wait for new feedback data come");
2652
2653                         /* resume feedback thread */
2654                         vc_mgr_data_clear_feedback_data(&feedback_data);
2655                         continue;
2656                 }
2657
2658                 if (NULL != feedback_data) {
2659                         if (getpid() == feedback_data->pid) {
2660                                 vc_mgr_feedback_streaming_cb callback = NULL;
2661                                 void* user_data = NULL;
2662
2663                                 pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
2664
2665                                 vc_mgr_client_get_feedback_streaming_cb(&callback, &user_data);
2666                                 if (NULL == callback) {
2667                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback streaming callback is null");
2668                                         vc_mgr_data_clear_feedback_data(&feedback_data);
2669                                         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2670                                         return;
2671                                 }
2672
2673                                 SLOG(LOG_DEBUG, TAG_VCM, "TTS feedback streaming callback is called");
2674                                 vc_mgr_client_use_callback();
2675                                 callback(feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
2676                                 vc_mgr_client_not_use_callback();
2677
2678                                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
2679                         } else {
2680                                 vc_mgr_vc_tts_streaming_cb callback = NULL;
2681                                 void* user_data = NULL;
2682
2683                                 pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
2684
2685                                 vc_mgr_client_get_vc_tts_streaming_cb(&callback, &user_data);
2686                                 if (NULL == callback) {
2687                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] vc tts streaming callback is null");
2688                                         vc_mgr_data_clear_feedback_data(&feedback_data);
2689                                         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2690                                         return;
2691                                 }
2692
2693                                 SLOG(LOG_DEBUG, TAG_VCM, "vc tts feedback streaming callback is called");
2694                                 vc_mgr_client_use_callback();
2695                                 callback(feedback_data->pid, feedback_data->utt_id, feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
2696                                 vc_mgr_client_not_use_callback();
2697
2698                                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
2699                         }
2700                         free(feedback_data);
2701                         feedback_data = NULL;
2702                 }
2703         }
2704 }
2705
2706 static void __end_tts_feedback_thread(void* data, Ecore_Thread* thread)
2707 {
2708         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] End thread");
2709         g_feedback_thread = NULL;
2710 }
2711
2712 static void __cancel_tts_feedback_thread(void* data, Ecore_Thread* thread)
2713 {
2714         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel thread");
2715         g_feedback_thread = NULL;
2716 }
2717
2718 int vc_mgr_start_feedback(void)
2719 {
2720         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] start feedback");
2721
2722         int ret;
2723         ret = __check_mgr_feature_privilege();
2724         if (VC_ERROR_NONE != ret)
2725                 return ret;
2726
2727         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request start TTS feedback");
2728
2729         vc_state_e state;
2730         if (0 != vc_mgr_client_get_client_state(&state)) {
2731                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Start feedback : A handle is not available");
2732                 return VC_ERROR_INVALID_STATE;
2733         }
2734
2735         /* check state */
2736         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Start feedback : Current state is not 'Ready' (%d)", state);
2737
2738         bool is_exist = ecore_thread_check(g_feedback_thread);
2739         if (NULL == g_feedback_thread || TRUE == is_exist) {
2740                 SLOG(LOG_INFO, TAG_VCM, "[INFO] ecore thread run : __tts_feedback_thread");
2741                 g_feedback_thread = ecore_thread_run(__tts_feedback_thread, __end_tts_feedback_thread, __cancel_tts_feedback_thread, NULL);
2742         }
2743
2744         return VC_ERROR_NONE;
2745 }
2746
2747 int vc_mgr_stop_feedback(void)
2748 {
2749         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] stop feedback");
2750
2751         int ret;
2752         ret = __check_mgr_feature_privilege();
2753         if (VC_ERROR_NONE != ret)
2754                 return ret;
2755
2756         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request stop TTS feedback");
2757
2758         vc_state_e state;
2759         if (0 != vc_mgr_client_get_client_state(&state)) {
2760                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stop feedback : A handle is not available");
2761                 return VC_ERROR_INVALID_STATE;
2762         }
2763
2764         /* check state */
2765         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Stop feedback : Current state is not 'Ready' (%d)", state);
2766
2767         if (g_feedback_thread) {
2768                 ecore_thread_cancel(g_feedback_thread);
2769                 g_feedback_thread = NULL;
2770         }
2771
2772         ret = -1;
2773         while (1) {
2774                 vc_feedback_data_s* feedback_data = NULL;
2775
2776                 /* get feedback data */
2777                 ret = vc_mgr_data_get_feedback_data(&feedback_data);
2778                 if (0 != ret || NULL == feedback_data) {
2779                         /* empty queue */
2780                         SLOG(LOG_INFO, TAG_VCM, "[INFO] No feedback data to stop any more");
2781                         return VC_ERROR_NONE;
2782                 }
2783                 ret = vc_mgr_data_clear_feedback_data(&feedback_data);
2784                 if (0 != ret) {
2785                         SLOG(LOG_INFO, TAG_VCM, "[ERROR] Fail to clear data, ret(%d)", ret);
2786                         break;
2787                 }
2788         }
2789
2790         return ret;
2791 }
2792
2793 int vc_mgr_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status)
2794 {
2795         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send utterance status, pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
2796
2797         int ret;
2798         ret = __check_mgr_feature_privilege();
2799         if (VC_ERROR_NONE != ret)
2800                 return ret;
2801
2802         if (VC_TTS_UTTERANCE_NONE > utt_status || VC_TTS_UTTERANCE_CANCELED < utt_status || 0 == utt_status) {
2803                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] utt_status is not valid. (%d)", utt_status);
2804                 return VC_ERROR_INVALID_PARAMETER;
2805         }
2806
2807         vc_state_e state;
2808         if (0 != vc_mgr_client_get_client_state(&state)) {
2809                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
2810                 return VC_ERROR_INVALID_STATE;
2811         }
2812
2813         /* check state */
2814         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
2815
2816         /* Check service state */
2817         vc_service_state_e service_state = -1;
2818         vc_mgr_client_get_service_state(&service_state);
2819         RETVM_IF(service_state != VC_SERVICE_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current service state(%d) is not 'READY'", service_state);
2820
2821         ret = vc_mgr_tidl_send_utterance_status(pid, utt_id, utt_status);
2822         if (0 != ret)
2823                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send utterance status : %s", __vc_mgr_get_error_code(ret));
2824         else
2825                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Send utterance status");
2826
2827         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send utterance status DONE");
2828         return ret;
2829 }
2830
2831 static float __get_volume_decibel(char* data, int size)
2832 {
2833 #define MAX_AMPLITUDE_MEAN_16 32768
2834
2835         int i, depthByte;
2836         int count = 0;
2837
2838         float db = 0.0;
2839         float rms = 0.0;
2840         unsigned long long square_sum = 0;
2841         short pcm16 = 0;
2842
2843         depthByte = 2;
2844
2845         for (i = 0; i < size; i += (depthByte<<1)) {
2846                 pcm16 = 0;
2847                 memcpy(&pcm16, data + i, sizeof(short));
2848                 square_sum += pcm16 * pcm16;
2849                 count++;
2850         }
2851
2852         if (0 == count || 0 == square_sum) {
2853                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No data");
2854                 rms = 1.0;
2855         } else {
2856                 rms = sqrt((float)square_sum/count);
2857         }
2858
2859         db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16);
2860         return db;
2861 }
2862
2863 int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
2864 {
2865         SLOG(LOG_INFO, TAG_VCM, "[Manager] Send audio streaming to the engine service, event(%d)", event);
2866
2867         int ret;
2868         ret = __check_mgr_feature_privilege();
2869         if (VC_ERROR_NONE != ret)
2870                 return ret;
2871
2872         if (VC_AUDIO_STREAMING_EVENT_FAIL > event || VC_AUDIO_STREAMING_EVENT_FINISH < event || 0 == event) {
2873                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] event is invalid parameter (%d)", event);
2874                 return VC_ERROR_INVALID_PARAMETER;
2875         }
2876
2877         RETVM_IF(NULL == buffer, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2878
2879         vc_state_e state = VC_STATE_NONE;
2880         ret = vc_mgr_client_get_client_state(&state);
2881         if (0 != ret) {
2882                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
2883                 return VC_ERROR_INVALID_STATE;
2884         }
2885
2886         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
2887
2888         vc_service_state_e service_state = VC_SERVICE_STATE_NONE;
2889         ret = vc_mgr_client_get_service_state(&service_state);
2890         if (0 != ret) {
2891                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
2892                 return VC_ERROR_INVALID_STATE;
2893         }
2894
2895         if (VC_SERVICE_STATE_READY != service_state && VC_SERVICE_STATE_RECORDING != service_state) {
2896                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY' and 'RECORDING', state(%d)", service_state);
2897                 return VC_ERROR_INVALID_STATE;
2898         }
2899
2900         float volume = __get_volume_decibel((char*)buffer, len);
2901         // TODO: check __vc_mgr_set_volume need to move
2902         __vc_mgr_set_volume(volume);
2903
2904         ret = vc_mgr_tidl_send_audio_streaming(g_pid, event, buffer, len);
2905         if (0 != ret)
2906                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data");
2907         else
2908                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to send");
2909         return ret;
2910 }
2911
2912 int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode)
2913 {
2914         SLOG(LOG_INFO, TAG_VCM, "[Manager] Set multi assistant mode, mode(%d)", mode);
2915
2916         int ret;
2917         ret = __check_mgr_feature_privilege();
2918         if (VC_ERROR_NONE != ret)
2919                 return ret;
2920
2921         if (VC_AUDIO_STREAMING_MODE_VC_SERVICE > mode || VC_AUDIO_STREAMING_MODE_OUTSIDE < mode) {
2922                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] mode is invalid parameter (%d)", mode);
2923                 return VC_ERROR_INVALID_PARAMETER;
2924         }
2925
2926         vc_state_e state = VC_STATE_NONE;
2927         ret = vc_mgr_client_get_client_state(&state);
2928         if (0 != ret) {
2929                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
2930                 return VC_ERROR_INVALID_STATE;
2931         }
2932
2933         vc_service_state_e service_state = VC_SERVICE_STATE_NONE;
2934         ret = vc_mgr_client_get_service_state(&service_state);
2935         if (0 != ret) {
2936                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
2937                 return VC_ERROR_INVALID_STATE;
2938         }
2939
2940         if (VC_STATE_INITIALIZED == state && VC_SERVICE_STATE_NONE == service_state) {
2941                 ret = vc_mgr_client_set_audio_streaming_mode(mode);
2942                 if (VC_ERROR_NONE != ret) {
2943                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret));
2944                         return VC_ERROR_INVALID_STATE;
2945                 } else {
2946                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client");
2947                 }
2948         } else if (VC_STATE_READY == state && VC_SERVICE_STATE_READY == service_state) {
2949                 ret = vc_mgr_client_set_audio_streaming_mode(mode);
2950                 if (VC_ERROR_NONE != ret) {
2951                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret));
2952                         return VC_ERROR_INVALID_STATE;
2953                 } else {
2954                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client");
2955                 }
2956
2957                 ret = vc_mgr_tidl_request_set_audio_streaming_mode(g_pid, mode);
2958                 if (VC_ERROR_NONE != ret) {
2959                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %s", __vc_mgr_get_error_code(ret));
2960                         return VC_ERROR_OPERATION_FAILED;
2961                 } else {
2962                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr tidl");
2963                 }
2964         } else {
2965                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'INITIALIZED', state(%d)", state);
2966                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current service state is not 'READY', service_state(%d)", service_state);
2967                 return VC_ERROR_INVALID_STATE;
2968         }
2969
2970         return VC_ERROR_NONE;
2971 }
2972
2973 //TODO it's internal api, so will remove it.
2974 int vc_mgr_change_system_volume(vc_system_volume_event_e event)
2975 {
2976         return vc_mgr_change_background_volume(event);
2977 }
2978
2979 //TODO it's internal api, so will remove it.
2980 int vc_mgr_recover_system_volume(void)
2981 {
2982         return vc_mgr_reset_background_volume();
2983 }
2984
2985 int vc_mgr_change_background_volume(vc_background_volume_event_e event)
2986 {
2987         SLOG(LOG_INFO, TAG_VCM, "[Manager] Change background volume. event(%d)", event);
2988
2989         int ret;
2990         ret = __check_mgr_feature_privilege();
2991         if (VC_ERROR_NONE != ret)
2992                 return ret;
2993
2994         if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD > event || VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_FARFIELD < event) {
2995                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] event is invalid parameter (%d)", event);
2996                 return VC_ERROR_INVALID_PARAMETER;
2997         }
2998
2999         vc_state_e state = VC_STATE_NONE;
3000         ret = vc_mgr_client_get_client_state(&state);
3001         if (VC_ERROR_NONE != ret) {
3002                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3003                 return VC_ERROR_INVALID_STATE;
3004         }
3005
3006         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3007                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3008                 return VC_ERROR_INVALID_STATE;
3009         }
3010
3011         double ratio = 0.0;
3012         if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_FARFIELD == event)
3013                 ratio = VC_MGR_DEFAULT_FARFIELD_DUCKING_RATIO;
3014         else if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD == event)
3015                 ratio = VC_MGR_DEFAULT_NEARFIELD_DUCKING_RATIO;
3016
3017         ret = vc_mgr_ducking_activate(ratio);
3018         if (VC_ERROR_NONE != ret)
3019                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to change volume");
3020         else
3021                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to change volume");
3022         return ret;
3023 }
3024
3025 int vc_mgr_change_background_volume_by_ratio(double ratio)
3026 {
3027         SLOG(LOG_INFO, TAG_VCM, "[Manager] Change background volume. ratio(%f)", ratio);
3028
3029         int ret;
3030         ret = __check_mgr_feature_privilege();
3031         if (VC_ERROR_NONE != ret)
3032                 return ret;
3033
3034         if (VC_MGR_MINIMUM_DUCKING_RATIO > ratio || VC_MGR_MAXIMUM_DUCKING_RATIO < ratio) {
3035                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] ratio is invalid parameter (%lf)", ratio);
3036                 return VC_ERROR_INVALID_PARAMETER;
3037         }
3038
3039         vc_state_e state = VC_STATE_NONE;
3040         ret = vc_mgr_client_get_client_state(&state);
3041         if (VC_ERROR_NONE != ret) {
3042                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3043                 return VC_ERROR_INVALID_STATE;
3044         }
3045
3046         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3047                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3048                 return VC_ERROR_INVALID_STATE;
3049         }
3050
3051         ret = vc_mgr_ducking_activate(ratio);
3052         if (VC_ERROR_NONE != ret)
3053                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set ratio");
3054         else
3055                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to set ratio");
3056
3057         return ret;
3058 }
3059
3060 int vc_mgr_reset_background_volume(void)
3061 {
3062         SLOG(LOG_INFO, TAG_VCM, "[Manager] Recover background volume");
3063
3064         int ret;
3065         ret = __check_mgr_feature_privilege();
3066         if (VC_ERROR_NONE != ret)
3067                 return ret;
3068
3069         vc_state_e state = VC_STATE_NONE;
3070         ret = vc_mgr_client_get_client_state(&state);
3071         if (VC_ERROR_NONE != ret) {
3072                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3073                 return VC_ERROR_INVALID_STATE;
3074         }
3075
3076         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3077                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3078                 return VC_ERROR_INVALID_STATE;
3079         }
3080
3081         ret = vc_mgr_ducking_deactivate();
3082         if (VC_ERROR_NONE != ret)
3083                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to recover volume");
3084         else
3085                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to recover volume");
3086
3087         return ret;
3088 }