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