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_client.h"
  32 #include "vc_mgr_tidl.h"
  33 #include "vc_mgr_data.h"
  34 #include "vc_mgr_player.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 Ecore_Timer* g_m_set_volume_timer = NULL;
  50
  51 static int g_pid;
  52
  53 static GSList* g_demandable_client_list = NULL;
  54
  55 static float g_volume_db = 0;
  56
  57 static float g_prev_volume_db = 0;
  58
  59 static float g_cur_volume_db = 0;
  60
  61 static int g_daemon_pid = 0;
  62
  63 static int g_feature_enabled = -1;
  64
  65 static bool g_privilege_allowed = false;
  66
  67 static cynara *p_cynara = NULL;
  68 static pthread_mutex_t g_cynara_mutex = PTHREAD_MUTEX_INITIALIZER;
  69
  70 static bool g_err_callback_status = false;
  71
  72 /* for TTS feedback */
  73 static int g_feedback_rate = 16000;
  74 static vc_audio_channel_e g_feedback_audio_channel = 0;
  75 static vc_audio_type_e g_feedback_audio_type = 0;
  76 static Ecore_Thread* g_feedback_thread = NULL;
  77
  78 static pthread_mutex_t g_feedback_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
  79 static pthread_mutex_t g_vc_tts_streaming_cb_mutex = PTHREAD_MUTEX_INITIALIZER;
  80
  81 static Eina_Bool __vc_mgr_notify_state_changed(void *data);
  82 static void __vc_mgr_notify_error(void *data);
  83 static Eina_Bool __vc_mgr_notify_result(void *data);
  84
  85 int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg);
  86
  87
  88 static const char* __vc_mgr_get_error_code(vc_error_e err)
  89 {
  90         switch (err) {
  91         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";
  92         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";
  93         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";
  94         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";
  95         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";
  96         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";
  97         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";
  98         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";
  99         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";
 100         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";
 101         default:                                return "Invalid error code";
 102         }
 103         return NULL;
 104 }
 105
 106 static void __vc_mgr_lang_changed_cb(const char* previous_lang, const char* current_lang)
 107 {
 108         SLOG(LOG_INFO, TAG_VCM, "Lang changed : previous lang(%s) current lang(%s)",
 109                                 previous_lang, current_lang);
 110
 111         vc_current_language_changed_cb callback = NULL;
 112         void* lang_user_data;
 113         vc_mgr_client_get_current_lang_changed_cb(&callback, &lang_user_data);
 114
 115         if (NULL != callback) {
 116                 vc_mgr_client_use_callback();
 117                 callback(previous_lang, current_lang, lang_user_data);
 118                 vc_mgr_client_not_use_callback();
 119                 SLOG(LOG_INFO, TAG_VCM, "Language changed callback is called");
 120         } else {
 121                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Language changed callback is null");
 122         }
 123
 124         return;
 125 }
 126
 127 static int __vc_mgr_get_feature_enabled()
 128 {
 129         if (0 == g_feature_enabled) {
 130                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
 131                 return VC_ERROR_NOT_SUPPORTED;
 132         } else if (-1 == g_feature_enabled) {
 133                 bool vc_supported = false;
 134                 bool mic_supported = false;
 135                 if (0 == system_info_get_platform_bool(VC_MGR_FEATURE_PATH, &vc_supported)) {
 136                         if (0 == system_info_get_platform_bool(VC_MIC_FEATURE_PATH, &mic_supported)) {
 137                                 if (false == vc_supported || false == mic_supported) {
 138                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Voice control feature NOT supported");
 139                                         g_feature_enabled = 0;
 140                                         return VC_ERROR_NOT_SUPPORTED;
 141                                 }
 142
 143                                 g_feature_enabled = 1;
 144                         }
 145                 }
 146         }
 147
 148         return VC_ERROR_NONE;
 149 }
 150
 151 static int __check_privilege_initialize()
 152 {
 153         int ret = cynara_initialize(&p_cynara, NULL);
 154         if (NULL == p_cynara || CYNARA_API_SUCCESS != ret) {
 155                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to initialize(%d)", ret);
 156                 return ret;
 157         }
 158
 159         return ret == CYNARA_API_SUCCESS;
 160 }
 161
 162 static int __check_privilege(const char* uid, const char * privilege)
 163 {
 164         FILE *fp = NULL;
 165         char label_path[1024] = "/proc/self/attr/current";
 166         char smack_label[1024] = {'\0',};
 167
 168         if (!p_cynara) {
 169                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] p_cynara is NULL");
 170                 return false;
 171         }
 172
 173         fp = fopen(label_path, "r");
 174         if (fp != NULL) {
 175                 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
 176                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to fread");
 177
 178                 fclose(fp);
 179         }
 180
 181         pid_t pid = getpid();
 182         char *session = cynara_session_from_pid(pid);
 183         int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
 184         if (session)
 185                 free(session);
 186         session = NULL;
 187
 188         if (ret != CYNARA_API_ACCESS_ALLOWED) {
 189                 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);
 190                 return false;
 191         }
 192
 193         return true;
 194 }
 195
 196 static void __check_privilege_deinitialize()
 197 {
 198         if (p_cynara) {
 199                 int ret = cynara_finish(p_cynara);
 200                 if (ret != CYNARA_API_SUCCESS)
 201                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cynara finish %d", ret);
 202         }
 203         p_cynara = NULL;
 204 }
 205
 206 static int __vc_mgr_check_privilege()
 207 {
 208         if (true == g_privilege_allowed)
 209                 return VC_ERROR_NONE;
 210
 211         pthread_mutex_lock(&g_cynara_mutex);
 212
 213         if (false == g_privilege_allowed) {
 214                 bool ret = true;
 215                 ret = __check_privilege_initialize();
 216                 if (false == ret) {
 217                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] privilege initialize is failed");
 218                         g_privilege_allowed = false;
 219                         pthread_mutex_unlock(&g_cynara_mutex);
 220                         return VC_ERROR_PERMISSION_DENIED;
 221                 }
 222
 223                 char uid[32];
 224                 snprintf(uid, 32, "%d", getuid());
 225                 ret = true;
 226                 ret = __check_privilege(uid, VC_PRIVILEGE_RECORDER);
 227                 if (false == ret) {
 228                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Permission is denied(%s)(%s)", VC_PRIVILEGE_RECORDER, uid);
 229                         __check_privilege_deinitialize();
 230                         g_privilege_allowed = false;
 231                         pthread_mutex_unlock(&g_cynara_mutex);
 232                         return VC_ERROR_PERMISSION_DENIED;
 233                 }
 234
 235                 ret = __check_privilege(uid, VC_MGR_PRIVILEGE);
 236                 if (false == ret) {
 237                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Permission is denied(%s)(%s)", VC_MGR_PRIVILEGE, uid);
 238                         __check_privilege_deinitialize();
 239                         g_privilege_allowed = false;
 240                         pthread_mutex_unlock(&g_cynara_mutex);
 241                         return VC_ERROR_PERMISSION_DENIED;
 242                 }
 243
 244                 __check_privilege_deinitialize();
 245         }
 246
 247         g_privilege_allowed = true;
 248         pthread_mutex_unlock(&g_cynara_mutex);
 249         return VC_ERROR_NONE;
 250 }
 251
 252 int __check_mgr_feature_privilege()
 253 {
 254         if (0 != __vc_mgr_get_feature_enabled()) {
 255                 SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
 256                 return VC_ERROR_NOT_SUPPORTED;
 257         }
 258
 259         if (0 != __vc_mgr_check_privilege()) {
 260                 return VC_ERROR_PERMISSION_DENIED;
 261         }
 262
 263         return VC_ERROR_NONE;
 264 }
 265
 266 int vc_mgr_initialize(void)
 267 {
 268         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Initialize");
 269
 270         int ret;
 271         ret = __check_mgr_feature_privilege();
 272         if (VC_ERROR_NONE != ret)
 273                 return ret;
 274
 275         /* check handle */
 276         if (true == vc_mgr_client_is_valid()) {
 277                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already initialized");
 278                 return VC_ERROR_NONE;
 279         }
 280
 281         if (0 != vc_mgr_tidl_open_connection()) {
 282                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open tidl connection");
 283                 return VC_ERROR_OPERATION_FAILED;
 284         }
 285
 286         if (0 != vc_mgr_client_create()) {
 287                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create client!!!!!");
 288                 return VC_ERROR_OUT_OF_MEMORY;
 289         }
 290
 291         g_pid = getpid();
 292         ret = vc_config_mgr_initialize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 293         if (0 != ret) {
 294                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to init config manager : %d", ret);
 295                 vc_mgr_client_destroy();
 296                 return VC_ERROR_OPERATION_FAILED;
 297         }
 298
 299         ret = vc_config_mgr_set_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_lang_changed_cb);
 300         if (0 != ret) {
 301                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set callback : %d", ret);
 302                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 303                 vc_mgr_client_destroy();
 304                 return VC_ERROR_OPERATION_FAILED;
 305         }
 306
 307         ret = vc_mgr_client_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE);
 308         if (0 != ret) {
 309                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %d", ret);
 310                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 311                 vc_mgr_client_destroy();
 312                 return ret;
 313         }
 314
 315         /* for TTS feedback */
 316 /*      ret = vc_mgr_player_init();
 317         if (0 != ret) {
 318                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize VC mgr player : %d", ret);
 319         }
 320 */
 321
 322         ret = vc_mgr_ducking_create();
 323         if (VC_ERROR_NONE != ret) {
 324                 SLOG(LOG_INFO, TAG_VCM, "[INFO] Fail to ducking create : %d", ret);
 325         }
 326
 327         SLOG(LOG_ERROR, TAG_VCM, "[Success] pid(%d)", g_pid);
 328
 329         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Initialize DONE");
 330
 331         return VC_ERROR_NONE;
 332 }
 333
 334 static void __vc_mgr_internal_unprepare()
 335 {
 336         int ret = vc_mgr_tidl_request_finalize(g_pid);
 337         if (0 != ret) {
 338                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
 339         }
 340
 341         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
 342         return;
 343 }
 344
 345 int vc_mgr_deinitialize(void)
 346 {
 347         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Deinitialize");
 348
 349         int ret;
 350         ret = __check_mgr_feature_privilege();
 351         if (VC_ERROR_NONE != ret)
 352                 return ret;
 353
 354         if (false == vc_mgr_client_is_valid()) {
 355                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NOT initialized");
 356                 return VC_ERROR_INVALID_STATE;
 357         }
 358
 359         vc_state_e state;
 360         vc_mgr_client_get_client_state(&state);
 361
 362         /* check state */
 363         switch (state) {
 364         case VC_STATE_READY:
 365                 __vc_mgr_internal_unprepare();
 366                 /* no break. need to next step*/
 367         case VC_STATE_INITIALIZED:
 368                 if (NULL != g_send_hello_timer) {
 369                         SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
 370                         ecore_timer_del(g_send_hello_timer);
 371                         g_send_hello_timer = NULL;
 372                 }
 373                 if (g_request_init_timer) {
 374                         SLOG(LOG_DEBUG, TAG_VCM, "Connect idler is deleted");
 375                         ecore_timer_del(g_request_init_timer);
 376                         g_request_init_timer = NULL;
 377                 }
 378
 379                 vc_config_mgr_unset_lang_cb(g_pid + VC_MANAGER_CONFIG_HANDLE);
 380                 vc_config_mgr_finalize(g_pid + VC_MANAGER_CONFIG_HANDLE);
 381
 382                 /* Free client resources */
 383                 vc_mgr_client_destroy();
 384                 g_pid = 0;
 385                 break;
 386         case VC_STATE_NONE:
 387                 break;
 388         }
 389
 390         SLOG(LOG_DEBUG, TAG_VCM, "Success: destroy");
 391
 392         int cnt = VC_COMMAND_TYPE_FOREGROUND;
 393         do {
 394                 ret = vc_cmd_parser_delete_file(getpid(), cnt);
 395                 if (0 != ret)
 396                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", cnt, ret);
 397         } while (VC_COMMAND_TYPE_EXCLUSIVE >= ++cnt);
 398
 399         ret = vc_db_finalize();
 400         if (0 != ret) {
 401                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to finalize DB, ret(%d)", ret);
 402         }
 403
 404         /* for TTS feedback */
 405 /*      ret = vc_mgr_player_release();
 406         if (0 != ret) {
 407                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to release VC mgr player(%d)", ret);
 408         }
 409 */
 410
 411         ret = vc_mgr_ducking_destroy();
 412         if (VC_ERROR_NONE != ret) {
 413                 SLOG(LOG_INFO, TAG_VCM, "[INFO] Fail to ducking destroy : %d", ret);
 414         }
 415
 416         if (0 != vc_mgr_tidl_close_connection()) {
 417                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection");
 418         }
 419
 420         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Deinitialize DONE");
 421
 422         return VC_ERROR_NONE;
 423 }
 424
 425 static Eina_Bool __request_initialize(void *data)
 426 {
 427         /* request initialization */
 428         int ret = -1;
 429         int service_state = 0;
 430         int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
 431
 432
 433         /* check handle */
 434         if (true == vc_mgr_client_is_valid()) {
 435                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG]  is valid");
 436
 437                 /* Initialize DB */
 438                 ret = vc_db_initialize();
 439                 if (0 != ret) {
 440                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize DB : %d", ret);
 441                         return EINA_TRUE;
 442                 }
 443
 444                 vc_audio_streaming_mode_e streaming_mode;
 445                 vc_mgr_client_get_audio_streaming_mode(&streaming_mode);
 446
 447                 ret = vc_mgr_tidl_request_initialize(g_pid, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid);
 448
 449                 if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 450                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
 451
 452                         vc_mgr_client_set_error(VC_ERROR_ENGINE_NOT_FOUND);
 453                         ecore_main_loop_thread_safe_call_async(__vc_mgr_notify_error, NULL);
 454
 455                         SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 456                         g_request_init_timer = NULL;
 457                         return EINA_FALSE;
 458
 459                 } else if (0 != ret) {
 460                         SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Fail to connection. Retry to connect : %s", __vc_mgr_get_error_code(ret));
 461                         ret = vc_db_finalize();
 462                         if (0 != ret) {
 463                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to finalize DB : %d", ret);
 464                         }
 465                         return EINA_TRUE;
 466                 } else {
 467                         /* Success to connect */
 468                 }
 469
 470                 /* Set service state */
 471                 vc_service_state_e previous_service_state;
 472                 vc_mgr_client_get_service_state(&previous_service_state);
 473                 vc_mgr_client_set_service_state((vc_service_state_e)service_state);
 474
 475                 vc_service_state_changed_cb service_changed_callback = NULL;
 476                 void* user_data = NULL;
 477                 vc_mgr_client_get_service_state_changed_cb(&service_changed_callback, &user_data);
 478
 479                 if (NULL != service_changed_callback) {
 480                         vc_mgr_client_use_callback();
 481                         service_changed_callback(previous_service_state, service_state, user_data);
 482                         vc_mgr_client_not_use_callback();
 483                         SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called");
 484                 } else {
 485                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
 486                 }
 487
 488                 /* Set foreground */
 489                 vc_mgr_client_set_foreground(foreground, true);
 490
 491                 SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Connected daemon");
 492
 493                 /* Set client state */
 494                 vc_mgr_client_set_client_state(VC_STATE_READY);
 495
 496                 vc_state_changed_cb changed_callback = NULL;
 497                 user_data = NULL;
 498                 vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data);
 499
 500                 vc_state_e current_state;
 501                 vc_state_e previous_state;
 502
 503                 vc_mgr_client_get_previous_state(&current_state, &previous_state);
 504
 505                 if (NULL != changed_callback) {
 506                         vc_mgr_client_use_callback();
 507                         changed_callback(previous_state, current_state, user_data);
 508                         vc_mgr_client_not_use_callback();
 509                         SLOG(LOG_INFO, TAG_VCM, "State changed callback is called");
 510                 } else {
 511                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
 512                 }
 513         } else {
 514                 SLOG(LOG_ERROR, TAG_VCM, "[Not ERROR]  is not valid. It is destroyed."); //LCOV_EXCL_LINE
 515                 g_request_init_timer = NULL;
 516                 return EINA_FALSE;
 517         }
 518
 519         SLOG(LOG_ERROR, TAG_VCM, "@@@");
 520
 521         g_request_init_timer = NULL;
 522         return EINA_FALSE;
 523 }
 524
 525
 526 static Eina_Bool __send_hello_message(void *data)
 527 {
 528         /* Send hello */
 529         if (0 != vc_mgr_tidl_request_hello()) {
 530                 if (g_tidl_send_hello_count == VCM_TIDL_RETRY_COUNT) {
 531                         g_tidl_send_hello_count = 0;
 532                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request hello !! send error to manager");
 533                         __vc_mgr_cb_error(VC_ERROR_TIMED_OUT, -1, "voice_framework.error.vcfw.connect_engine_fail");
 534                         g_send_hello_timer = NULL;
 535                         return EINA_FALSE;
 536                 } else {
 537                         g_tidl_send_hello_count++;
 538                         return EINA_TRUE;
 539                 }
 540         }
 541
 542         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
 543
 544         if (NULL == g_request_init_timer) {
 545                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new idler for preparation");
 546                 g_request_init_timer = ecore_timer_add(0.0, __request_initialize, NULL);
 547         } else {
 548                 SLOG(LOG_INFO, TAG_VCM, "[INFO] idler handle is already created");
 549         }
 550
 551         g_send_hello_timer = NULL;
 552         return EINA_FALSE;
 553 }
 554
 555 int vc_mgr_prepare(void)
 556 {
 557         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Prepare");
 558
 559         int ret;
 560         ret = __check_mgr_feature_privilege();
 561         if (VC_ERROR_NONE != ret)
 562                 return ret;
 563
 564         vc_state_e state;
 565         if (0 != vc_mgr_client_get_client_state(&state)) {
 566                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 567                 return VC_ERROR_INVALID_STATE;
 568         }
 569
 570         /* check state */
 571         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
 572
 573         if (NULL == g_send_hello_timer) {
 574                 g_tidl_send_hello_count = 0;
 575                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Create a new timer for preparation");
 576                 ecore_thread_main_loop_begin();
 577                 g_send_hello_timer = ecore_timer_add(0.1, __send_hello_message, NULL);
 578                 ecore_thread_main_loop_end();
 579         } else {
 580                 SLOG(LOG_INFO, TAG_VCM, "[INFO] timer handle is already created");
 581         }
 582
 583         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Calling Prepare DONE");
 584
 585         return VC_ERROR_NONE;
 586 }
 587
 588 int vc_mgr_unprepare(void)
 589 {
 590         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unprepare");
 591
 592         int ret;
 593         ret = __check_mgr_feature_privilege();
 594         if (VC_ERROR_NONE != ret)
 595                 return ret;
 596
 597         vc_state_e state;
 598         if (0 != vc_mgr_client_get_client_state(&state)) {
 599                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 600                 return VC_ERROR_INVALID_STATE;
 601         }
 602
 603         /* check state */
 604         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 605
 606         __vc_mgr_internal_unprepare();
 607
 608         vc_mgr_client_set_client_state(VC_STATE_INITIALIZED);
 609         ecore_timer_add(0, __vc_mgr_notify_state_changed, NULL);
 610
 611         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Unprepare DONE");
 612
 613         return VC_ERROR_NONE;
 614 }
 615
 616 int vc_mgr_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 617 {
 618         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Foreach Supported Language");
 619
 620         int ret;
 621         ret = __check_mgr_feature_privilege();
 622         if (VC_ERROR_NONE != ret)
 623                 return ret;
 624
 625         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 626
 627         vc_state_e state;
 628         if (0 != vc_mgr_client_get_client_state(&state)) {
 629                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 630                 return VC_ERROR_INVALID_STATE;
 631         }
 632
 633         ret = vc_config_mgr_get_language_list(callback, user_data);
 634         if (0 != ret) {
 635                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 636                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get languages : %s", __vc_mgr_get_error_code(ret));
 637         }
 638
 639         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Foreach Supported Language DONE");
 640
 641         return VC_ERROR_NONE;
 642 }
 643
 644 int vc_mgr_get_current_language(char** language)
 645 {
 646         int ret;
 647         ret = __check_mgr_feature_privilege();
 648         if (VC_ERROR_NONE != ret)
 649                 return ret;
 650
 651         RETVM_IF(NULL == language, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 652
 653         vc_state_e state;
 654         if (0 != vc_mgr_client_get_client_state(&state)) {
 655                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 656                 return VC_ERROR_INVALID_STATE;
 657         }
 658
 659         ret = vc_config_mgr_get_default_language(language);
 660         if (0 != ret) {
 661                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 662                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get current languages : %s", __vc_mgr_get_error_code(ret));
 663         } else {
 664                 SLOG(LOG_ERROR, TAG_VCM, "[Get current language] language : %s", *language);
 665         }
 666
 667         return ret;
 668 }
 669
 670 int vc_mgr_get_state(vc_state_e* state)
 671 {
 672         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get State");
 673
 674         int ret;
 675         ret = __check_mgr_feature_privilege();
 676         if (VC_ERROR_NONE != ret)
 677                 return ret;
 678
 679         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 680
 681         vc_state_e temp;
 682         if (0 != vc_mgr_client_get_client_state(&temp)) {
 683                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 684                 return VC_ERROR_INVALID_STATE;
 685         }
 686
 687         *state = temp;
 688
 689         switch (*state) {
 690         case VC_STATE_NONE:             SLOG(LOG_INFO, TAG_VCM, "Current state is 'None'");             break;
 691         case VC_STATE_INITIALIZED:      SLOG(LOG_INFO, TAG_VCM, "Current state is 'Created'");          break;
 692         case VC_STATE_READY:            SLOG(LOG_INFO, TAG_VCM, "Current state is 'Ready'");            break;
 693         default:                        SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
 694         }
 695
 696         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get State DONE");
 697
 698         return VC_ERROR_NONE;
 699 }
 700
 701 int vc_mgr_get_service_state(vc_service_state_e* state)
 702 {
 703         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get Service State");
 704
 705         int ret;
 706         ret = __check_mgr_feature_privilege();
 707         if (VC_ERROR_NONE != ret)
 708                 return ret;
 709
 710         RETVM_IF(NULL == state, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 711
 712         vc_state_e client_state;
 713         if (0 != vc_mgr_client_get_client_state(&client_state)) {
 714                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 715                 return VC_ERROR_INVALID_STATE;
 716         }
 717
 718         /* check state */
 719         RETVM_IF(client_state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Current state is not 'READY'");
 720
 721         /* get service state */
 722         vc_service_state_e service_state;
 723         if (0 != vc_mgr_client_get_service_state(&service_state)) {
 724                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state");
 725                 return VC_ERROR_OPERATION_FAILED;
 726         }
 727
 728         *state = service_state;
 729
 730         switch (*state) {
 731         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'");            break;
 732         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'");           break;
 733         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'");       break;
 734         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Processing'");      break;
 735         default:                                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");
 736         }
 737
 738         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get Service State DONE");
 739
 740         return VC_ERROR_NONE;
 741 }
 742
 743 int vc_mgr_set_demandable_client_rule(const char* rule)
 744 {
 745         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s)", rule);
 746
 747         int ret;
 748         ret = __check_mgr_feature_privilege();
 749         if (VC_ERROR_NONE != ret)
 750                 return ret;
 751
 752         vc_state_e state;
 753         if (0 != vc_mgr_client_get_client_state(&state)) {
 754                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 755                 return VC_ERROR_INVALID_STATE;
 756         }
 757
 758         /* check state */
 759         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 760
 761         ret = vc_info_parser_set_demandable_client(rule);
 762         if (0 != ret) {
 763                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] rule is NOT valid");
 764                 SLOG(LOG_DEBUG, TAG_VCM, "@@@");
 765                 return VC_ERROR_INVALID_PARAMETER;
 766         }
 767
 768         if (0 != vc_info_parser_get_demandable_clients(&g_demandable_client_list)) {
 769                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get demandable clients");
 770                 return VC_ERROR_OPERATION_FAILED;
 771         }
 772
 773         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set Demandable client rule(%s) DONE", rule);
 774
 775         return VC_ERROR_NONE;
 776 }
 777
 778 int vc_mgr_unset_demandable_client_rule(void)
 779 {
 780         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Unset Demandable client");
 781
 782         int ret;
 783         ret = __check_mgr_feature_privilege();
 784         if (VC_ERROR_NONE != ret)
 785                 return ret;
 786
 787         vc_info_parser_set_demandable_client(NULL);
 788
 789         ret = vc_mgr_tidl_request_demandable_client(g_pid);
 790         if (0 != ret) {
 791                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset client rule to daemon : %s", __vc_mgr_get_error_code(ret));
 792         }
 793
 794         // TODO: check return value correct or not
 795         return VC_ERROR_NONE;
 796 }
 797
 798 int vc_mgr_is_command_format_supported(int format, bool* support)
 799 {
 800         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Is command type supported");
 801
 802         int ret;
 803         ret = __check_mgr_feature_privilege();
 804         if (VC_ERROR_NONE != ret)
 805                 return ret;
 806
 807         RETVM_IF(NULL == support, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 808
 809         vc_state_e state;
 810         if (0 != vc_mgr_client_get_client_state(&state)) {
 811                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 812                 return VC_ERROR_INVALID_STATE;
 813         }
 814
 815         /* check support */
 816         bool non_fixed_support = false;
 817         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 818                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get nonfixed support info");
 819         }
 820
 821         switch (format) {
 822         case VC_CMD_FORMAT_FIXED:               *support = true;                break;
 823         case VC_CMD_FORMAT_FIXED_AND_VFIXED:    *support = true;                break;
 824         case VC_CMD_FORMAT_VFIXED_AND_FIXED:    *support = true;                break;
 825         case VC_CMD_FORMAT_FIXED_AND_NONFIXED:  *support = non_fixed_support;   break;
 826         case VC_CMD_FORMAT_NONFIXED_AND_FIXED:  *support = non_fixed_support;   break;
 827         default:                                *support = false;               break;
 828         }
 829
 830         SLOG(LOG_ERROR, TAG_VCM, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 831
 832         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Is command type supported DONE");
 833
 834         return VC_ERROR_NONE;
 835 }
 836
 837 int vc_mgr_enable_command_type(int cmd_type)
 838 {
 839         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Enable Command Type, cmd_type(%d)", cmd_type);
 840
 841         int ret;
 842         ret = __check_mgr_feature_privilege();
 843         if (VC_ERROR_NONE != ret)
 844                 return ret;
 845
 846         if (VC_COMMAND_TYPE_FOREGROUND > cmd_type || VC_COMMAND_TYPE_EXCLUSIVE < cmd_type) {
 847                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cmd_type is not valid. (%d)", cmd_type);
 848                 return VC_ERROR_INVALID_PARAMETER;
 849         }
 850
 851         vc_state_e state;
 852         if (0 != vc_mgr_client_get_client_state(&state)) {
 853                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 854                 return VC_ERROR_INVALID_STATE;
 855         }
 856
 857         /* check state */
 858         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 859
 860         /* Check service state */
 861         vc_service_state_e service_state = -1;
 862         vc_mgr_client_get_service_state(&service_state);
 863         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);
 864
 865         ret = vc_mgr_client_enable_command_type((vc_cmd_type_e)cmd_type);               // enable the cmd type
 866         if (0 != ret) {
 867                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to enable the command type(%d). ret(%d)", cmd_type, ret);
 868         } else {
 869                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to enable the command type(%d)", cmd_type);
 870         }
 871
 872         SLOG(LOG_ERROR, TAG_VCM, "@@@  [Manager] Enable Command Type DONE, ret(%d)", ret);
 873
 874         return ret;
 875 }
 876
 877 int vc_mgr_disable_command_type(int cmd_type)
 878 {
 879         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Disable Command Type, cmd_type(%d)", cmd_type);
 880
 881         int ret;
 882         ret = __check_mgr_feature_privilege();
 883         if (VC_ERROR_NONE != ret)
 884                 return ret;
 885
 886         if (VC_COMMAND_TYPE_FOREGROUND > cmd_type || VC_COMMAND_TYPE_EXCLUSIVE < cmd_type) {
 887                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] cmd type is not valid, (%d)", cmd_type);
 888                 return VC_ERROR_INVALID_PARAMETER;
 889         }
 890
 891         vc_state_e state;
 892         if (0 != vc_mgr_client_get_client_state(&state)) {
 893                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 894                 return VC_ERROR_INVALID_STATE;
 895         }
 896
 897         /* check state */
 898         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
 899
 900         /* Check service state */
 901         vc_service_state_e service_state = -1;
 902         vc_mgr_client_get_service_state(&service_state);
 903         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);
 904
 905         ret = vc_mgr_client_disable_command_type((vc_cmd_type_e)cmd_type);              // enable the cmd type
 906         if (0 != ret) {
 907                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to disable the command type(%d). ret(%d)", cmd_type, ret);
 908         } else {
 909                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to disable the command type(%d)", cmd_type);
 910         }
 911
 912         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Disable Command Type DONE, ret(%d)", ret);
 913
 914         return ret;
 915 }
 916
 917 int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
 918 {
 919         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list");
 920
 921         int ret;
 922         ret = __check_mgr_feature_privilege();
 923         if (VC_ERROR_NONE != ret)
 924                 return ret;
 925
 926         vc_state_e state;
 927         if (0 != vc_mgr_client_get_client_state(&state)) {
 928                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 929                 return VC_ERROR_INVALID_STATE;
 930         }
 931
 932         /* check state */
 933         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 934
 935         /* Check service state */
 936         vc_service_state_e service_state = -1;
 937         vc_mgr_client_get_service_state(&service_state);
 938         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);
 939
 940         RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input parameter is NULL");
 941
 942         vc_cmd_list_s* list = NULL;
 943         list = (vc_cmd_list_s*)vc_cmd_list;
 944         SLOG(LOG_INFO, TAG_VCM, "[List] (%p) (%p)", list, list->list);
 945
 946         RETVM_IF(NULL == list->list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Input command list");
 947
 948         int i;
 949         bool success_save = false;
 950         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
 951                 ret = vc_cmd_parser_delete_file(getpid(), i);
 952                 if (0 != ret)
 953                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
 954
 955                 ret = vc_cmd_parser_save_file(getpid(), i, list->list, NULL);
 956                 if (0 != ret) {
 957                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save file, type(%d), ret(%d)", i, ret);
 958                 } else {
 959                         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Save file, type(%d)", i);
 960                         success_save = true;
 961                 }
 962         }
 963
 964         if (true != success_save) {
 965                 ret = VC_ERROR_INVALID_PARAMETER;
 966                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret));
 967         } else {
 968                 ret = vc_mgr_tidl_request_set_command(g_pid);
 969                 if (0 != ret) {
 970                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
 971                 }
 972         }
 973
 974         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list DONE, ret(%d)", ret);
 975
 976         return ret;
 977 }
 978
 979 int vc_mgr_unset_command_list(void)
 980 {
 981         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unset Command list");
 982
 983         int ret;
 984         ret = __check_mgr_feature_privilege();
 985         if (VC_ERROR_NONE != ret)
 986                 return ret;
 987
 988         vc_state_e state;
 989         if (0 != vc_mgr_client_get_client_state(&state)) {
 990                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 991                 return VC_ERROR_INVALID_STATE;
 992         }
 993
 994         /* check state */
 995         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
 996
 997         ret = vc_mgr_tidl_request_unset_command(g_pid);
 998         if (0 != ret) {
 999                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret));
1000         }
1001
1002         int i;
1003         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
1004                 ret = vc_cmd_parser_delete_file(getpid(), i);
1005                 if (0 != ret)
1006                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
1007         }
1008
1009         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Unset Command list DONE");
1010
1011         // TODO: check return value correct or not
1012         return VC_ERROR_NONE;
1013 }
1014
1015 int vc_mgr_set_command_list_from_file(const char* file_path, int type)
1016 {
1017         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list from file, type(%d)", type);
1018
1019         int ret;
1020         ret = __check_mgr_feature_privilege();
1021         if (VC_ERROR_NONE != ret)
1022                 return ret;
1023
1024         RETVM_IF(NULL == file_path, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1025         SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
1026
1027         /* check type */
1028         if (VC_COMMAND_TYPE_FOREGROUND > type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
1029                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid command type: input type is %d", type);
1030                 return VC_ERROR_INVALID_PARAMETER;
1031         }
1032
1033         vc_state_e state;
1034         if (0 != vc_mgr_client_get_client_state(&state)) {
1035                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1036                 return VC_ERROR_INVALID_STATE;
1037         }
1038
1039         /* check state */
1040         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1041
1042         /* Check service state */
1043         vc_service_state_e service_state = -1;
1044         vc_mgr_client_get_service_state(&service_state);
1045         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);
1046
1047         ret = vc_cmd_parser_delete_file(getpid(), type);
1048         if (0 != ret)
1049                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(4), ret(%d)", ret);
1050
1051         if (0 != vc_json_set_commands_from_file(file_path, type, NULL)) {
1052                 ret = VC_ERROR_INVALID_PARAMETER;
1053                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command list (%d)", ret);
1054         } else {
1055                 ret = vc_mgr_tidl_request_set_command(g_pid);
1056                 if (0 != ret) {
1057                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
1058                 }
1059         }
1060
1061         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set Command list from file DONE, ret(%d)", ret);
1062
1063         return ret;
1064 }
1065
1066 int vc_mgr_set_preloaded_commands_from_file(const char* file_path)
1067 {
1068         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set preloaded command list");
1069
1070         int ret;
1071         ret = __check_mgr_feature_privilege();
1072         if (VC_ERROR_NONE != ret)
1073                 return ret;
1074
1075         RETVM_IF(NULL == file_path, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1076         SLOG(LOG_INFO, TAG_VCM, "@@@ File path: %s", file_path);
1077
1078         vc_state_e state;
1079         if (0 != vc_mgr_client_get_client_state(&state)) {
1080                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1081                 return VC_ERROR_INVALID_STATE;
1082         }
1083
1084         /* check state */
1085         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1086
1087         /* Check service state */
1088         vc_service_state_e service_state = -1;
1089         vc_mgr_client_get_service_state(&service_state);
1090         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);
1091
1092         /* Only support to set background commands for preloaded application */
1093         ret = vc_json_set_commands_from_file(file_path, VC_COMMAND_TYPE_BACKGROUND, NULL);
1094         if (0 != ret)
1095                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to insert preloaded commands into db");
1096
1097         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set preloaded command list DONE, ret(%d)", ret);
1098         return ret;
1099 }
1100
1101 int vc_mgr_set_audio_type(const char* audio_id)
1102 {
1103         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set audio type, audio_id(%s)", audio_id);
1104
1105         int ret;
1106         ret = __check_mgr_feature_privilege();
1107         if (VC_ERROR_NONE != ret)
1108                 return ret;
1109
1110         if (NULL == audio_id || !strncmp(audio_id, "", strlen(audio_id))) {
1111                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1112                 return VC_ERROR_INVALID_PARAMETER;
1113         }
1114
1115         vc_state_e state;
1116         if (0 != vc_mgr_client_get_client_state(&state)) {
1117                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1118                 return VC_ERROR_INVALID_STATE;
1119         }
1120
1121         /* check state */
1122         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1123
1124         /* Check service state */
1125         vc_service_state_e service_state = -1;
1126         vc_mgr_client_get_service_state(&service_state);
1127         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);
1128
1129         /* Request */
1130         ret = vc_mgr_tidl_request_set_audio_type(g_pid, audio_id);
1131         if (0 != ret) {
1132                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret));
1133         } else {
1134                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set audio type");
1135                 /* Save */
1136                 vc_mgr_client_set_audio_type(audio_id);
1137         }
1138
1139         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Set audio type DONE, ret(%d)", ret);
1140
1141         return ret;
1142 }
1143
1144 int vc_mgr_get_audio_type(char** audio_id)
1145 {
1146         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Get audio type");
1147
1148         int ret;
1149         ret = __check_mgr_feature_privilege();
1150         if (VC_ERROR_NONE != ret)
1151                 return ret;
1152
1153         RETVM_IF(NULL == audio_id, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1154
1155         vc_state_e state;
1156         if (0 != vc_mgr_client_get_client_state(&state)) {
1157                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1158                 return VC_ERROR_INVALID_STATE;
1159         }
1160
1161         /* check state */
1162         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1163
1164         /* Check service state */
1165         vc_service_state_e service_state = -1;
1166         vc_mgr_client_get_service_state(&service_state);
1167         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);
1168
1169         char* temp = NULL;
1170
1171         vc_mgr_client_get_audio_type(&temp);
1172
1173         if (NULL == temp) {
1174                 /* Not initiallized */
1175                 ret = -1;
1176                 while (0 != ret) {
1177                         ret = vc_mgr_tidl_request_get_audio_type(g_pid, &temp);
1178                         if (0 != ret) {
1179                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret));
1180                         } else {
1181                                 SLOG(LOG_ERROR, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
1182                                 /* Save */
1183                                 vc_mgr_client_set_audio_type(temp);
1184                         }
1185                 }
1186         }
1187
1188         if (NULL != temp) {
1189                 *audio_id = strdup(temp);
1190                 free(temp);
1191                 temp = NULL;
1192         }
1193
1194         // TODO: check return value correct or not
1195         return VC_ERROR_NONE;
1196 }
1197
1198 int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
1199 {
1200         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Foreach current commands");
1201
1202         int ret;
1203         ret = __check_mgr_feature_privilege();
1204         if (VC_ERROR_NONE != ret)
1205                 return ret;
1206
1207         vc_state_e state;
1208         if (0 != vc_mgr_client_get_client_state(&state)) {
1209                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1210                 return VC_ERROR_INVALID_STATE;
1211         }
1212
1213         /* check state */
1214         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1215
1216         /* Check service state */
1217         vc_service_state_e service_state = -1;
1218         vc_mgr_client_get_service_state(&service_state);
1219         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);
1220
1221         RETVM_IF(NULL == vc_cmd_list, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid Parameter");
1222
1223         vc_cmd_list_h temp_list = NULL;
1224         if (0 != vc_cmd_list_create(&temp_list)) {
1225                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
1226                 return VC_ERROR_INVALID_PARAMETER;
1227         }
1228
1229         *vc_cmd_list = temp_list;
1230
1231         int fg_pid = 0;
1232         int mgr_pid = 0;
1233
1234         /* Get foreground pid */
1235         if (0 != vc_mgr_client_get_foreground(&fg_pid)) {
1236                 /* There is no foreground app for voice control */
1237                 SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
1238         } else {
1239                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
1240         }
1241
1242         if (0 != vc_mgr_client_get_pid(&mgr_pid)) {
1243                 SLOG(LOG_ERROR, TAG_VCM, "[Manager] Fail to get manager pid");
1244                 return VC_ERROR_OPERATION_FAILED;
1245         } else {
1246                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
1247         }
1248
1249         /* Get system command */
1250         ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
1251         if (0 != ret) {
1252                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No system commands");
1253         }
1254
1255         /* Request */
1256         ret = vc_mgr_tidl_request_set_client_info(g_pid);
1257         if (0 != ret) {
1258                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret));
1259         } else {
1260                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set client info");
1261         }
1262
1263         GSList *iter = NULL;
1264         GSList* client_info_list = NULL;
1265         vc_client_info_s *client_info = NULL;
1266         bool is_fgpid = false;
1267
1268         if (0 != vc_info_parser_get_client_info(&client_info_list)) {
1269                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No client");
1270                 return VC_ERROR_NONE;
1271         }
1272
1273         if (VC_NO_FOREGROUND_PID != fg_pid) {
1274                 iter = g_slist_nth(client_info_list, 0);
1275                 while (NULL != iter) {
1276                         client_info = iter->data;
1277                         if (NULL != client_info) {
1278                                 if (fg_pid == client_info->pid) {
1279                                         is_fgpid = true;
1280                                         break;
1281                                 }
1282                         }
1283                         iter = g_slist_next(iter);
1284                 }
1285         }
1286
1287         /* Get foreground commands and widget */
1288         if (true == is_fgpid) {
1289                 /* Get handle */
1290                 SLOG(LOG_INFO, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
1291
1292                 /* Get foreground command */
1293                 if (true == client_info->fg_cmd) {
1294                         ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
1295                         if (0 != ret) {
1296                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
1297                         }
1298                 } else {
1299                         SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground commands");
1300                 }
1301
1302                 /* Check exclusive option */
1303                 if (true == client_info->exclusive_cmd) {
1304                         SLOG(LOG_INFO, TAG_VCM, "[Manager] Exclusive command is ON");
1305
1306                         /* Set background command for exclusive option */
1307                         if (true == client_info->bg_cmd) {
1308                                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Set background command");
1309                                 ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1310                                 if (0 != ret) {
1311                                         SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1312                                 }
1313                         }
1314
1315                         /* need to release client info */
1316                         iter = g_slist_nth(client_info_list, 0);
1317
1318                         while (NULL != iter) {
1319                                 client_info = iter->data;
1320                                 if (NULL != client_info) {
1321                                         free(client_info);
1322                                 }
1323                                 client_info_list = g_slist_remove_link(client_info_list, iter);
1324                                 iter = g_slist_nth(client_info_list, 0);
1325                         }
1326
1327                         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Foreach current commands DONE");
1328
1329                         return VC_ERROR_NONE;
1330                 }
1331         } else {
1332                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No foreground app");
1333         }
1334
1335         /* Get background commands */
1336         if (0 < g_slist_length(client_info_list)) {
1337                 iter = g_slist_nth(client_info_list, 0);
1338
1339                 while (NULL != iter) {
1340                         client_info = iter->data;
1341
1342                         if (NULL != client_info) {
1343                                 SLOG(LOG_INFO, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
1344                                 if (true == client_info->bg_cmd) {
1345                                         ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1346                                         if (0 != ret) {
1347                                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1348                                         }
1349                                 }
1350                                 free(client_info);
1351                         }
1352                         client_info_list = g_slist_remove_link(client_info_list, iter);
1353
1354                         iter = g_slist_nth(client_info_list, 0);
1355                 }
1356         } else {
1357                 /* NO client */
1358                 SLOG(LOG_INFO, TAG_VCM, "[Manager] No background commands");
1359         }
1360
1361         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Foreach current commands DONE");
1362
1363         // TODO: check return value correct or not
1364         return VC_ERROR_NONE;
1365 }
1366
1367 int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
1368 {
1369         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set recognition mode = %d", mode);
1370
1371         int ret;
1372         ret = __check_mgr_feature_privilege();
1373         if (VC_ERROR_NONE != ret)
1374                 return ret;
1375
1376         /* check vc recognition mode */
1377         if (mode < VC_RECOGNITION_MODE_STOP_BY_SILENCE || mode > VC_RECOGNITION_MODE_MANUAL) {
1378                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] invalid parameter: 'mode' is not supported mode (%d)", mode);
1379                 return VC_ERROR_INVALID_PARAMETER;
1380         }
1381
1382         vc_state_e state;
1383         if (0 != vc_mgr_client_get_client_state(&state)) {
1384                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1385                 return VC_ERROR_INVALID_STATE;
1386         }
1387
1388         /* check state */
1389         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1390
1391         /* Check service state */
1392         vc_service_state_e service_state = -1;
1393         vc_mgr_client_get_service_state(&service_state);
1394         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);
1395
1396         vc_mgr_client_set_recognition_mode(mode);
1397         return VC_ERROR_NONE;
1398 }
1399
1400 int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
1401 {
1402         int ret;
1403         ret = __check_mgr_feature_privilege();
1404         if (VC_ERROR_NONE != ret)
1405                 return ret;
1406
1407         RETVM_IF(NULL == mode, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter, mode is NULL ptr");
1408
1409         vc_state_e state;
1410         if (0 != vc_mgr_client_get_client_state(&state)) {
1411                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1412                 return VC_ERROR_INVALID_STATE;
1413         }
1414
1415         ret = vc_mgr_client_get_recognition_mode(mode);
1416         if (0 != ret) {
1417                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1418                 return ret;
1419         }
1420
1421         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Get recognition mode = %d", *mode);
1422         return VC_ERROR_NONE;
1423 }
1424
1425 int vc_mgr_set_private_data(const char* key, const char* data)
1426 {
1427         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Set private data");
1428
1429         int ret;
1430         ret = __check_mgr_feature_privilege();
1431         if (VC_ERROR_NONE != ret)
1432                 return ret;
1433
1434         RETVM_IF(NULL == key, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1435
1436         vc_state_e state;
1437         if (0 != vc_mgr_client_get_client_state(&state)) {
1438                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1439                 return VC_ERROR_INVALID_STATE;
1440         }
1441
1442         /* check state */
1443         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1444
1445         /* Check service state */
1446         vc_service_state_e service_state = -1;
1447         vc_mgr_client_get_service_state(&service_state);
1448         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);
1449
1450         ret = vc_mgr_tidl_request_set_private_data(g_pid, key, data);
1451         if (0 != ret) {
1452                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set private data : %s", __vc_mgr_get_error_code(ret));
1453                 return ret;
1454         } else {
1455                 SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set private data");
1456         }
1457
1458         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set private data DONE");
1459
1460         return VC_ERROR_NONE;
1461 }
1462
1463 int vc_mgr_get_private_data(const char* key, char** data)
1464 {
1465         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get private data");
1466
1467         int ret;
1468         ret = __check_mgr_feature_privilege();
1469         if (VC_ERROR_NONE != ret)
1470                 return ret;
1471
1472         if (NULL == key || NULL == data) {
1473                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1474                 return VC_ERROR_INVALID_PARAMETER;
1475         }
1476
1477         vc_state_e state;
1478         if (0 != vc_mgr_client_get_client_state(&state)) {
1479                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1480                 return VC_ERROR_INVALID_STATE;
1481         }
1482
1483         /* check state */
1484         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1485
1486         /* Check service state */
1487         vc_service_state_e service_state = -1;
1488         vc_mgr_client_get_service_state(&service_state);
1489         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);
1490
1491         char* temp = NULL;
1492         ret = vc_mgr_tidl_request_get_private_data(g_pid, key, &temp);
1493         if (0 != ret) {
1494                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret));
1495         } else {
1496                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
1497         }
1498
1499         if (NULL != temp) {
1500                 *data = strdup(temp);
1501                 free(temp);
1502                 temp = NULL;
1503         }
1504
1505         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get private data DONE");
1506
1507         // TODO: check return value correct or not
1508         return VC_ERROR_NONE;
1509 }
1510
1511 int vc_mgr_set_domain(const char* domain)
1512 {
1513         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set domain");
1514
1515         int ret;
1516         ret = __check_mgr_feature_privilege();
1517         if (VC_ERROR_NONE != ret)
1518                 return ret;
1519
1520         RETVM_IF(NULL == domain, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1521
1522         vc_state_e state;
1523         if (0 != vc_mgr_client_get_client_state(&state)) {
1524                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1525                 return VC_ERROR_INVALID_STATE;
1526         }
1527
1528         /* check state */
1529         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1530
1531         /* Check service state */
1532         vc_service_state_e service_state = -1;
1533         vc_mgr_client_get_service_state(&service_state);
1534         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);
1535
1536         ret = vc_mgr_tidl_request_set_domain(g_pid, domain);
1537         if (0 != ret) {
1538                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret));
1539         } else {
1540                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set domain");
1541         }
1542
1543         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Set domain DONE");
1544
1545         return VC_ERROR_NONE;
1546 }
1547
1548 int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
1549 {
1550         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] do action");
1551
1552         int ret;
1553         ret = __check_mgr_feature_privilege();
1554         if (VC_ERROR_NONE != ret)
1555                 return ret;
1556
1557         if (type < VC_SEND_EVENT_TYPE_TEXT || VC_SEND_EVENT_TYPE_HAPTIC_EVENT < type) {
1558                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] send event type is not valid, (%d)", type);
1559                 return VC_ERROR_INVALID_PARAMETER;
1560         }
1561
1562         RETVM_IF(NULL == send_event, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1563
1564         vc_state_e state;
1565         if (0 != vc_mgr_client_get_client_state(&state)) {
1566                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1567                 return VC_ERROR_INVALID_STATE;
1568         }
1569
1570         /* check state */
1571         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1572
1573         /* Check service state */
1574         vc_service_state_e service_state = -1;
1575         vc_mgr_client_get_service_state(&service_state);
1576         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);
1577
1578         ret = vc_mgr_tidl_request_do_action(g_pid, type, send_event);
1579         if (0 != ret) {
1580                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
1581                 return ret;
1582         } else {
1583                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] do action");
1584         }
1585         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] do action DONE");
1586
1587         return VC_ERROR_NONE;
1588 }
1589
1590 int vc_mgr_send_specific_engine_request(const char* engine_app_id, const char* event, const char* request)
1591 {
1592         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send specific engine request");
1593
1594         int ret;
1595         ret = __check_mgr_feature_privilege();
1596         if (VC_ERROR_NONE != ret)
1597                 return ret;
1598
1599         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] specific engine request. engine app id(%s), event(%s), request(%s)", engine_app_id, event, request);
1600
1601         if (NULL == engine_app_id || NULL == event) {
1602                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1603                 return VC_ERROR_INVALID_PARAMETER;
1604         }
1605
1606         if (NULL == request) {
1607                 SLOG(LOG_ERROR, TAG_VCM, "[INFO] Input parameter is NULL. (no request)");
1608         }
1609
1610         vc_state_e state;
1611         if (0 != vc_mgr_client_get_client_state(&state)) {
1612                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1613                 return VC_ERROR_INVALID_STATE;
1614         }
1615
1616         /* check state */
1617         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1618
1619         /* Check service state */
1620         vc_service_state_e service_state = -1;
1621         vc_mgr_client_get_service_state(&service_state);
1622         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);
1623
1624         ret = vc_mgr_tidl_send_specific_engine_request(g_pid, engine_app_id, event, request);
1625         if (0 != ret) {
1626                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to specific engine request : %s", __vc_mgr_get_error_code(ret));
1627                 return ret;
1628         } else {
1629                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] specific engine request");
1630         }
1631         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send specific engine request DONE");
1632
1633         return VC_ERROR_NONE;
1634 }
1635
1636 int vc_mgr_start(bool exclusive_command_option)
1637 {
1638         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request start");
1639
1640         int ret;
1641         ret = __check_mgr_feature_privilege();
1642         if (VC_ERROR_NONE != ret)
1643                 return ret;
1644
1645         vc_state_e state;
1646         if (0 != vc_mgr_client_get_client_state(&state)) {
1647                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1648                 return VC_ERROR_INVALID_STATE;
1649         }
1650
1651         /* check state */
1652         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1653
1654         /* Check service state */
1655         vc_service_state_e service_state = -1;
1656         vc_mgr_client_get_service_state(&service_state);
1657         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);
1658
1659         /* Check internal state for async */
1660         vc_internal_state_e internal_state = -1;
1661         vc_mgr_client_get_internal_state(&internal_state);
1662         if (internal_state != VC_INTERNAL_STATE_NONE) {
1663                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is NOT none : %d", internal_state);
1664                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1665         }
1666
1667         vc_mgr_client_set_exclusive_command(exclusive_command_option);
1668
1669         bool start_by_client = false;
1670         if (0 != vc_mgr_client_get_start_by_client(&start_by_client)) {
1671                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
1672         }
1673
1674         int disabled_cmd_type = 0;
1675         if (0 != vc_mgr_client_get_disabled_command_type(&disabled_cmd_type)) {
1676                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get disabled command type");
1677         }
1678
1679         vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
1680         if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
1681                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1682         }
1683
1684         /* Request */
1685         ret = -1;
1686         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STARTING);
1687         ret = vc_mgr_tidl_request_start(g_pid, (int)recognition_mode, exclusive_command_option, start_by_client, disabled_cmd_type);
1688         if (0 != ret) {
1689                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
1690                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1691         } else {
1692                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] start recognition");
1693         }
1694
1695         g_volume_db = 0;
1696         g_prev_volume_db = 0;
1697         g_cur_volume_db = 0;
1698
1699         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request start DONE, ret(%d)", ret);
1700
1701         return ret;
1702 }
1703
1704 int vc_mgr_stop(void)
1705 {
1706         SLOG(LOG_ERROR, TAG_VCM, "@@@ [Manager] Request stop");
1707
1708         int ret;
1709         ret = __check_mgr_feature_privilege();
1710         if (VC_ERROR_NONE != ret)
1711                 return ret;
1712
1713         vc_state_e state;
1714         if (0 != vc_mgr_client_get_client_state(&state)) {
1715                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1716                 return VC_ERROR_INVALID_STATE;
1717         }
1718
1719         /* check state */
1720         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1721
1722         /* Check service state */
1723         vc_service_state_e service_state = -1;
1724         vc_mgr_client_get_service_state(&service_state);
1725         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);
1726
1727         /* Check internal state for async */
1728         vc_internal_state_e internal_state = -1;
1729         vc_mgr_client_get_internal_state(&internal_state);
1730         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1731                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1732                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1733         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1734                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1735                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1736         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1737                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1738                 return VC_ERROR_IN_PROGRESS_TO_READY;
1739         }
1740
1741         ret = -1;
1742         /* do request */
1743         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_STOPPING);
1744         ret = vc_mgr_tidl_request_stop(g_pid);
1745         if (0 != ret) {
1746                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
1747                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1748         } else {
1749                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Stop recognition");
1750         }
1751
1752         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request stop DONE");
1753
1754         return ret;
1755 }
1756
1757 int vc_mgr_cancel(void)
1758 {
1759         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request cancel");
1760
1761         int ret;
1762         ret = __check_mgr_feature_privilege();
1763         if (VC_ERROR_NONE != ret)
1764                 return ret;
1765
1766         vc_state_e state;
1767         if (0 != vc_mgr_client_get_client_state(&state)) {
1768                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1769                 return VC_ERROR_INVALID_STATE;
1770         }
1771
1772         /* check state */
1773         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'READY'", state);
1774
1775         /* Check service state */
1776         vc_service_state_e service_state = -1;
1777         vc_mgr_client_get_service_state(&service_state);
1778         RETVM_IF(service_state == VC_SERVICE_STATE_NONE, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state is NONE");
1779
1780         vc_internal_state_e internal_state = -1;
1781         vc_mgr_client_get_internal_state(&internal_state);
1782         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1783                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1784                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1785         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1786                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1787                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1788         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1789                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1790                 return VC_ERROR_IN_PROGRESS_TO_READY;
1791         }
1792
1793         ret = -1;
1794         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_CANCELING);
1795         ret = vc_mgr_tidl_request_cancel(g_pid);
1796         if (0 != ret) {
1797                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret));
1798                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
1799         } else {
1800                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel recognition");
1801         }
1802
1803         vc_mgr_client_set_exclusive_command(false);
1804
1805         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Request cancel DONE");
1806
1807         return ret;
1808 }
1809
1810 static int g_cnt = 0;
1811 static Eina_Bool __vc_mgr_set_volume_timer_cb(void* data)
1812 {
1813         g_cnt++;
1814         g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5 * g_cnt;
1815
1816         SLOG(LOG_INFO, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
1817
1818         if (0 == g_cnt % 5) {
1819                 return EINA_FALSE;
1820         }
1821         return EINA_TRUE;
1822 }
1823
1824 int __vc_mgr_cb_set_volume(float volume)
1825 {
1826         // called in vc_mgr_tidl
1827         g_prev_volume_db = g_volume_db;
1828         g_cur_volume_db = volume;
1829
1830         g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5;
1831
1832         if (NULL != g_m_set_volume_timer) {
1833                 ecore_timer_del(g_m_set_volume_timer);
1834         }
1835
1836         g_cnt = 1;
1837         g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_set_volume_timer_cb, NULL);
1838
1839         return VC_ERROR_NONE;
1840 }
1841
1842 int __vc_mgr_set_volume(float volume)
1843 {
1844         // called by app directly
1845         g_volume_db = volume;
1846
1847         return VC_ERROR_NONE;
1848 }
1849
1850 int vc_mgr_get_recording_volume(float* volume)
1851 {
1852         int ret;
1853         ret = __check_mgr_feature_privilege();
1854         if (VC_ERROR_NONE != ret)
1855                 return ret;
1856
1857         RETVM_IF(NULL == volume, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
1858
1859         vc_service_state_e service_state = -1;
1860         if (0 != vc_mgr_client_get_service_state(&service_state)) {
1861                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1862                 return VC_ERROR_INVALID_STATE;
1863         }
1864
1865         /* check state */
1866         RETVM_IF(VC_SERVICE_STATE_RECORDING != service_state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Service state is not 'RECORDING'");
1867
1868         *volume = g_volume_db;
1869
1870         return VC_ERROR_NONE;
1871 }
1872
1873 int __vc_mgr_cb_set_foreground(int pid, bool value)
1874 {
1875         vc_mgr_client_set_foreground(pid, value);
1876
1877         /* get authorized valid app */
1878         int tmp_pid;
1879         if (0 != vc_mgr_client_get_valid_authorized_client(&tmp_pid)) {
1880                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
1881                 return VC_ERROR_INVALID_PARAMETER;
1882         }
1883
1884         if (true == value) {
1885                 /* compare & set valid */
1886                 if (tmp_pid != pid) {
1887                         SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1888
1889                         /* set authorized valid */
1890                         if (true == vc_mgr_client_is_authorized_client(pid)) {
1891                                 SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid);
1892                                 vc_mgr_client_set_valid_authorized_client(pid);
1893                         } else {
1894                                 SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
1895                                 vc_mgr_client_set_valid_authorized_client(-1);
1896                         }
1897                 }
1898         } else {
1899                 if (tmp_pid == pid) {
1900                         SLOG(LOG_INFO, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1901                         vc_mgr_client_set_valid_authorized_client(-1);
1902                 }
1903         }
1904
1905         return VC_ERROR_NONE;
1906 }
1907
1908 int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
1909 {
1910         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Select result");
1911
1912         int ret;
1913         ret = __check_mgr_feature_privilege();
1914         if (VC_ERROR_NONE != ret)
1915                 return ret;
1916
1917         /* Do not check state for 'restart continuously' mode */
1918
1919         vc_service_state_e service_state = -1;
1920         vc_mgr_client_get_service_state(&service_state);
1921         if (service_state != VC_SERVICE_STATE_PROCESSING) {
1922                 vc_recognition_mode_e recognition_mode;
1923                 vc_mgr_get_recognition_mode(&recognition_mode);
1924
1925                 if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
1926                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continuously'");
1927                         return VC_ERROR_INVALID_STATE;
1928                 }
1929         }
1930
1931         if (NULL != vc_cmd_list) {
1932                 int event = 0;
1933                 char* result_text = NULL;
1934
1935                 vc_mgr_client_get_all_result(&event, &result_text);
1936
1937                 vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false);
1938
1939                 if (NULL != result_text) {
1940                         free(result_text);
1941                         result_text = NULL;
1942                 }
1943         }
1944
1945         /* Request */
1946         ret = vc_mgr_tidl_send_result_selection(g_pid);
1947         if (0 != ret) {
1948                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret));
1949                 return ret;
1950         } else {
1951                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] result selection");
1952         }
1953
1954         vc_mgr_client_unset_all_result();
1955
1956         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Select result DONE");
1957
1958         return VC_ERROR_NONE;
1959 }
1960
1961 static Eina_Bool __vc_mgr_set_select_result(void *data)
1962 {
1963         vc_mgr_set_selected_results(NULL);
1964         return EINA_FALSE;
1965 }
1966
1967 static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
1968 {
1969         char* temp_text = NULL;
1970         int event;
1971         char* temp_message = NULL;
1972         vc_cmd_list_h vc_cmd_list = NULL;
1973
1974         vc_mgr_all_result_cb all_callback = NULL;
1975         void* all_user_data = NULL;
1976
1977         vc_mgr_client_get_all_result_cb(&all_callback, &all_user_data);
1978         RETM_IF(NULL == all_callback, TAG_VCM, "[ERROR] All result callback is NULL");
1979
1980         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1981                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
1982                 return;
1983         }
1984
1985         vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command());
1986
1987         SECURE_SLOG(LOG_INFO, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
1988                 result_type, temp_text, event, temp_message);
1989
1990         vc_cmd_print_list(vc_cmd_list);
1991
1992         bool cb_ret = false;
1993
1994         vc_mgr_client_set_all_result(event, temp_text);
1995
1996         vc_mgr_client_use_callback();
1997         cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data);
1998         vc_mgr_client_not_use_callback();
1999
2000         if (true == vc_mgr_client_get_exclusive_command()) {
2001                 /* exclusive */
2002                 vc_result_cb callback = NULL;
2003                 void* user_data = NULL;
2004
2005                 vc_mgr_client_get_result_cb(&callback, &user_data);
2006                 RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client result callback is NULL");
2007
2008                 vc_mgr_client_use_callback();
2009                 callback(event, vc_cmd_list, temp_text, user_data);
2010                 vc_mgr_client_not_use_callback();
2011                 SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called");
2012
2013                 /* Release result */
2014                 if (NULL != temp_text) {
2015                         free(temp_text);
2016                         temp_text = NULL;
2017                 }
2018                 if (NULL != temp_message) {
2019                         free(temp_message);
2020                         temp_message = NULL;
2021                 }
2022
2023                 /* Release list */
2024                 if (vc_cmd_list)
2025                         vc_cmd_list_destroy(vc_cmd_list, true);
2026                 vc_cmd_list = NULL;
2027
2028                 vc_mgr_client_set_exclusive_command(false);
2029
2030                 return;
2031         }
2032
2033         int count = 0;
2034         vc_cmd_list_get_count(vc_cmd_list, &count);
2035         if (0 < count) {
2036                 if (true == cb_ret) {
2037                         SLOG(LOG_INFO, TAG_VCM, "Callback result is true");
2038                         if (VC_RESULT_TYPE_NOTIFICATION != result_type)
2039                                 ecore_idler_add(__vc_mgr_set_select_result, NULL);
2040                 } else {
2041                         SLOG(LOG_INFO, TAG_VCM, "Callback result is false");
2042                         /* need to select conflicted result */
2043                 }
2044         } else {
2045                 if (VC_RESULT_TYPE_NOTIFICATION != result_type)
2046                         ecore_idler_add(__vc_mgr_set_select_result, NULL);
2047
2048                 vc_mgr_client_set_exclusive_command(false);
2049                 vc_mgr_client_unset_all_result();
2050         }
2051
2052         /* Release result */
2053         if (NULL != temp_text) {
2054                 free(temp_text);
2055                 temp_text = NULL;
2056         }
2057         if (NULL != temp_message) {
2058                 free(temp_message);
2059                 temp_message = NULL;
2060         }
2061
2062         /* Release list */
2063         if (vc_cmd_list)
2064                 vc_cmd_list_destroy(vc_cmd_list, true);
2065         vc_cmd_list = NULL;
2066
2067         return;
2068 }
2069
2070 static Eina_Bool __vc_mgr_notify_result(void *data)
2071 {
2072         char* temp_text = NULL;
2073         int event;
2074         vc_cmd_list_h vc_cmd_list = NULL;
2075
2076         vc_result_cb callback = NULL;
2077         void* user_data = NULL;
2078
2079         vc_mgr_client_get_result_cb(&callback, &user_data);
2080         RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCM, "[ERROR] Client result callback is NULL");
2081
2082         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
2083                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
2084                 return EINA_FALSE;
2085         }
2086
2087         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
2088
2089         SECURE_SLOG(LOG_INFO, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event);
2090
2091         vc_cmd_print_list(vc_cmd_list);
2092
2093         vc_mgr_client_use_callback();
2094         callback(event, vc_cmd_list, temp_text, user_data);
2095         vc_mgr_client_not_use_callback();
2096         SLOG(LOG_INFO, TAG_VCM, "Result callback called");
2097
2098         if (vc_cmd_list)
2099                 vc_cmd_list_destroy(vc_cmd_list, true);
2100         vc_cmd_list = NULL;
2101
2102         /* Release result */
2103         if (temp_text)
2104                 free(temp_text);
2105         temp_text = NULL;
2106
2107         return EINA_FALSE;
2108 }
2109
2110 void __vc_mgr_cb_all_result(vc_result_type_e type)
2111 {
2112         if (false == vc_mgr_client_get_exclusive_command()) {
2113                 __vc_mgr_notify_all_result(type);
2114         } else {
2115                 __vc_mgr_notify_result(0);
2116         }
2117
2118         return;
2119 }
2120
2121 void __vc_mgr_cb_pre_result(vc_pre_result_event_e event, const char* pre_result)
2122 {
2123         vc_mgr_pre_result_cb callback = NULL;
2124         void* user_data = NULL;
2125
2126         vc_mgr_client_get_pre_result_cb(&callback, &user_data);
2127         RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client pre result callback is NULL");
2128
2129         vc_mgr_client_use_callback();
2130         callback(event, pre_result, user_data);
2131         vc_mgr_client_not_use_callback();
2132         SLOG(LOG_INFO, TAG_VCM, "Pre result callback is called");
2133
2134         return;
2135 }
2136
2137 void __vc_mgr_cb_system_result()
2138 {
2139         __vc_mgr_notify_result(NULL);
2140         return;
2141 }
2142
2143 static Eina_Bool __vc_mgr_speech_detected(void *data)
2144 {
2145         vc_mgr_begin_speech_detected_cb callback = NULL;
2146         void* user_data = NULL;
2147
2148         vc_mgr_client_get_speech_detected_cb(&callback, &user_data);
2149         RETVM_IF(NULL == callback, EINA_FALSE, TAG_VCM, "[ERROR] Client speech detected callback is NULL");
2150
2151         vc_mgr_client_use_callback();
2152         callback(user_data);
2153         vc_mgr_client_not_use_callback();
2154         SLOG(LOG_INFO, TAG_VCM, "Speech detected callback called");
2155
2156         return EINA_FALSE;
2157 }
2158
2159 void __vc_mgr_cb_speech_detected()
2160 {
2161         __vc_mgr_speech_detected(NULL);
2162
2163         return;
2164 }
2165
2166 int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data)
2167 {
2168         int ret;
2169         ret = __check_mgr_feature_privilege();
2170         if (VC_ERROR_NONE != ret)
2171                 return ret;
2172
2173         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2174
2175         vc_state_e state;
2176         if (0 != vc_mgr_client_get_client_state(&state)) {
2177                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
2178                 return VC_ERROR_INVALID_STATE;
2179         }
2180
2181         /* check state */
2182         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2183
2184         vc_mgr_client_set_all_result_cb(callback, user_data);
2185
2186         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set all result callback");
2187
2188         return VC_ERROR_NONE;
2189 }
2190
2191 int vc_mgr_unset_all_result_cb(void)
2192 {
2193         int ret;
2194         ret = __check_mgr_feature_privilege();
2195         if (VC_ERROR_NONE != ret)
2196                 return ret;
2197
2198         vc_state_e state;
2199         if (0 != vc_mgr_client_get_client_state(&state)) {
2200                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
2201                 return VC_ERROR_INVALID_STATE;
2202         }
2203
2204         /* check state */
2205         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2206
2207         vc_mgr_client_set_all_result_cb(NULL, NULL);
2208
2209         return VC_ERROR_NONE;
2210 }
2211
2212 int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data)
2213 {
2214         int ret;
2215         ret = __check_mgr_feature_privilege();
2216         if (VC_ERROR_NONE != ret)
2217                 return ret;
2218
2219         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2220
2221         vc_state_e state;
2222         if (0 != vc_mgr_client_get_client_state(&state)) {
2223                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
2224                 return VC_ERROR_INVALID_STATE;
2225         }
2226
2227         /* check state */
2228         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2229
2230         vc_mgr_client_set_result_cb(callback, user_data);
2231
2232         return VC_ERROR_NONE;
2233 }
2234
2235 int vc_mgr_unset_result_cb(void)
2236 {
2237         int ret;
2238         ret = __check_mgr_feature_privilege();
2239         if (VC_ERROR_NONE != ret)
2240                 return ret;
2241
2242         vc_state_e state;
2243         if (0 != vc_mgr_client_get_client_state(&state)) {
2244                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
2245                 return VC_ERROR_INVALID_STATE;
2246         }
2247
2248         /* check state */
2249         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2250
2251         vc_mgr_client_set_result_cb(NULL, NULL);
2252
2253         return VC_ERROR_NONE;
2254 }
2255
2256 int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
2257 {
2258         int ret;
2259         ret = __check_mgr_feature_privilege();
2260         if (VC_ERROR_NONE != ret)
2261                 return ret;
2262
2263         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2264
2265         vc_state_e state;
2266         if (0 != vc_mgr_client_get_client_state(&state)) {
2267                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set pre result callback : A handle is not available");
2268                 return VC_ERROR_INVALID_STATE;
2269         }
2270
2271         /* check state */
2272         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2273
2274         vc_mgr_client_set_pre_result_cb(callback, user_data);
2275
2276         return VC_ERROR_NONE;
2277 }
2278
2279 int vc_mgr_unset_pre_result_cb(void)
2280 {
2281         int ret;
2282         ret = __check_mgr_feature_privilege();
2283         if (VC_ERROR_NONE != ret)
2284                 return ret;
2285
2286         vc_state_e state;
2287         if (0 != vc_mgr_client_get_client_state(&state)) {
2288                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset pre result callback : A handle is not available");
2289                 return VC_ERROR_INVALID_STATE;
2290         }
2291
2292         /* check state */
2293         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2294
2295         vc_mgr_client_set_pre_result_cb(NULL, NULL);
2296
2297         return VC_ERROR_NONE;
2298 }
2299
2300 int vc_mgr_get_error_message(char** err_msg)
2301 {
2302         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get error message");
2303
2304         int ret;
2305         ret = __check_mgr_feature_privilege();
2306         if (VC_ERROR_NONE != ret)
2307                 return ret;
2308
2309         /* check state */
2310         vc_state_e state;
2311         if (0 != vc_mgr_client_get_client_state(&state)) {
2312                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] vc_mgr handle is not available");
2313                 return VC_ERROR_INVALID_STATE;
2314         }
2315
2316         RETVM_IF(NULL == err_msg, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2317
2318         if (false == g_err_callback_status) {
2319                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in error callback");
2320                 return VC_ERROR_OPERATION_FAILED;
2321         }
2322
2323         ret = vc_mgr_client_get_error_message(err_msg);
2324         if (0 != ret) {
2325                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message");
2326         }
2327
2328         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] Get error message DONE");
2329
2330         return ret;
2331 }
2332
2333 static void __vc_mgr_notify_error(void *data)
2334 {
2335         vc_error_cb callback = NULL;
2336         void* user_data = NULL;
2337         int reason;
2338
2339         vc_mgr_client_get_error_cb(&callback, &user_data);
2340         vc_mgr_client_get_error(&reason);
2341
2342         if (NULL != callback) {
2343                 vc_mgr_client_use_callback();
2344                 g_err_callback_status = true;
2345                 callback(reason, user_data);
2346                 g_err_callback_status = false;
2347                 vc_mgr_client_not_use_callback();
2348                 SLOG(LOG_INFO, TAG_VCM, "Error callback is called");
2349         } else {
2350                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
2351         }
2352 }
2353
2354 int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg)
2355 {
2356         vc_state_e state;
2357         if (0 != vc_mgr_client_get_client_state(&state)) {
2358                 SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client");
2359                 return VC_ERROR_INVALID_PARAMETER;
2360         }
2361
2362         /* check state */
2363         if (state != VC_STATE_INITIALIZED && state != VC_STATE_READY) {
2364                 SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet");
2365                 return VC_ERROR_INVALID_STATE;
2366         }
2367
2368         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
2369
2370         if (VC_ERROR_SERVICE_RESET == reason) {
2371                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] VC daemon reset");
2372
2373                 vc_service_state_e service_state = -1;
2374                 vc_mgr_client_get_service_state(&service_state);
2375                 if (VC_SERVICE_STATE_UPDATING == service_state) {
2376                         SLOG(LOG_INFO, TAG_VCM, "[INFO] VC daemon is terminated by update manager");
2377                         return VC_ERROR_NONE;
2378                 }
2379
2380                 vc_mgr_client_set_client_state(VC_STATE_INITIALIZED);
2381                 __vc_mgr_notify_state_changed(NULL);
2382
2383                 if (0 != vc_mgr_prepare()) {
2384                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to prepare");
2385                 }
2386         }
2387
2388         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
2389
2390         vc_mgr_client_set_error(reason);
2391         vc_mgr_client_set_error_message(msg);
2392         __vc_mgr_notify_error(NULL);
2393
2394         return VC_ERROR_NONE;
2395 }
2396
2397 static Eina_Bool __vc_mgr_notify_state_changed(void *data)
2398 {
2399         vc_state_changed_cb changed_callback = NULL;
2400         void* user_data;
2401
2402         vc_mgr_client_get_state_changed_cb(&changed_callback, &user_data);
2403
2404         vc_state_e current_state;
2405         vc_state_e previous_state;
2406
2407         vc_mgr_client_get_previous_state(&current_state, &previous_state);
2408
2409         if (NULL != changed_callback) {
2410                 vc_mgr_client_use_callback();
2411                 changed_callback(previous_state, current_state, user_data);
2412                 vc_mgr_client_not_use_callback();
2413                 SLOG(LOG_INFO, TAG_VCM, "State changed callback is called");
2414         } else {
2415                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
2416         }
2417
2418         return EINA_FALSE;
2419 }
2420
2421 int vc_mgr_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
2422 {
2423         int ret;
2424         ret = __check_mgr_feature_privilege();
2425         if (VC_ERROR_NONE != ret)
2426                 return ret;
2427
2428         if (callback == NULL)
2429                 return VC_ERROR_INVALID_PARAMETER;
2430
2431         vc_state_e state;
2432         if (0 != vc_mgr_client_get_client_state(&state)) {
2433                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2434                 return VC_ERROR_INVALID_STATE;
2435         }
2436
2437         /* check state */
2438         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2439
2440         vc_mgr_client_set_state_changed_cb(callback, user_data);
2441
2442         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set state changed callback");
2443         return VC_ERROR_NONE;
2444 }
2445
2446 int vc_mgr_unset_state_changed_cb(void)
2447 {
2448         int ret;
2449         ret = __check_mgr_feature_privilege();
2450         if (VC_ERROR_NONE != ret)
2451                 return ret;
2452
2453         vc_state_e state;
2454         if (0 != vc_mgr_client_get_client_state(&state)) {
2455                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2456                 return VC_ERROR_INVALID_STATE;
2457         }
2458
2459         /* check state */
2460         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2461
2462         vc_mgr_client_set_state_changed_cb(NULL, NULL);
2463
2464         return VC_ERROR_NONE;
2465 }
2466
2467 int __vc_mgr_cb_service_state(int state)
2468 {
2469         vc_service_state_e current_state = (vc_service_state_e)state;
2470         vc_service_state_e previous_state;
2471         vc_mgr_client_get_service_state(&previous_state);
2472
2473         SLOG(LOG_INFO, TAG_VCM, "Service State changed : previous(%d) current(%d)",
2474                 previous_state, current_state);
2475
2476         vc_internal_state_e internal_state = -1;
2477         vc_mgr_client_get_internal_state(&internal_state);
2478         if ((VC_INTERNAL_STATE_STARTING == internal_state && VC_SERVICE_STATE_RECORDING == current_state) ||
2479                 (VC_INTERNAL_STATE_STOPPING == internal_state && VC_SERVICE_STATE_PROCESSING == current_state) ||
2480                 (VC_INTERNAL_STATE_CANCELING == internal_state && VC_SERVICE_STATE_READY == current_state)) {
2481                         SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE");
2482                         vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
2483         }
2484         if (VC_SERVICE_STATE_UPDATING == current_state) {
2485                 SLOG(LOG_INFO, TAG_VCM, "Internal state is changed to NONE by updating");
2486                 vc_mgr_client_set_internal_state(VC_INTERNAL_STATE_NONE);
2487         }
2488
2489         if (current_state == previous_state) {
2490                 SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : previous(%d) current(%d)",
2491                         previous_state, current_state);
2492                 return VC_ERROR_NONE;
2493         }
2494
2495         /* Save service state */
2496         vc_mgr_client_set_service_state(current_state);
2497
2498         vc_service_state_changed_cb callback = NULL;
2499         void* service_user_data = NULL;
2500         vc_mgr_client_get_service_state_changed_cb(&callback, &service_user_data);
2501
2502         if (NULL != callback) {
2503                 vc_mgr_client_use_callback();
2504                 callback(previous_state, current_state, service_user_data);
2505                 vc_mgr_client_not_use_callback();
2506                 SLOG(LOG_INFO, TAG_VCM, "Service state changed callback is called");
2507         } else {
2508                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
2509         }
2510
2511         return VC_ERROR_NONE;
2512 }
2513
2514 int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
2515 {
2516         int ret;
2517         ret = __check_mgr_feature_privilege();
2518         if (VC_ERROR_NONE != ret)
2519                 return ret;
2520
2521         if (callback == NULL)
2522                 return VC_ERROR_INVALID_PARAMETER;
2523
2524         vc_state_e state;
2525         if (0 != vc_mgr_client_get_client_state(&state)) {
2526                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2527                 return VC_ERROR_INVALID_STATE;
2528         }
2529
2530         /* check state */
2531         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2532
2533         vc_mgr_client_set_service_state_changed_cb(callback, user_data);
2534
2535         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set service state changed callback");
2536         return VC_ERROR_NONE;
2537 }
2538
2539 int vc_mgr_unset_service_state_changed_cb(void)
2540 {
2541         int ret;
2542         ret = __check_mgr_feature_privilege();
2543         if (VC_ERROR_NONE != ret)
2544                 return ret;
2545
2546         vc_state_e state;
2547         if (0 != vc_mgr_client_get_client_state(&state)) {
2548                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2549                 return VC_ERROR_INVALID_STATE;
2550         }
2551
2552         /* check state */
2553         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2554
2555         vc_mgr_client_set_service_state_changed_cb(NULL, NULL);
2556         return VC_ERROR_NONE;
2557 }
2558
2559 int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data)
2560 {
2561         int ret;
2562         ret = __check_mgr_feature_privilege();
2563         if (VC_ERROR_NONE != ret)
2564                 return ret;
2565
2566         if (callback == NULL)
2567                 return VC_ERROR_INVALID_PARAMETER;
2568
2569         vc_state_e state;
2570         if (0 != vc_mgr_client_get_client_state(&state)) {
2571                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2572                 return VC_ERROR_INVALID_STATE;
2573         }
2574
2575         /* check state */
2576         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2577
2578         vc_mgr_client_set_speech_detected_cb(callback, user_data);
2579
2580         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set speech detected callback");
2581         return VC_ERROR_NONE;
2582 }
2583
2584 int vc_mgr_unset_speech_detected_cb(void)
2585 {
2586         int ret;
2587         ret = __check_mgr_feature_privilege();
2588         if (VC_ERROR_NONE != ret)
2589                 return ret;
2590
2591         vc_state_e state;
2592         if (0 != vc_mgr_client_get_client_state(&state)) {
2593                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2594                 return VC_ERROR_INVALID_STATE;
2595         }
2596
2597         /* check state */
2598         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2599
2600         vc_mgr_client_set_speech_detected_cb(NULL, NULL);
2601         return VC_ERROR_NONE;
2602 }
2603
2604 int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2605 {
2606         int ret;
2607         ret = __check_mgr_feature_privilege();
2608         if (VC_ERROR_NONE != ret)
2609                 return ret;
2610
2611         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2612
2613         vc_state_e state;
2614         if (0 != vc_mgr_client_get_client_state(&state)) {
2615                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : A handle is not available");
2616                 return VC_ERROR_INVALID_STATE;
2617         }
2618
2619         /* check state */
2620         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2621
2622         vc_mgr_client_set_current_lang_changed_cb(callback, user_data);
2623
2624         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set current language changed callback");
2625         return VC_ERROR_NONE;
2626 }
2627
2628 int vc_mgr_unset_current_language_changed_cb(void)
2629 {
2630         int ret;
2631         ret = __check_mgr_feature_privilege();
2632         if (VC_ERROR_NONE != ret)
2633                 return ret;
2634
2635         vc_state_e state;
2636         if (0 != vc_mgr_client_get_client_state(&state)) {
2637                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : A handle is not available");
2638                 return VC_ERROR_INVALID_STATE;
2639         }
2640
2641         /* check state */
2642         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2643
2644         vc_mgr_client_set_current_lang_changed_cb(NULL, NULL);
2645
2646         return VC_ERROR_NONE;
2647 }
2648
2649 int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data)
2650 {
2651         int ret;
2652         ret = __check_mgr_feature_privilege();
2653         if (VC_ERROR_NONE != ret)
2654                 return ret;
2655
2656         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2657
2658         vc_state_e state;
2659         if (0 != vc_mgr_client_get_client_state(&state)) {
2660                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2661                 return VC_ERROR_INVALID_STATE;
2662         }
2663
2664         /* check state */
2665         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2666
2667         vc_mgr_client_set_error_cb(callback,  user_data);
2668
2669         return VC_ERROR_NONE;
2670 }
2671
2672 int vc_mgr_unset_error_cb(void)
2673 {
2674         int ret;
2675         ret = __check_mgr_feature_privilege();
2676         if (VC_ERROR_NONE != ret)
2677                 return ret;
2678
2679         vc_state_e state;
2680         if (0 != vc_mgr_client_get_client_state(&state)) {
2681                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2682                 return VC_ERROR_INVALID_STATE;
2683         }
2684
2685         /* check state */
2686         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2687
2688         vc_mgr_client_set_error_cb(NULL, NULL);
2689
2690         return VC_ERROR_NONE;
2691 }
2692
2693 int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
2694 {
2695         vc_mgr_dialog_request_cb callback = NULL;
2696         void* user_data = NULL;
2697
2698         vc_mgr_client_get_dialog_request_cb(&callback, &user_data);
2699
2700         if (NULL != callback) {
2701                 vc_mgr_client_use_callback();
2702                 callback(pid, disp_text, utt_text, continuous, user_data);
2703                 vc_mgr_client_not_use_callback();
2704                 SLOG(LOG_INFO, TAG_VCM, "Dialog callback is called, disp_text(%s), utt)text(%s), continuous(%d)", disp_text, utt_text, continuous);
2705         } else {
2706                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
2707         }
2708
2709         return VC_ERROR_NONE;
2710 }
2711
2712 int __vc_mgr_cb_private_data_set(const char* key, const char* data)
2713 {
2714         vc_mgr_private_data_set_cb callback = NULL;
2715         void* user_data = NULL;
2716         int ret = -1;
2717
2718         vc_mgr_client_get_private_data_set_cb(&callback, &user_data);
2719
2720         if (NULL != callback) {
2721                 vc_mgr_client_use_callback();
2722                 ret = callback(key, data, user_data);
2723                 vc_mgr_client_not_use_callback();
2724                 SLOG(LOG_INFO, TAG_VCM, "Private data set callback is called");
2725         } else {
2726                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data set callback is null");
2727         }
2728
2729         return ret;
2730 }
2731
2732 int __vc_mgr_cb_private_data_requested(const char* key, char** data)
2733 {
2734         vc_mgr_private_data_requested_cb callback = NULL;
2735         void* user_data = NULL;
2736         int ret = -1;
2737
2738         vc_mgr_client_get_private_data_requested_cb(&callback, &user_data);
2739
2740         if (NULL != callback) {
2741                 vc_mgr_client_use_callback();
2742                 ret = callback(key, data, user_data);
2743                 vc_mgr_client_not_use_callback();
2744                 SLOG(LOG_INFO, TAG_VCM, "Private data requested callback is called");
2745         } else {
2746                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Private data requested callback is null");
2747         }
2748
2749         return ret;
2750 }
2751
2752 /* for TTS feedback */
2753 int __vc_mgr_cb_feedback_audio_format(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type)
2754 {
2755         vc_mgr_feedback_audio_format_cb callback = NULL;
2756         void* user_data = NULL;
2757
2758         /* set global audio formats */
2759         g_feedback_rate = rate;
2760         g_feedback_audio_channel = channel;
2761         g_feedback_audio_type = audio_type;
2762
2763         vc_mgr_client_get_feedback_audio_format_cb(&callback, &user_data);
2764
2765         if (NULL != callback) {
2766                 vc_mgr_client_use_callback();
2767                 callback(rate, channel, audio_type, user_data);
2768                 vc_mgr_client_not_use_callback();
2769                 SLOG(LOG_INFO, TAG_VCM, "TTS feedback audio format callback is called");
2770         } else {
2771                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback audio format callback is null");
2772         }
2773
2774         return VC_ERROR_NONE;
2775 }
2776
2777 int __vc_mgr_cb_feedback_streaming(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len)
2778 {
2779         /* add feedback data */
2780         vc_feedback_data_s* temp_feedback_data = NULL;
2781         temp_feedback_data = (vc_feedback_data_s*)calloc(1, sizeof(vc_feedback_data_s));
2782         RETVM_IF(NULL == temp_feedback_data, VC_ERROR_OUT_OF_MEMORY, TAG_VCM, "[ERROR] Out of memory");
2783         SLOG(LOG_INFO, TAG_VCM, "[INFO] feedback streaming before queing");
2784
2785         temp_feedback_data->data = NULL;
2786         temp_feedback_data->rate = g_feedback_rate;
2787         temp_feedback_data->data_size = 0;
2788
2789         if (0 < len) {
2790                 temp_feedback_data->data = (char*)calloc(len + 5, sizeof(char));
2791                 if (NULL != temp_feedback_data->data) {
2792                         memcpy(temp_feedback_data->data, buffer, len);
2793                         temp_feedback_data->data_size = len;
2794                         SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG][memcpy] data(%p) size(%d)",
2795                                         temp_feedback_data->data, temp_feedback_data->data_size);
2796                 } else {
2797                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] fail to allocate memory");
2798                 }
2799         } else {
2800                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] feedback data is NULL");
2801         }
2802
2803         temp_feedback_data->pid = pid;
2804         temp_feedback_data->utt_id = utt_id;
2805         temp_feedback_data->event = event;
2806         temp_feedback_data->audio_type = g_feedback_audio_type;
2807         temp_feedback_data->channel = g_feedback_audio_channel;
2808
2809         SLOG(LOG_INFO, TAG_VCM, "[INFO] add feedback data, pid(%d), utt_id(%d), event(%d), audio_type(%d), channel(%d)", pid, utt_id, event, g_feedback_audio_type, g_feedback_audio_channel);
2810
2811         int ret = vc_mgr_data_add_feedback_data(temp_feedback_data);
2812         if (0 != ret) {
2813                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add feedback data");
2814                 if (NULL != temp_feedback_data->data) {
2815                         free(temp_feedback_data->data);
2816                         temp_feedback_data->data = NULL;
2817                 }
2818                 if (NULL != temp_feedback_data) {
2819                         free(temp_feedback_data);
2820                         temp_feedback_data = NULL;
2821                 }
2822         }
2823
2824         return ret;
2825 }
2826
2827
2828 int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data)
2829 {
2830         int ret;
2831         ret = __check_mgr_feature_privilege();
2832         if (VC_ERROR_NONE != ret)
2833                 return ret;
2834
2835         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2836
2837         vc_state_e state;
2838         if (0 != vc_mgr_client_get_client_state(&state)) {
2839                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2840                 return VC_ERROR_INVALID_STATE;
2841         }
2842
2843         /* check state */
2844         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2845
2846         vc_mgr_client_set_dialog_request_cb(callback,  user_data);
2847
2848         return VC_ERROR_NONE;
2849 }
2850
2851 int vc_mgr_unset_dialog_request_cb(void)
2852 {
2853         int ret;
2854         ret = __check_mgr_feature_privilege();
2855         if (VC_ERROR_NONE != ret)
2856                 return ret;
2857
2858         vc_state_e state;
2859         if (0 != vc_mgr_client_get_client_state(&state)) {
2860                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2861                 return VC_ERROR_INVALID_STATE;
2862         }
2863
2864         /* check state */
2865         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
2866
2867         vc_mgr_client_set_dialog_request_cb(NULL, NULL);
2868
2869         return VC_ERROR_NONE;
2870 }
2871
2872 int vc_mgr_set_private_data_set_cb(vc_mgr_private_data_set_cb callback, void* user_data)
2873 {
2874         int ret;
2875         ret = __check_mgr_feature_privilege();
2876         if (VC_ERROR_NONE != ret)
2877                 return ret;
2878
2879         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2880
2881         vc_state_e state;
2882         if (0 != vc_mgr_client_get_client_state(&state)) {
2883                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data set callback : A handle is not available");
2884                 return VC_ERROR_INVALID_STATE;
2885         }
2886
2887         /* check state */
2888         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data set callback : Current state is not 'Initialized'");
2889
2890         vc_mgr_client_set_private_data_set_cb(callback, user_data);
2891
2892         return VC_ERROR_NONE;
2893 }
2894
2895 int vc_mgr_unset_private_data_set_cb(void)
2896 {
2897         int ret;
2898         ret = __check_mgr_feature_privilege();
2899         if (VC_ERROR_NONE != ret)
2900                 return ret;
2901
2902         vc_state_e state;
2903         if (0 != vc_mgr_client_get_client_state(&state)) {
2904                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data set callback : A handle is not available");
2905                 return VC_ERROR_INVALID_STATE;
2906         }
2907
2908         /* check state */
2909         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data set callback : Current state is not 'Initialized'");
2910
2911         vc_mgr_client_set_private_data_set_cb(NULL, NULL);
2912
2913         return VC_ERROR_NONE;
2914 }
2915
2916 int vc_mgr_set_private_data_requested_cb(vc_mgr_private_data_requested_cb callback, void* user_data)
2917 {
2918         int ret;
2919         ret = __check_mgr_feature_privilege();
2920         if (VC_ERROR_NONE != ret)
2921                 return ret;
2922
2923         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
2924
2925         vc_state_e state;
2926         if (0 != vc_mgr_client_get_client_state(&state)) {
2927                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set private data requested callback : A handle is not available");
2928                 return VC_ERROR_INVALID_STATE;
2929         }
2930
2931         /* check state*/
2932         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set private data requested callback : Current state is not 'Initialized'");
2933
2934         vc_mgr_client_set_private_data_requested_cb(callback, user_data);
2935
2936         return VC_ERROR_NONE;
2937 }
2938
2939 int vc_mgr_unset_private_data_requested_cb(void)
2940 {
2941         int ret;
2942         ret = __check_mgr_feature_privilege();
2943         if (VC_ERROR_NONE != ret)
2944                 return ret;
2945
2946         vc_state_e state;
2947         if (0 != vc_mgr_client_get_client_state(&state)) {
2948                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset private data requested callback : A handle is not available");
2949                 return VC_ERROR_INVALID_STATE;
2950         }
2951
2952         /* check state */
2953         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset private data requested callback : Current state is not 'Initialized'");
2954
2955         vc_mgr_client_set_private_data_requested_cb(NULL, NULL);
2956
2957         return VC_ERROR_NONE;
2958 }
2959
2960 static bool __vc_mgr_check_demandable_client(int pid)
2961 {
2962         if (0 == g_slist_length(g_demandable_client_list)) {
2963                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] No demandable clients");
2964                 return false;
2965         }
2966
2967         char appid[1024] = {'\0', };
2968         if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) {
2969                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get callee appid by pid");
2970                 return false;
2971         }
2972         SLOG(LOG_INFO, TAG_VCM, "[CHECK] Appid - %s", appid);
2973
2974         GSList *iter = NULL;
2975         vc_demandable_client_s* temp_client;
2976         iter = g_slist_nth(g_demandable_client_list, 0);
2977
2978         while (NULL != iter) {
2979                 temp_client = iter->data;
2980
2981                 if (NULL != temp_client) {
2982                         if (NULL != temp_client->appid) {
2983                                 if (!strcmp(temp_client->appid, appid)) {
2984                                         SLOG(LOG_DEBUG, TAG_VCM, "pid(%d) is available", pid);
2985                                         return true;
2986                                 }
2987                         }
2988                 }
2989
2990                 iter = g_slist_next(iter);
2991         }
2992
2993         return false;
2994 }
2995
2996 /* Authority */
2997 int __vc_mgr_request_auth_enable(int pid)
2998 {
2999         if (false == __vc_mgr_check_demandable_client(pid)) {
3000                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not demandable client");
3001                 return VC_ERROR_INVALID_PARAMETER;
3002         }
3003
3004         /* check already authorized */
3005         if (true == vc_mgr_client_is_authorized_client(pid)) {
3006                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already authorized");
3007                 return VC_ERROR_INVALID_PARAMETER;
3008         }
3009
3010         /* add authorized list */
3011         if (0 != vc_mgr_client_add_authorized_client(pid)) {
3012                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add authorized client");
3013                 return VC_ERROR_OPERATION_FAILED;
3014         }
3015
3016         /* foreground check */
3017         int fore_pid = 0;
3018         if (0 != vc_mgr_client_get_foreground(&fore_pid)) {
3019                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground");
3020                 return VC_ERROR_OPERATION_FAILED;
3021         }
3022
3023         if (pid == fore_pid) {
3024                 vc_mgr_client_set_valid_authorized_client(pid);
3025         }
3026
3027         return VC_ERROR_NONE;
3028 }
3029
3030 int __vc_mgr_request_auth_disable(int pid)
3031 {
3032         /* check authorized */
3033         if (false == vc_mgr_client_is_authorized_client(pid)) {
3034                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No authorized");
3035                 return VC_ERROR_INVALID_PARAMETER;
3036         }
3037
3038         /* remove authorized list */
3039         if (0 != vc_mgr_client_remove_authorized_client(pid)) {
3040                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to remove authorized client");
3041                 return VC_ERROR_OPERATION_FAILED;
3042         }
3043
3044         /* check authority valid */
3045         if (true == vc_mgr_client_is_valid_authorized_client(pid)) {
3046                 SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed");
3047                 if (0 != vc_mgr_client_set_valid_authorized_client(-1)) {
3048                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set valid authorized client");
3049                         return VC_ERROR_OPERATION_FAILED;
3050                 }
3051         }
3052
3053         return VC_ERROR_NONE;
3054 }
3055
3056 static Eina_Bool __request_auth_start(void* data)
3057 {
3058         SLOG(LOG_INFO, TAG_VCM, "Request Start");
3059
3060         if (0 != vc_mgr_client_set_start_by_client(true)) {
3061                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
3062         }
3063
3064         if (0 != vc_mgr_start(false)) {
3065                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed");
3066                 /* TODO - Error handling? */
3067         }
3068
3069         if (0 != vc_mgr_client_set_start_by_client(false)) {
3070                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
3071         }
3072
3073
3074         return EINA_FALSE;
3075 }
3076
3077 int __vc_mgr_request_auth_start(int pid)
3078 {
3079         /* check authorized */
3080         if (false == vc_mgr_client_is_valid_authorized_client(pid)) {
3081                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
3082                 return VC_ERROR_INVALID_PARAMETER;
3083         }
3084
3085         /* add timer for start recording */
3086         ecore_timer_add(0, __request_auth_start, NULL);
3087
3088         return VC_ERROR_NONE;
3089 }
3090
3091 static Eina_Bool __request_auth_stop(void* data)
3092 {
3093         SLOG(LOG_INFO, TAG_VCM, "Request Stop");
3094
3095         if (0 != vc_mgr_stop()) {
3096                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed");
3097                 /* TODO - Error handling? */
3098         }
3099
3100         return EINA_FALSE;
3101 }
3102
3103 int __vc_mgr_request_auth_stop(int pid)
3104 {
3105         /* check authorized */
3106         if (false == vc_mgr_client_is_valid_authorized_client(pid)) {
3107                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
3108                 return VC_ERROR_INVALID_PARAMETER;
3109         }
3110
3111         /* add timer for start recording */
3112         ecore_timer_add(0, __request_auth_stop, NULL);
3113
3114         return VC_ERROR_NONE;
3115 }
3116
3117 static Eina_Bool __request_auth_cancel(void* data)
3118 {
3119         SLOG(LOG_INFO, TAG_VCM, "Request Cancel");
3120
3121         if (0 != vc_mgr_cancel()) {
3122                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed");
3123                 /* TODO - Error handling? */
3124         }
3125
3126         return EINA_FALSE;
3127 }
3128
3129 int __vc_mgr_request_auth_cancel(int pid)
3130 {
3131         /* check authorized */
3132         if (false == vc_mgr_client_is_valid_authorized_client(pid)) {
3133                 SLOG(LOG_ERROR,  TAG_VCM, "[ERROR] No valid authorized client");
3134                 return VC_ERROR_INVALID_PARAMETER;
3135         }
3136
3137         /* add timer for start recording */
3138         ecore_timer_add(0, __request_auth_cancel, NULL);
3139
3140         return VC_ERROR_NONE;
3141 }
3142
3143 int vc_mgr_set_specific_engine_result_cb(vc_mgr_specific_engine_result_cb callback, void* user_data)
3144 {
3145         int ret;
3146         ret = __check_mgr_feature_privilege();
3147         if (VC_ERROR_NONE != ret)
3148                 return ret;
3149
3150         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
3151
3152         vc_state_e state;
3153         if (0 != vc_mgr_client_get_client_state(&state)) {
3154                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set specific engine result callback : A handle is not available");
3155                 return VC_ERROR_INVALID_STATE;
3156         }
3157
3158         /* check state */
3159         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
3160
3161         vc_mgr_client_set_specific_engine_result_cb(callback, user_data);
3162
3163         return VC_ERROR_NONE;
3164 }
3165 int vc_mgr_unset_specific_engine_result_cb(void)
3166 {
3167         if (0 != __vc_mgr_get_feature_enabled()) {
3168                 return VC_ERROR_NOT_SUPPORTED;
3169         }
3170
3171         vc_state_e state;
3172         if (0 != vc_mgr_client_get_client_state(&state)) {
3173                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset specific engine result callback : A handle is not available");
3174                 return VC_ERROR_INVALID_STATE;
3175         }
3176
3177         /* check state */
3178         RETVM_IF(state != VC_STATE_INITIALIZED, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Initialized'", state);
3179
3180         vc_mgr_client_set_specific_engine_result_cb(NULL, NULL);
3181
3182         return VC_ERROR_NONE;
3183 }
3184
3185 void __vc_mgr_cb_specific_engine_result(const char* engine_app_id, const char* event, const char* result)
3186 {
3187         vc_mgr_specific_engine_result_cb callback = NULL;
3188         void* user_data = NULL;
3189
3190         vc_mgr_client_get_specific_engine_result_cb(&callback, &user_data);
3191         RETM_IF(NULL == callback, TAG_VCM, "[ERROR] Client specific engine result callback is NULL");
3192
3193         vc_mgr_client_use_callback();
3194         callback(engine_app_id, event, result, user_data);
3195         vc_mgr_client_not_use_callback();
3196         SLOG(LOG_INFO, TAG_VCM, "Specific engine result callback is called, engine app id(%s), event(%s), result(%s)", engine_app_id, event, result);
3197
3198         return;
3199 }
3200
3201 /* for TTS feedback */
3202 int vc_mgr_set_feedback_audio_format_cb(vc_mgr_feedback_audio_format_cb callback, void* user_data)
3203 {
3204         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback audio format");
3205
3206         int ret;
3207         ret = __check_mgr_feature_privilege();
3208         if (VC_ERROR_NONE != ret)
3209                 return ret;
3210
3211         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
3212
3213         vc_state_e state;
3214         if (0 != vc_mgr_client_get_client_state(&state)) {
3215                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback audio format callback : A handle is not available");
3216                 return VC_ERROR_INVALID_STATE;
3217         }
3218
3219         /* check state */
3220         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Set feedback audio format callback : Current state is not 'Initialized'");
3221
3222         vc_mgr_client_set_feedback_audio_format_cb(callback, user_data);
3223
3224         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback audio format callback");
3225
3226         return VC_ERROR_NONE;
3227 }
3228
3229 int vc_mgr_unset_feedback_audio_format_cb()
3230 {
3231         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback audio format");
3232
3233         int ret;
3234         ret = __check_mgr_feature_privilege();
3235         if (VC_ERROR_NONE != ret)
3236                 return ret;
3237
3238         vc_state_e state;
3239         if (0 != vc_mgr_client_get_client_state(&state)) {
3240                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback audio format callback : A handle is not available");
3241                 return VC_ERROR_INVALID_STATE;
3242         }
3243
3244         /* check state */
3245         RETVM_IF(VC_STATE_INITIALIZED != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Unset feedback audio format callback : Current state is not 'Initialized'");
3246
3247         vc_mgr_client_set_feedback_audio_format_cb(NULL, NULL);
3248
3249         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback audio format callback");
3250
3251         return VC_ERROR_NONE;
3252 }
3253
3254 int vc_mgr_set_feedback_streaming_cb(vc_mgr_feedback_streaming_cb callback, void* user_data)
3255 {
3256         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set feedback streaming");
3257
3258         int ret;
3259         ret = __check_mgr_feature_privilege();
3260         if (VC_ERROR_NONE != ret)
3261                 return ret;
3262
3263         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
3264
3265         pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
3266
3267         vc_state_e state;
3268         if (0 != vc_mgr_client_get_client_state(&state)) {
3269                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
3270                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3271                 return VC_ERROR_INVALID_STATE;
3272         }
3273
3274         /* check state */
3275         if (VC_STATE_INITIALIZED != state) {
3276                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
3277                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3278                 return VC_ERROR_INVALID_STATE;
3279         }
3280
3281         vc_mgr_client_set_feedback_streaming_cb(callback, user_data);
3282
3283         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3284
3285         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
3286
3287         return VC_ERROR_NONE;
3288 }
3289
3290 int vc_mgr_unset_feedback_streaming_cb()
3291 {
3292         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset feedback streaming");
3293
3294         int ret;
3295         ret = __check_mgr_feature_privilege();
3296         if (VC_ERROR_NONE != ret)
3297                 return ret;
3298
3299         pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
3300
3301         vc_state_e state;
3302         if (0 != vc_mgr_client_get_client_state(&state)) {
3303                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
3304                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3305                 return VC_ERROR_INVALID_STATE;
3306         }
3307
3308         /* check state */
3309         if (VC_STATE_INITIALIZED != state) {
3310                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
3311                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3312                 return VC_ERROR_INVALID_STATE;
3313         }
3314
3315         vc_mgr_client_set_feedback_streaming_cb(NULL, NULL);
3316
3317         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3318
3319         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
3320
3321         return VC_ERROR_NONE;
3322 }
3323
3324 int vc_mgr_set_vc_tts_streaming_cb(vc_mgr_vc_tts_streaming_cb callback, void* user_data)
3325 {
3326         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] set vc tts streaming callback");
3327
3328         int ret;
3329         ret = __check_mgr_feature_privilege();
3330         if (VC_ERROR_NONE != ret)
3331                 return ret;
3332
3333         RETVM_IF(NULL == callback, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
3334
3335         pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
3336
3337         vc_state_e state;
3338         if (0 != vc_mgr_client_get_client_state(&state)) {
3339                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : A handle is not available");
3340                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3341                 return VC_ERROR_INVALID_STATE;
3342         }
3343
3344         /* check state */
3345         if (VC_STATE_INITIALIZED != state) {
3346                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set feedback streaming callback : Current state is not 'Initialized' (%d)", state);
3347                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3348                 return VC_ERROR_INVALID_STATE;
3349         }
3350
3351         vc_mgr_client_set_vc_tts_streaming_cb(callback, user_data);
3352
3353         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3354
3355         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Set feedback streaming callback");
3356
3357         return VC_ERROR_NONE;
3358 }
3359
3360 int vc_mgr_unset_vc_tts_streaming_cb()
3361 {
3362         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] unset vc tts streaming callback");
3363
3364         int ret;
3365         ret = __check_mgr_feature_privilege();
3366         if (VC_ERROR_NONE != ret)
3367                 return ret;
3368
3369         pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
3370
3371         vc_state_e state;
3372         if (0 != vc_mgr_client_get_client_state(&state)) {
3373                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : A handle is not available");
3374                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3375                 return VC_ERROR_INVALID_STATE;
3376         }
3377
3378         /* check state */
3379         if (VC_STATE_INITIALIZED != state) {
3380                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset feedback streaming callback : Current state is not 'Initialized' (%d)", state);
3381                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3382                 return VC_ERROR_INVALID_STATE;
3383         }
3384
3385         vc_mgr_client_set_vc_tts_streaming_cb(NULL, NULL);
3386
3387         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3388
3389         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Unset feedback streaming callback");
3390
3391         return VC_ERROR_NONE;
3392 }
3393
3394 static void __tts_feedback_thread(void* data, Ecore_Thread* thread)
3395 {
3396         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Start thread");
3397
3398         vc_feedback_data_s* feedback_data = NULL;
3399
3400         while (1) {
3401                 int ret = -1;
3402                 int cnt = 0;
3403
3404                 /* get feedback data */
3405                 ret = vc_mgr_data_get_feedback_data(&feedback_data);
3406                 if (0 != ret || NULL == feedback_data) {
3407                         /* empty queue */
3408                         SLOG(LOG_INFO, TAG_VCM, "[DEBUG] No feedback data. Waiting mode");
3409
3410                         /* waiting */
3411                         while (1) {
3412                                 if (ecore_thread_check(thread) == EINA_TRUE) {
3413                                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Stop feedback is called");
3414                                         return;
3415                                 }
3416
3417                                 usleep(10000);
3418
3419                                 if (0 < vc_mgr_data_get_feedback_data_size()) {
3420                                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Resume thread");
3421                                         break;
3422                                 }
3423                                 if (200 < cnt) {
3424                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Wrong request, there's no pcm data");
3425                                         vc_mgr_data_clear_feedback_data(&feedback_data);
3426                                         return;
3427                                 }
3428                                 cnt++;
3429                         }
3430                         SLOG(LOG_INFO, TAG_VCM, "[INFO] Finish to wait for new feedback data come");
3431
3432                         /* resume feedback thread */
3433                         vc_mgr_data_clear_feedback_data(&feedback_data);
3434                         continue;
3435                 }
3436
3437                 if (NULL != feedback_data) {
3438                         if (getpid() == feedback_data->pid) {
3439                                 vc_mgr_feedback_streaming_cb callback = NULL;
3440                                 void* user_data = NULL;
3441
3442                                 pthread_mutex_lock(&g_feedback_streaming_cb_mutex);
3443
3444                                 vc_mgr_client_get_feedback_streaming_cb(&callback, &user_data);
3445                                 if (NULL == callback) {
3446                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] TTS feedback streaming callback is null");
3447                                         vc_mgr_data_clear_feedback_data(&feedback_data);
3448                                         pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3449                                         return;
3450                                 }
3451
3452                                 SLOG(LOG_DEBUG, TAG_VCM, "TTS feedback streaming callback is called");
3453                                 vc_mgr_client_use_callback();
3454                                 callback(feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
3455                                 vc_mgr_client_not_use_callback();
3456
3457                                 pthread_mutex_unlock(&g_feedback_streaming_cb_mutex);
3458                         } else {
3459                                 vc_mgr_vc_tts_streaming_cb callback = NULL;
3460                                 void* user_data = NULL;
3461
3462                                 pthread_mutex_lock(&g_vc_tts_streaming_cb_mutex);
3463
3464                                 vc_mgr_client_get_vc_tts_streaming_cb(&callback, &user_data);
3465                                 if (NULL == callback) {
3466                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] vc tts streaming callback is null");
3467                                         vc_mgr_data_clear_feedback_data(&feedback_data);
3468                                         pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3469                                         return;
3470                                 }
3471
3472                                 SLOG(LOG_DEBUG, TAG_VCM, "vc tts feedback streaming callback is called");
3473                                 vc_mgr_client_use_callback();
3474                                 callback(feedback_data->pid, feedback_data->utt_id, feedback_data->event, feedback_data->data, feedback_data->data_size, user_data);
3475                                 vc_mgr_client_not_use_callback();
3476
3477                                 pthread_mutex_unlock(&g_vc_tts_streaming_cb_mutex);
3478                         }
3479                         free(feedback_data);
3480                         feedback_data = NULL;
3481                 }
3482         }
3483 }
3484
3485 static void __end_tts_feedback_thread(void* data, Ecore_Thread* thread)
3486 {
3487         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] End thread");
3488         g_feedback_thread = NULL;
3489 }
3490
3491 static void __cancel_tts_feedback_thread(void* data, Ecore_Thread* thread)
3492 {
3493         SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Cancel thread");
3494         g_feedback_thread = NULL;
3495 }
3496
3497 int vc_mgr_start_feedback(void)
3498 {
3499         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] start feedback");
3500
3501         int ret;
3502         ret = __check_mgr_feature_privilege();
3503         if (VC_ERROR_NONE != ret)
3504                 return ret;
3505
3506         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request start TTS feedback");
3507
3508         vc_state_e state;
3509         if (0 != vc_mgr_client_get_client_state(&state)) {
3510                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Start feedback : A handle is not available");
3511                 return VC_ERROR_INVALID_STATE;
3512         }
3513
3514         /* check state */
3515         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Start feedback : Current state is not 'Ready' (%d)", state);
3516
3517 #if 1
3518         bool is_exist = ecore_thread_check(g_feedback_thread);
3519         if (NULL == g_feedback_thread || TRUE == is_exist) {
3520                 SLOG(LOG_INFO, TAG_VCM, "[INFO] ecore thread run : __tts_feedback_thread");
3521                 g_feedback_thread = ecore_thread_run(__tts_feedback_thread, __end_tts_feedback_thread, __cancel_tts_feedback_thread, NULL);
3522         }
3523 #else
3524         /* start playing TTS feedback */
3525         int ret = -1;
3526         ret = vc_mgr_player_play();
3527         if (0 != ret) {
3528                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to player play, ret(%d)", ret);
3529         }
3530 #endif
3531         return VC_ERROR_NONE;
3532 }
3533
3534 int vc_mgr_stop_feedback(void)
3535 {
3536         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] stop feedback");
3537
3538         int ret;
3539         ret = __check_mgr_feature_privilege();
3540         if (VC_ERROR_NONE != ret)
3541                 return ret;
3542
3543         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] Request stop TTS feedback");
3544
3545         vc_state_e state;
3546         if (0 != vc_mgr_client_get_client_state(&state)) {
3547                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Stop feedback : A handle is not available");
3548                 return VC_ERROR_INVALID_STATE;
3549         }
3550
3551         /* check state */
3552         RETVM_IF(VC_STATE_READY != state, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Stop feedback : Current state is not 'Ready' (%d)", state);
3553
3554 #if 1
3555         if (g_feedback_thread) {
3556                 ecore_thread_cancel(g_feedback_thread);
3557                 g_feedback_thread = NULL;
3558         }
3559
3560         ret = -1;
3561         while (1) {
3562                 vc_feedback_data_s* feedback_data = NULL;
3563
3564                 /* get feedback data */
3565                 ret = vc_mgr_data_get_feedback_data(&feedback_data);
3566                 if (0 != ret || NULL == feedback_data) {
3567                         /* empty queue */
3568                         SLOG(LOG_INFO, TAG_VCM, "[INFO] No feedback data to stop any more");
3569                         return VC_ERROR_NONE;
3570                 }
3571                 ret = vc_mgr_data_clear_feedback_data(&feedback_data);
3572                 if (0 != ret) {
3573                         SLOG(LOG_INFO, TAG_VCM, "[ERROR] Fail to clear data, ret(%d)", ret);
3574                         break;
3575                 }
3576         }
3577 #else
3578         /* request to stop playing TTS feedback */
3579         int ret = -1;
3580         ret = vc_mgr_player_stop();
3581         if (0 != ret) {
3582                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to player stop, ret(%d)", ret);
3583         }
3584 #endif
3585         return ret;
3586 }
3587
3588 int vc_mgr_send_utterance_status(int pid, int utt_id, vc_tts_utterance_status_e utt_status)
3589 {
3590         SLOG(LOG_INFO, TAG_VCM, "@@@ [Manager] send utterance status, pid(%d), utt_id(%d), utt_status(%d)", pid, utt_id, utt_status);
3591
3592         int ret;
3593         ret = __check_mgr_feature_privilege();
3594         if (VC_ERROR_NONE != ret)
3595                 return ret;
3596
3597         if (VC_TTS_UTTERANCE_NONE > utt_status || VC_TTS_UTTERANCE_CANCELED < utt_status || 0 == utt_status) {
3598                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] utt_status is not valid. (%d)", utt_status);
3599                 return VC_ERROR_INVALID_PARAMETER;
3600         }
3601
3602         vc_state_e state;
3603         if (0 != vc_mgr_client_get_client_state(&state)) {
3604                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3605                 return VC_ERROR_INVALID_STATE;
3606         }
3607
3608         /* check state */
3609         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
3610
3611         /* Check service state */
3612         vc_service_state_e service_state = -1;
3613         vc_mgr_client_get_service_state(&service_state);
3614         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);
3615
3616         ret = vc_mgr_tidl_send_utterance_status(pid, utt_id, utt_status);
3617         if (0 != ret)
3618                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send utterance status : %s", __vc_mgr_get_error_code(ret));
3619         else
3620                 SLOG(LOG_INFO, TAG_VCM, "[SUCCESS] Send utterance status");
3621
3622         SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] send utterance status DONE");
3623         return ret;
3624 }
3625
3626 static float __get_volume_decibel(char* data, int size)
3627 {
3628 #define MAX_AMPLITUDE_MEAN_16 32768
3629
3630         int i, depthByte;
3631         int count = 0;
3632
3633         float db = 0.0;
3634         float rms = 0.0;
3635         unsigned long long square_sum = 0;
3636         short pcm16 = 0;
3637
3638         depthByte = 2;
3639
3640         for (i = 0; i < size; i += (depthByte<<1)) {
3641                 pcm16 = 0;
3642                 memcpy(&pcm16, data + i, sizeof(short));
3643                 square_sum += pcm16 * pcm16;
3644                 count++;
3645         }
3646
3647         if (0 == count || 0 == square_sum) {
3648                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No data");
3649                 rms = 1.0;
3650         } else {
3651                 rms = sqrt((float)square_sum/count);
3652         }
3653
3654         db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16);
3655         return db;
3656 }
3657
3658 int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
3659 {
3660         SLOG(LOG_INFO, TAG_VCM, "[Manager] Send audio streaming to the engine service, event(%d)", event);
3661
3662         int ret;
3663         ret = __check_mgr_feature_privilege();
3664         if (VC_ERROR_NONE != ret)
3665                 return ret;
3666
3667         if (VC_AUDIO_STREAMING_EVENT_FAIL > event || VC_AUDIO_STREAMING_EVENT_FINISH < event || 0 == event) {
3668                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] event is invalid parameter (%d)", event);
3669                 return VC_ERROR_INVALID_PARAMETER;
3670         }
3671
3672         RETVM_IF(NULL == buffer, VC_ERROR_INVALID_PARAMETER, TAG_VCM, "[ERROR] Invalid parameter");
3673
3674         vc_state_e state = VC_STATE_NONE;
3675         ret = vc_mgr_client_get_client_state(&state);
3676         if (0 != ret) {
3677                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3678                 return VC_ERROR_INVALID_STATE;
3679         }
3680
3681         RETVM_IF(state != VC_STATE_READY, VC_ERROR_INVALID_STATE, TAG_VCM, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", state);
3682
3683         vc_service_state_e service_state = VC_SERVICE_STATE_NONE;
3684         ret = vc_mgr_client_get_service_state(&service_state);
3685         if (0 != ret) {
3686                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3687                 return VC_ERROR_INVALID_STATE;
3688         }
3689
3690         if (VC_SERVICE_STATE_READY != service_state && VC_SERVICE_STATE_RECORDING != service_state) {
3691                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY' and 'RECORDING', state(%d)", service_state);
3692                 return VC_ERROR_INVALID_STATE;
3693         }
3694
3695         float volume = __get_volume_decibel((char*)buffer, len);
3696         __vc_mgr_set_volume(volume);
3697
3698         ret = vc_mgr_tidl_send_audio_streaming(g_pid, event, buffer, len);
3699         if (0 != ret)
3700                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data");
3701         else
3702                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to send");
3703         return ret;
3704 }
3705
3706 int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e mode)
3707 {
3708         SLOG(LOG_INFO, TAG_VCM, "[Manager] Set multi assistant mode, mode(%d)", mode);
3709
3710         int ret;
3711         ret = __check_mgr_feature_privilege();
3712         if (VC_ERROR_NONE != ret)
3713                 return ret;
3714
3715         if (VC_AUDIO_STREAMING_MODE_VC_SERVICE > mode || VC_AUDIO_STREAMING_MODE_OUTSIDE < mode) {
3716                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] mode is invalid parameter (%d)", mode);
3717                 return VC_ERROR_INVALID_PARAMETER;
3718         }
3719
3720         vc_state_e state = VC_STATE_NONE;
3721         ret = vc_mgr_client_get_client_state(&state);
3722         if (0 != ret) {
3723                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3724                 return VC_ERROR_INVALID_STATE;
3725         }
3726
3727         vc_service_state_e service_state = VC_SERVICE_STATE_NONE;
3728         ret = vc_mgr_client_get_service_state(&service_state);
3729         if (0 != ret) {
3730                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3731                 return VC_ERROR_INVALID_STATE;
3732         }
3733
3734         if (VC_STATE_INITIALIZED == state && VC_SERVICE_STATE_NONE == service_state) {
3735                 ret = vc_mgr_client_set_audio_streaming_mode(mode);
3736                 if (VC_ERROR_NONE != ret) {
3737                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret));
3738                         return VC_ERROR_INVALID_STATE;
3739                 } else {
3740                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client");
3741                 }
3742         } else if (VC_STATE_READY == state && VC_SERVICE_STATE_READY == service_state) {
3743                 ret = vc_mgr_client_set_audio_streaming_mode(mode);
3744                 if (VC_ERROR_NONE != ret) {
3745                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode : %s", __vc_mgr_get_error_code(ret));
3746                         return VC_ERROR_INVALID_STATE;
3747                 } else {
3748                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr client");
3749                 }
3750
3751                 ret = vc_mgr_tidl_request_set_audio_streaming_mode(g_pid, mode);
3752                 if (VC_ERROR_NONE != ret) {
3753                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %s", __vc_mgr_get_error_code(ret));
3754                         return VC_ERROR_OPERATION_FAILED;
3755                 } else {
3756                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio streaming mode in vc mgr tidl");
3757                 }
3758         } else {
3759                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'INITIALIZED', state(%d)", state);
3760                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current service state is not 'READY', service_state(%d)", service_state);
3761                 return VC_ERROR_INVALID_STATE;
3762         }
3763
3764         return VC_ERROR_NONE;
3765 }
3766
3767 //TODO it's internal api, so will remove it.
3768 int vc_mgr_change_system_volume(vc_system_volume_event_e event)
3769 {
3770         return vc_mgr_change_background_volume(event);
3771 }
3772
3773 //TODO it's internal api, so will remove it.
3774 int vc_mgr_recover_system_volume(void)
3775 {
3776         return vc_mgr_reset_background_volume();
3777 }
3778
3779 int vc_mgr_change_background_volume(vc_background_volume_event_e event)
3780 {
3781         SLOG(LOG_INFO, TAG_VCM, "[Manager] Change background volume. event(%d)", event);
3782
3783         int ret;
3784         ret = __check_mgr_feature_privilege();
3785         if (VC_ERROR_NONE != ret)
3786                 return ret;
3787
3788         if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD > event || VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_FARFIELD < event) {
3789                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] event is invalid parameter (%d)", event);
3790                 return VC_ERROR_INVALID_PARAMETER;
3791         }
3792
3793         vc_state_e state = VC_STATE_NONE;
3794         ret = vc_mgr_client_get_client_state(&state);
3795         if (VC_ERROR_NONE != ret) {
3796                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3797                 return VC_ERROR_INVALID_STATE;
3798         }
3799
3800         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3801                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3802                 return VC_ERROR_INVALID_STATE;
3803         }
3804
3805         double ratio = 0.0;
3806         if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_FARFIELD == event)
3807                 ratio = VC_MGR_DEFAULT_FARFIELD_DUCKING_RATIO;
3808         else if (VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD == event)
3809                 ratio = VC_MGR_DEFAULT_NEARFIELD_DUCKING_RATIO;
3810
3811         ret = vc_mgr_ducking_activate(ratio);
3812         if (VC_ERROR_NONE != ret)
3813                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to change volume");
3814         else
3815                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to change volume");
3816         return ret;
3817 }
3818
3819 int vc_mgr_change_background_volume_by_ratio(double ratio)
3820 {
3821         SLOG(LOG_INFO, TAG_VCM, "[Manager] Change background volume. ratio(%f)", ratio);
3822
3823         int ret;
3824         ret = __check_mgr_feature_privilege();
3825         if (VC_ERROR_NONE != ret)
3826                 return ret;
3827
3828         if (VC_MGR_MINIMUM_DUCKING_RATIO > ratio || VC_MGR_MAXIMUM_DUCKING_RATIO < ratio) {
3829                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] ratio is invalid parameter (%lf)", ratio);
3830                 return VC_ERROR_INVALID_PARAMETER;
3831         }
3832
3833         vc_state_e state = VC_STATE_NONE;
3834         ret = vc_mgr_client_get_client_state(&state);
3835         if (VC_ERROR_NONE != ret) {
3836                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3837                 return VC_ERROR_INVALID_STATE;
3838         }
3839
3840         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3841                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3842                 return VC_ERROR_INVALID_STATE;
3843         }
3844
3845         ret = vc_mgr_ducking_activate(ratio);
3846         if (VC_ERROR_NONE != ret)
3847                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set ratio");
3848         else
3849                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to set ratio");
3850
3851         return ret;
3852 }
3853
3854 int vc_mgr_reset_background_volume(void)
3855 {
3856         SLOG(LOG_INFO, TAG_VCM, "[Manager] Recover background volume");
3857
3858         int ret;
3859         ret = __check_mgr_feature_privilege();
3860         if (VC_ERROR_NONE != ret)
3861                 return ret;
3862
3863         vc_state_e state = VC_STATE_NONE;
3864         ret = vc_mgr_client_get_client_state(&state);
3865         if (VC_ERROR_NONE != ret) {
3866                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
3867                 return VC_ERROR_INVALID_STATE;
3868         }
3869
3870         if (state != VC_STATE_READY && state != VC_STATE_INITIALIZED) {
3871                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY' and not 'INITIALIZED', state(%d)", state);
3872                 return VC_ERROR_INVALID_STATE;
3873         }
3874
3875         ret = vc_mgr_ducking_deactivate();
3876         if (VC_ERROR_NONE != ret)
3877                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to recover volume");
3878         else
3879                 SLOG(LOG_INFO, TAG_VCM, "[DEBUG] Success to recover volume");
3880
3881         return ret;
3882 }