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