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