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         vc_cmd_list_s* list = NULL;
 796         list = (vc_cmd_list_s*)vc_cmd_list;
 797
 798         int i;
 799         int ret;
 800         bool success_save = false;
 801         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
 802                 ret = vc_cmd_parser_delete_file(getpid(), i);
 803                 if (0 != ret)
 804                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
 805
 806                 ret = vc_cmd_parser_save_file(getpid(), i, list->list, NULL);
 807                 if (0 != ret) {
 808                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save file, type(%d), ret(%d)", i, ret);
 809                 } else {
 810                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Save file, type(%d)", i);
 811                         success_save = true;
 812                 }
 813         }
 814
 815         if (true != success_save) {
 816                 ret = VC_ERROR_INVALID_PARAMETER;
 817                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret));
 818         } else {
 819                 int count = 0;
 820                 do {
 821                         ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
 822                         if (0 != ret) {
 823                                 if (VC_ERROR_TIMED_OUT != ret) {
 824                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
 825                                         break;
 826                                 } else {
 827                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request set command : %s", __vc_mgr_get_error_code(ret));
 828                                         usleep(10000);
 829                                         count++;
 830                                         if (VC_RETRY_COUNT == count) {
 831                                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 832                                                 break;
 833                                         }
 834                                 }
 835                         }
 836                 } while (0 != ret);
 837         }
 838
 839         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 840         SLOG(LOG_DEBUG, TAG_VCM, " ");
 841
 842         return ret;
 843 }
 844
 845 int vc_mgr_unset_command_list()
 846 {
 847         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Unset Command list");
 848
 849         vc_state_e state;
 850         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 851                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 852                 return VC_ERROR_INVALID_STATE;
 853         }
 854
 855         /* check state */
 856         if (state != VC_STATE_READY) {
 857                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Current state is not 'READY'");
 858                 return VC_ERROR_INVALID_STATE;
 859         }
 860
 861         int count = 0;
 862         int ret = -1;
 863         while (0 != ret) {
 864                 ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle);
 865                 if (0 != ret) {
 866                         if (VC_ERROR_TIMED_OUT != ret) {
 867                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret));
 868                                 break;
 869                         } else {
 870                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request unset command : %s", __vc_mgr_get_error_code(ret));
 871                                 usleep(10000);
 872                                 count++;
 873                                 if (VC_RETRY_COUNT == count) {
 874                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 875                                         break;
 876                                 }
 877                         }
 878                 }
 879         }
 880
 881         int i;
 882         for (i = VC_COMMAND_TYPE_FOREGROUND; i <= VC_COMMAND_TYPE_EXCLUSIVE; i++) {
 883                 ret = vc_cmd_parser_delete_file(getpid(), i);
 884                 if (0 != ret)
 885                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(%d), ret(%d)", i, ret);
 886         }
 887
 888         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 889         SLOG(LOG_DEBUG, TAG_VCM, " ");
 890
 891         return 0;
 892 }
 893
 894 int vc_mgr_set_command_list_from_file(const char* file_path, int type)
 895 {
 896         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list from file");
 897
 898         if (NULL == file_path) {
 899                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter!!");
 900                 return VC_ERROR_INVALID_PARAMETER;
 901         } else {
 902                 SLOG(LOG_DEBUG, TAG_VCM, "===== File path: %s", file_path);
 903         }
 904
 905         /* check type */
 906         if (VC_COMMAND_TYPE_FOREGROUND > type || VC_COMMAND_TYPE_EXCLUSIVE < type) {
 907                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Invalid command type: input type is %d", type);
 908                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 909                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 910                 return VC_ERROR_INVALID_PARAMETER;
 911         }
 912
 913         vc_state_e state;
 914         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 915                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 916                 return VC_ERROR_INVALID_STATE;
 917         }
 918
 919         /* check state */
 920         if (state != VC_STATE_READY) {
 921                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 922                 return VC_ERROR_INVALID_STATE;
 923         }
 924
 925         /* Check service state */
 926         vc_service_state_e service_state = -1;
 927         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 928         if (service_state != VC_SERVICE_STATE_READY) {
 929                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 930                 return VC_ERROR_INVALID_STATE;
 931         }
 932
 933         int ret = vc_cmd_parser_delete_file(getpid(), type);
 934         if (0 != ret)
 935                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to delete file, type(4), ret(%d)", ret);
 936
 937         if (0 != vc_json_set_commands_from_file(file_path, type, NULL)) {
 938                 ret = VC_ERROR_INVALID_PARAMETER;
 939                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command list (%d)", ret);
 940         } else {
 941                 int count = 0;
 942                 do {
 943                         ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
 944                         if (0 != ret) {
 945                                 if (VC_ERROR_TIMED_OUT != ret) {
 946                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
 947                                         break;
 948                                 } else {
 949                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request set command : %s", __vc_mgr_get_error_code(ret));
 950                                         usleep(10000);
 951                                         count++;
 952                                         if (VC_RETRY_COUNT == count) {
 953                                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 954                                                 break;
 955                                         }
 956                                 }
 957                         }
 958                 } while (0 != ret);
 959         }
 960
 961         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 962         SLOG(LOG_DEBUG, TAG_VCM, " ");
 963
 964         return ret;
 965 }
 966
 967 int vc_mgr_set_preloaded_commands_from_file(const char* file_path)
 968 {
 969         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set preloaded command list");
 970
 971         vc_state_e state;
 972         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 973                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 974                 return VC_ERROR_INVALID_STATE;
 975         }
 976
 977         /* check state */
 978         if (state != VC_STATE_READY) {
 979                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 980                 return VC_ERROR_INVALID_STATE;
 981         }
 982
 983         /* Check service state */
 984         vc_service_state_e service_state = -1;
 985         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 986         if (service_state != VC_SERVICE_STATE_READY) {
 987                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 988                 return VC_ERROR_INVALID_STATE;
 989         }
 990
 991         /* Only support to set background commands for preloaded application */
 992         int ret = vc_json_set_commands_from_file(file_path, VC_COMMAND_TYPE_BACKGROUND, NULL);
 993         if (0 != ret)
 994                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to insert preloaded commands into db");
 995
 996         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 997         SLOG(LOG_DEBUG, TAG_VCM, " ");
 998         return ret;
 999 }
1000
1001 int vc_mgr_set_audio_type(const char* audio_id)
1002 {
1003         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set audio type");
1004
1005         if (NULL == audio_id) {
1006                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1007                 return VC_ERROR_INVALID_PARAMETER;
1008         }
1009
1010         vc_state_e state;
1011         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1012                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1013                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1014                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1015                 return VC_ERROR_INVALID_STATE;
1016         }
1017
1018         /* check state */
1019         if (state != VC_STATE_READY) {
1020                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1021                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1022                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1023                 return VC_ERROR_INVALID_STATE;
1024         }
1025
1026         /* Check service state */
1027         vc_service_state_e service_state = -1;
1028         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1029         if (service_state != VC_SERVICE_STATE_READY) {
1030                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1031                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1032                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1033                 return VC_ERROR_INVALID_STATE;
1034         }
1035
1036         int ret;
1037         int count = 0;
1038
1039         /* Request */
1040         ret = -1;
1041         count = 0;
1042         while (0 != ret) {
1043                 ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id);
1044                 if (0 != ret) {
1045                         if (VC_ERROR_TIMED_OUT != ret) {
1046                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret));
1047                                 break;
1048                         } else {
1049                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set audio type : %s", __vc_mgr_get_error_code(ret));
1050                                 usleep(10000);
1051                                 count++;
1052                                 if (VC_RETRY_COUNT == count) {
1053                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1054                                         break;
1055                                 }
1056                         }
1057                 } else {
1058                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio type");
1059                         /* Save */
1060                         vc_mgr_client_set_audio_type(g_vc_m, audio_id);
1061                 }
1062         }
1063
1064         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1065         SLOG(LOG_DEBUG, TAG_VCM, " ");
1066
1067         return ret;
1068 }
1069
1070 int vc_mgr_get_audio_type(char** audio_id)
1071 {
1072         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get audio type");
1073
1074         if (NULL == audio_id) {
1075                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1076                 return VC_ERROR_INVALID_PARAMETER;
1077         }
1078
1079         vc_state_e state;
1080         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1081                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1082                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1083                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1084                 return VC_ERROR_INVALID_STATE;
1085         }
1086
1087         /* check state */
1088         if (state != VC_STATE_READY) {
1089                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1090                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1091                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1092                 return VC_ERROR_INVALID_STATE;
1093         }
1094
1095         /* Check service state */
1096         vc_service_state_e service_state = -1;
1097         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1098         if (service_state != VC_SERVICE_STATE_READY) {
1099                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1100                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1101                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1102                 return VC_ERROR_INVALID_STATE;
1103         }
1104
1105         char* temp = NULL;
1106
1107         vc_mgr_client_get_audio_type(g_vc_m, &temp);
1108
1109         if (NULL == temp) {
1110                 /* Not initiallized */
1111                 int ret = -1;
1112                 int count = 0;
1113                 while (0 != ret) {
1114                         ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp);
1115                         if (0 != ret) {
1116                                 if (VC_ERROR_TIMED_OUT != ret) {
1117                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret));
1118                                         break;
1119                                 } else {
1120                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to get audio type : %s", __vc_mgr_get_error_code(ret));
1121                                         usleep(10000);
1122                                         count++;
1123                                         if (VC_RETRY_COUNT == count) {
1124                                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1125                                                 break;
1126                                         }
1127                                 }
1128                         } else {
1129                                 SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
1130                                 /* Save */
1131                                 vc_mgr_client_set_audio_type(g_vc_m, temp);
1132                         }
1133                 }
1134         }
1135
1136         if (NULL != temp) {
1137                 *audio_id = strdup(temp);
1138                 free(temp);
1139                 temp = NULL;
1140         }
1141
1142         return 0;
1143 }
1144
1145 int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
1146 {
1147         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Foreach current commands");
1148
1149         vc_state_e state;
1150         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1151                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1152                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1153                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1154                 return VC_ERROR_INVALID_STATE;
1155         }
1156
1157         /* check state */
1158         if (state != VC_STATE_READY) {
1159                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1160                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1161                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1162                 return VC_ERROR_INVALID_STATE;
1163         }
1164
1165         /* Check service state */
1166         vc_service_state_e service_state = -1;
1167         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1168         if (service_state != VC_SERVICE_STATE_READY) {
1169                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1170                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1171                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1172                 return VC_ERROR_INVALID_STATE;
1173         }
1174
1175         if (NULL == vc_cmd_list) {
1176                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid Parameter");
1177                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1178                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1179                 return VC_ERROR_INVALID_PARAMETER;
1180         }
1181
1182         vc_cmd_list_h temp_list = NULL;
1183         if (0 != vc_cmd_list_create(&temp_list)) {
1184                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
1185                 return VC_ERROR_INVALID_PARAMETER;
1186         }
1187
1188         *vc_cmd_list = temp_list;
1189
1190         int fg_pid = 0;
1191         int mgr_pid = 0;
1192         int count = 0;
1193         int ret = -1;
1194
1195         /* Get foreground pid */
1196         if (0 != vc_mgr_client_get_foreground(g_vc_m, &fg_pid)) {
1197                 /* There is no foreground app for voice control */
1198                 SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
1199         } else {
1200                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
1201         }
1202
1203         if (0 != vc_mgr_client_get_pid(g_vc_m, &mgr_pid)) {
1204                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Fail to get manager pid");
1205                 return VC_ERROR_OPERATION_FAILED;
1206         } else {
1207                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
1208         }
1209
1210         /* Get system command */
1211         ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
1212         if (0 != ret) {
1213                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No system commands");
1214         }
1215
1216         /* Request */
1217         ret = -1;
1218         count = 0;
1219         while (0 != ret) {
1220                 ret = vc_mgr_dbus_request_set_client_info(g_vc_m->handle);
1221                 if (0 != ret) {
1222                         if (VC_ERROR_TIMED_OUT != ret) {
1223                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret));
1224                                 break;
1225                         } else {
1226                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set client info : %s", __vc_mgr_get_error_code(ret));
1227                                 usleep(10000);
1228                                 count++;
1229                                 if (VC_RETRY_COUNT == count) {
1230                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1231                                         break;
1232                                 }
1233                         }
1234                 } else {
1235                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set client info");
1236                 }
1237         }
1238
1239         GSList *iter = NULL;
1240         GSList* client_info_list = NULL;
1241         vc_client_info_s *client_info = NULL;
1242         bool is_fgpid = false;
1243
1244         if (0 != vc_info_parser_get_client_info(&client_info_list)) {
1245                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
1246                 return 0;
1247         }
1248
1249         if (VC_NO_FOREGROUND_PID != fg_pid) {
1250                 iter = g_slist_nth(client_info_list, 0);
1251                 while (NULL != iter) {
1252                         client_info = iter->data;
1253                         if (NULL != client_info) {
1254                                 if (fg_pid == client_info->pid) {
1255                                         is_fgpid = true;
1256                                         break;
1257                                 }
1258                         }
1259                         iter = g_slist_next(iter);
1260                 }
1261         }
1262
1263         /* Get foreground commands and widget */
1264         if (true == is_fgpid) {
1265                 /* Get handle */
1266                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
1267
1268                 /* Get foreground command */
1269                 if (true == client_info->fg_cmd) {
1270                         ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
1271                         if (0 != ret) {
1272                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
1273                         }
1274                 } else {
1275                         SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground commands");
1276                 }
1277
1278                 /* Check exclusive option */
1279                 if (true == client_info->exclusive_cmd) {
1280                         SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Exclusive command is ON");
1281
1282                         /* Set background command for exclusive option */
1283                         if (true == client_info->bg_cmd) {
1284                                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set background command");
1285                                 ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1286                                 if (0 != ret) {
1287                                         SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1288                                 }
1289                         }
1290
1291                         /* need to release client info */
1292                         iter = g_slist_nth(client_info_list, 0);
1293
1294                         while (NULL != iter) {
1295                                 client_info = iter->data;
1296                                 if (NULL != client_info) {
1297                                         free(client_info);
1298                                 }
1299                                 client_info_list = g_slist_remove_link(client_info_list, iter);
1300                                 iter = g_slist_nth(client_info_list, 0);
1301                         }
1302
1303                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1304                         SLOG(LOG_DEBUG, TAG_VCM, " ");
1305
1306                         return 0;
1307                 }
1308         } else {
1309                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
1310         }
1311
1312         /* Get background commands */
1313         if (0 < g_slist_length(client_info_list)) {
1314                 iter = g_slist_nth(client_info_list, 0);
1315
1316                 while (NULL != iter) {
1317                         client_info = iter->data;
1318
1319                         if (NULL != client_info) {
1320                                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
1321                                 if (true == client_info->bg_cmd) {
1322                                         ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1323                                         if (0 != ret) {
1324                                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1325                                         }
1326                                 }
1327                                 free(client_info);
1328                         }
1329                         client_info_list = g_slist_remove_link(client_info_list, iter);
1330
1331                         iter = g_slist_nth(client_info_list, 0);
1332                 }
1333         } else {
1334                 /* NO client */
1335                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No background commands");
1336         }
1337
1338         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1339         SLOG(LOG_DEBUG, TAG_VCM, " ");
1340
1341         return 0;
1342 }
1343
1344 int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
1345 {
1346         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set recognition mode = %d", mode);
1347
1348         vc_state_e state;
1349         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1350                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1351                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1352                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1353                 return VC_ERROR_INVALID_STATE;
1354         }
1355
1356         /* check state */
1357         if (state != VC_STATE_READY) {
1358                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1359                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1360                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1361                 return VC_ERROR_INVALID_STATE;
1362         }
1363
1364         /* Check service state */
1365         vc_service_state_e service_state = -1;
1366         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1367         if (service_state != VC_SERVICE_STATE_READY) {
1368                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1369                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1370                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1371                 return VC_ERROR_INVALID_STATE;
1372         }
1373
1374         vc_mgr_client_set_recognition_mode(g_vc_m, mode);
1375         return 0;
1376 }
1377
1378 int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
1379 {
1380         int ret = -1;
1381
1382         ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode);
1383         if (0 != ret) {
1384                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1385                 return ret;
1386         }
1387
1388         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
1389         return 0;
1390 }
1391
1392 int vc_mgr_set_private_data(const char* key, const char* data)
1393 {
1394         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set private data");
1395
1396         if (NULL == key) {
1397                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1398                 return VC_ERROR_INVALID_PARAMETER;
1399         }
1400
1401         vc_state_e state;
1402         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1403                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1404                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1405                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1406                 return VC_ERROR_INVALID_STATE;
1407         }
1408
1409         /* check state */
1410         if (state != VC_STATE_READY) {
1411                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1412                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1413                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1414                 return VC_ERROR_INVALID_STATE;
1415         }
1416
1417         /* Check service state */
1418         vc_service_state_e service_state = -1;
1419         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1420         if (service_state != VC_SERVICE_STATE_READY) {
1421                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1422                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1423                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1424                 return VC_ERROR_INVALID_STATE;
1425         }
1426
1427         int ret = -1;
1428         int count = 0;
1429         while (0 != ret) {
1430                 ret = vc_mgr_dbus_request_set_private_data(g_vc_m->handle, key, data);
1431                 if (0 != ret) {
1432                         if (VC_ERROR_TIMED_OUT != ret) {
1433                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to set private data request : %s", __vc_mgr_get_error_code(ret));
1434                                 break;
1435                         } else {
1436                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry set private data request : %s", __vc_mgr_get_error_code(ret));
1437                                 usleep(10000);
1438                                 count++;
1439                                 if (VC_RETRY_COUNT == count) {
1440                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1441                                         break;
1442                                 }
1443                         }
1444                 } else {
1445                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
1446                 }
1447         }
1448         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1449         SLOG(LOG_DEBUG, TAG_VCM, " ");
1450
1451         return 0;
1452 }
1453
1454 int vc_mgr_get_private_data(const char* key, char** data)
1455 {
1456         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get private data");
1457
1458         if (NULL == key || NULL == data) {
1459                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1460                 return VC_ERROR_INVALID_PARAMETER;
1461         }
1462
1463         vc_state_e state;
1464         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1465                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1466                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1467                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1468                 return VC_ERROR_INVALID_STATE;
1469         }
1470
1471         /* check state */
1472         if (state != VC_STATE_READY) {
1473                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1474                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1475                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1476                 return VC_ERROR_INVALID_STATE;
1477         }
1478
1479         /* Check service state */
1480         vc_service_state_e service_state = -1;
1481         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1482         if (service_state != VC_SERVICE_STATE_READY) {
1483                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1484                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1485                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1486                 return VC_ERROR_INVALID_STATE;
1487         }
1488
1489         int ret = -1;
1490         int count = 0;
1491         char* temp = NULL;
1492
1493         while (0 != ret) {
1494                 ret = vc_mgr_dbus_request_get_private_data(g_vc_m->handle, key, &temp);
1495                 if (0 != ret) {
1496                         if (VC_ERROR_TIMED_OUT != ret) {
1497                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to get private data request : %s", __vc_mgr_get_error_code(ret));
1498                                 break;
1499                         } else {
1500                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry get private data request : %s", __vc_mgr_get_error_code(ret));
1501                                 usleep(10000);
1502                                 count++;
1503                                 if (VC_RETRY_COUNT == count) {
1504                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1505                                         break;
1506                                 }
1507                         }
1508                 } else {
1509                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get private data, key(%s), data(%s)", key, temp);
1510                 }
1511         }
1512
1513         if (NULL != temp) {
1514                 *data = strdup(temp);
1515                 free(temp);
1516                 temp = NULL;
1517         }
1518
1519         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1520         SLOG(LOG_DEBUG, TAG_VCM, " ");
1521
1522         return 0;
1523 }
1524
1525 int vc_mgr_set_domain(const char* domain)
1526 {
1527         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set domain");
1528
1529         if (NULL == domain) {
1530                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1531                 return VC_ERROR_INVALID_PARAMETER;
1532         }
1533
1534         vc_state_e state;
1535         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1536                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1537                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1538                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1539                 return VC_ERROR_INVALID_STATE;
1540         }
1541
1542         /* check state */
1543         if (state != VC_STATE_READY) {
1544                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1545                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1546                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1547                 return VC_ERROR_INVALID_STATE;
1548         }
1549
1550         /* Check service state */
1551         vc_service_state_e service_state = -1;
1552         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1553         if (service_state != VC_SERVICE_STATE_READY) {
1554                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1555                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1556                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1557                 return VC_ERROR_INVALID_STATE;
1558         }
1559
1560         int ret = -1;
1561         int count = 0;
1562         while (0 != ret) {
1563                 ret = vc_mgr_dbus_request_set_domain(g_vc_m->handle, domain);
1564                 if (0 != ret) {
1565                         if (VC_ERROR_TIMED_OUT != ret) {
1566                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to set domain request : %s", __vc_mgr_get_error_code(ret));
1567                                 break;
1568                         } else {
1569                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry set domain request : %s", __vc_mgr_get_error_code(ret));
1570                                 usleep(10000);
1571                                 count++;
1572                                 if (VC_RETRY_COUNT == count) {
1573                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1574                                         break;
1575                                 }
1576                         }
1577                 } else {
1578                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set domain");
1579                 }
1580         }
1581         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1582         SLOG(LOG_DEBUG, TAG_VCM, " ");
1583
1584         return 0;
1585 }
1586
1587 int vc_mgr_do_action(vc_send_event_type_e type, char* send_event)
1588 {
1589         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] do action");
1590
1591         if (NULL == send_event) {
1592                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
1593                 return VC_ERROR_INVALID_PARAMETER;
1594         }
1595
1596         vc_state_e state;
1597         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1598                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1599                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1600                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1601                 return VC_ERROR_INVALID_STATE;
1602         }
1603
1604         /* check state */
1605         if (state != VC_STATE_READY) {
1606                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1607                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1608                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1609                 return VC_ERROR_INVALID_STATE;
1610         }
1611
1612         /* Check service state */
1613         vc_service_state_e service_state = -1;
1614         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1615         if (service_state != VC_SERVICE_STATE_READY) {
1616                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1617                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1618                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1619                 return VC_ERROR_INVALID_STATE;
1620         }
1621
1622         int ret = -1;
1623         int count = 0;
1624         while (0 != ret) {
1625                 ret = vc_mgr_dbus_request_do_action(g_vc_m->handle, type, send_event);
1626                 if (0 != ret) {
1627                         if (VC_ERROR_TIMED_OUT != ret) {
1628                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to do action request : %s", __vc_mgr_get_error_code(ret));
1629                                 break;
1630                         } else {
1631                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry do action request : %s", __vc_mgr_get_error_code(ret));
1632                                 usleep(10000);
1633                                 count++;
1634                                 if (VC_RETRY_COUNT == count) {
1635                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1636                                         break;
1637                                 }
1638                         }
1639                 } else {
1640                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] do action");
1641                 }
1642         }
1643         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1644         SLOG(LOG_DEBUG, TAG_VCM, " ");
1645
1646         return 0;
1647 }
1648
1649 int vc_mgr_start(bool exclusive_command_option)
1650 {
1651         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
1652
1653         vc_state_e state;
1654         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1655                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1656                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1657                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1658                 return VC_ERROR_INVALID_STATE;
1659         }
1660
1661         /* check state */
1662         if (state != VC_STATE_READY) {
1663                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1664                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1665                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1666                 return VC_ERROR_INVALID_STATE;
1667         }
1668
1669         /* Check service state */
1670         vc_service_state_e service_state = -1;
1671         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1672         if (service_state != VC_SERVICE_STATE_READY) {
1673                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1674                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1675                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1676                 return VC_ERROR_INVALID_STATE;
1677         }
1678
1679         /* Check internal state for async */
1680         vc_internal_state_e internal_state = -1;
1681         vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
1682         if (internal_state != VC_INTERNAL_STATE_NONE) {
1683                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invaid State : Internal state is NOT none : %d", internal_state);
1684                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1685         }
1686
1687         vc_mgr_client_set_exclusive_command(g_vc_m, exclusive_command_option);
1688
1689         bool start_by_client = false;
1690         if (0 != vc_mgr_client_get_start_by_client(g_vc_m, &start_by_client)) {
1691                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
1692         }
1693
1694         int ret;
1695         int count = 0;
1696         vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
1697         if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
1698                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1699         }
1700
1701         /* Request */
1702         ret = -1;
1703         count = 0;
1704         while (0 != ret) {
1705                 ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client);
1706                 if (0 != ret) {
1707                         if (VC_ERROR_TIMED_OUT != ret) {
1708                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
1709                                 break;
1710                         } else {
1711                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry start request start : %s", __vc_mgr_get_error_code(ret));
1712                                 usleep(10000);
1713                                 count++;
1714                                 if (VC_RETRY_COUNT == count) {
1715                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1716                                         vc_mgr_client_set_exclusive_command(g_vc_m, false);
1717                                         break;
1718                                 }
1719                         }
1720                 } else {
1721                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
1722                         vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STARTING);
1723                 }
1724         }
1725
1726         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1727         SLOG(LOG_DEBUG, TAG_VCM, " ");
1728
1729         return ret;
1730 }
1731
1732 int vc_mgr_stop()
1733 {
1734         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request stop");
1735
1736         vc_state_e state;
1737         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1738                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1739                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1740                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1741                 return VC_ERROR_INVALID_STATE;
1742         }
1743
1744         /* check state */
1745         if (state != VC_STATE_READY) {
1746                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: client state is not 'READY'");
1747                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1748                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1749                 return VC_ERROR_INVALID_STATE;
1750         }
1751
1752         /* Check service state */
1753         vc_service_state_e service_state = -1;
1754         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1755         if (service_state != VC_SERVICE_STATE_RECORDING) {
1756                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'RECORDING'");
1757                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1758                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1759                 return VC_ERROR_INVALID_STATE;
1760         }
1761
1762         /* Check internal state for async */
1763         vc_internal_state_e internal_state = -1;
1764         vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
1765         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1766                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1767                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1768         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1769                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1770                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1771         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1772                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1773                 return VC_ERROR_IN_PROGRESS_TO_READY;
1774         }
1775
1776         int ret = -1;
1777         int count = 0;
1778         /* do request */
1779         while (0 != ret) {
1780                 ret = vc_mgr_dbus_request_stop(g_vc_m->handle);
1781                 if (0 != ret) {
1782                         if (VC_ERROR_TIMED_OUT != ret) {
1783                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
1784                                 break;
1785                         } else {
1786                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry stop request : %s", __vc_mgr_get_error_code(ret));
1787                                 usleep(10000);
1788                                 count++;
1789                                 if (VC_RETRY_COUNT == count) {
1790                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1791                                         break;
1792                                 }
1793                         }
1794                 } else {
1795                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Stop recognition");
1796                         vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_STOPPING);
1797                 }
1798         }
1799
1800         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1801         SLOG(LOG_DEBUG, TAG_VCM, " ");
1802
1803         return ret;
1804 }
1805
1806 int vc_mgr_cancel()
1807 {
1808         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request cancel");
1809
1810         vc_state_e state;
1811         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1812                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1813                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1814                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1815                 return VC_ERROR_INVALID_STATE;
1816         }
1817
1818         /* check state */
1819         if (state != VC_STATE_READY) {
1820                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: client state is not 'READY'");
1821                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1822                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1823                 return VC_ERROR_INVALID_STATE;
1824         }
1825
1826         /* Check service state */
1827         vc_service_state_e service_state = -1;
1828         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1829         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1830                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1831                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1832                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1833                 return VC_ERROR_INVALID_STATE;
1834         }
1835
1836         vc_internal_state_e internal_state = -1;
1837         vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
1838         if (VC_INTERNAL_STATE_STARTING == internal_state) {
1839                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STARTING");
1840                 return VC_ERROR_IN_PROGRESS_TO_RECORDING;
1841         } else if (VC_INTERNAL_STATE_STOPPING == internal_state) {
1842                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is STOPPING");
1843                 return VC_ERROR_IN_PROGRESS_TO_PROCESSING;
1844         } else if (VC_INTERNAL_STATE_CANCELING == internal_state) {
1845                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State : Internal state is CANCELING");
1846                 return VC_ERROR_IN_PROGRESS_TO_READY;
1847         }
1848
1849         int ret = -1;
1850         int count = 0;
1851         while (0 != ret) {
1852                 ret = vc_mgr_dbus_request_cancel(g_vc_m->handle);
1853                 if (0 != ret) {
1854                         if (VC_ERROR_TIMED_OUT != ret) {
1855                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret));
1856                                 break;
1857                         } else {
1858                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry cancel request : %s", __vc_mgr_get_error_code(ret));
1859                                 usleep(10000);
1860                                 count++;
1861                                 if (VC_RETRY_COUNT == count) {
1862                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1863                                         break;
1864                                 }
1865                         }
1866                 } else {
1867                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Cancel recognition");
1868                         vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_CANCELING);
1869                 }
1870         }
1871
1872         vc_mgr_client_set_exclusive_command(g_vc_m, false);
1873
1874         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1875         SLOG(LOG_DEBUG, TAG_VCM, " ");
1876
1877         return ret;
1878 }
1879
1880 static int g_cnt = 0;
1881 static Eina_Bool __vc_mgr_set_volume(void* data)
1882 {
1883         g_cnt++;
1884         g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5 * g_cnt;
1885
1886         SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
1887
1888         if (0 == g_cnt % 5) {
1889                 return EINA_FALSE;
1890         }
1891         return EINA_TRUE;
1892 }
1893
1894 int __vc_mgr_cb_set_volume(float volume)
1895 {
1896         g_prev_volume_db = g_volume_db;
1897         g_cur_volume_db = volume;
1898
1899         g_volume_db = g_prev_volume_db + (g_cur_volume_db - g_prev_volume_db) / 5;
1900
1901         SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)(%f)", g_volume_db, g_cur_volume_db);
1902
1903         if (NULL != g_m_set_volume_timer) {
1904                 SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
1905                 ecore_timer_del(g_m_set_volume_timer);
1906         }
1907
1908         g_cnt = 1;
1909         g_m_set_volume_timer = ecore_timer_add(0.05, __vc_mgr_set_volume, NULL);
1910
1911         return 0;
1912 }
1913
1914 int vc_mgr_get_recording_volume(float* volume)
1915 {
1916         if (NULL == volume) {
1917                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1918                 return VC_ERROR_INVALID_PARAMETER;
1919         }
1920
1921         vc_service_state_e service_state = -1;
1922         if (0 != vc_mgr_client_get_service_state(g_vc_m, &service_state)) {
1923                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1924                 return VC_ERROR_INVALID_STATE;
1925         }
1926
1927         /* check state */
1928         if (VC_SERVICE_STATE_RECORDING != service_state) {
1929                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Service state is not 'RECORDING'");
1930                 return VC_ERROR_INVALID_STATE;
1931         }
1932
1933         *volume = g_volume_db;
1934
1935         return 0;
1936 }
1937
1938 int __vc_mgr_cb_set_foreground(int pid, bool value)
1939 {
1940         vc_mgr_client_set_foreground(g_vc_m, pid, value);
1941
1942         /* get authorized valid app */
1943         int tmp_pid;
1944         if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &tmp_pid)) {
1945                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
1946                 return VC_ERROR_INVALID_PARAMETER;
1947         }
1948
1949         if (true == value) {
1950                 /* compare & set valid */
1951                 if (tmp_pid != pid) {
1952                         SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1953
1954                         /* set authorized valid */
1955                         if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
1956                                 SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid);
1957                                 vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
1958                         } else {
1959                                 SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
1960                                 vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
1961                         }
1962                 }
1963         } else {
1964                 if (tmp_pid == pid) {
1965                         SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1966                         vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
1967                 }
1968         }
1969
1970         return 0;
1971 }
1972
1973 int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
1974 {
1975         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Select result");
1976
1977         /* Do not check state for 'restart continusly' mode */
1978
1979         vc_service_state_e service_state = -1;
1980         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1981         if (service_state != VC_SERVICE_STATE_PROCESSING) {
1982                 vc_recognition_mode_e recognition_mode;
1983                 vc_mgr_get_recognition_mode(&recognition_mode);
1984
1985                 if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
1986                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continously'");
1987                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1988                         SLOG(LOG_DEBUG, TAG_VCM, " ");
1989                         return VC_ERROR_INVALID_STATE;
1990                 }
1991         }
1992
1993         if (NULL != vc_cmd_list) {
1994                 int event = 0;
1995                 char* result_text = NULL;
1996
1997                 vc_mgr_client_get_all_result(g_vc_m, &event, &result_text);
1998
1999                 vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false);
2000
2001                 if (NULL != result_text) {
2002                         free(result_text);
2003                         result_text = NULL;
2004                 }
2005         }
2006
2007         int ret;
2008         int count = 0;
2009
2010         /* Request */
2011         ret = -1;
2012         count = 0;
2013         while (0 != ret) {
2014                 ret = vc_mgr_dbus_send_result_selection(g_vc_m->handle);
2015                 if (0 != ret) {
2016                         if (VC_ERROR_TIMED_OUT != ret) {
2017                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret));
2018                                 break;
2019                         } else {
2020                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry send result selection : %s", __vc_mgr_get_error_code(ret));
2021                                 usleep(10000);
2022                                 count++;
2023                                 if (VC_RETRY_COUNT == count) {
2024                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
2025                                         break;
2026                                 }
2027                         }
2028                 } else {
2029                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] result selection");
2030                 }
2031         }
2032
2033         vc_mgr_client_unset_all_result(g_vc_m);
2034
2035         SLOG(LOG_DEBUG, TAG_VCM, "=====");
2036         SLOG(LOG_DEBUG, TAG_VCM, " ");
2037
2038         return 0;
2039 }
2040
2041 static Eina_Bool __vc_mgr_set_select_result(void *data)
2042 {
2043         vc_mgr_set_selected_results(NULL);
2044         return EINA_FALSE;
2045 }
2046
2047 static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
2048 {
2049         char* temp_text = NULL;
2050         int event;
2051         char* temp_message = NULL;
2052         vc_cmd_list_h vc_cmd_list = NULL;
2053
2054         vc_mgr_all_result_cb all_callback = NULL;
2055         void* all_user_data = NULL;
2056
2057         vc_mgr_client_get_all_result_cb(g_vc_m, &all_callback, &all_user_data);
2058         if (NULL == all_callback) {
2059                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] All result callback is NULL");
2060                 return;
2061         }
2062
2063         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
2064                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
2065                 return;
2066         }
2067
2068         vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command(g_vc_m));
2069
2070         SLOG(LOG_INFO, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
2071                 result_type, temp_text, event, temp_message);
2072
2073         vc_cmd_print_list(vc_cmd_list);
2074
2075         bool cb_ret;
2076
2077         vc_mgr_client_use_callback(g_vc_m);
2078         cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data);
2079         vc_mgr_client_not_use_callback(g_vc_m);
2080
2081         if (true == vc_mgr_client_get_exclusive_command(g_vc_m)) {
2082                 /* exclusive */
2083                 vc_result_cb callback = NULL;
2084                 void* user_data = NULL;
2085
2086                 vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
2087                 if (NULL == callback) {
2088                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
2089                         return;
2090                 }
2091
2092                 vc_mgr_client_use_callback(g_vc_m);
2093                 callback(event, vc_cmd_list, temp_text, user_data);
2094                 vc_mgr_client_not_use_callback(g_vc_m);
2095                 SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called");
2096
2097                 /* Release result */
2098                 if (NULL != temp_text)  free(temp_text);
2099
2100                 /* Release list */
2101                 vc_cmd_list_destroy(vc_cmd_list, true);
2102
2103                 vc_mgr_client_set_exclusive_command(g_vc_m, false);
2104
2105                 return;
2106         }
2107
2108         int count = 0;
2109         vc_cmd_list_get_count(vc_cmd_list, &count);
2110         if (0 < count) {
2111                 vc_mgr_client_set_all_result(g_vc_m, event, temp_text);
2112                 if (true == cb_ret) {
2113                         SLOG(LOG_DEBUG, TAG_VCM, "Callback result is true");
2114                         if (VC_RESULT_TYPE_NOTIFICATION != result_type)
2115                                 ecore_idler_add(__vc_mgr_set_select_result, NULL);
2116                 } else {
2117                         SLOG(LOG_DEBUG, TAG_VCM, "Callback result is false");
2118                         /* need to select conflicted result */
2119                 }
2120         } else {
2121                 if (VC_RESULT_TYPE_NOTIFICATION != result_type)
2122                         ecore_idler_add(__vc_mgr_set_select_result, NULL);
2123
2124                 vc_mgr_client_set_exclusive_command(g_vc_m, false);
2125                 vc_mgr_client_unset_all_result(g_vc_m);
2126         }
2127
2128         /* Release result */
2129         if (NULL != temp_text) {
2130                 free(temp_text);
2131                 temp_text = NULL;
2132         }
2133
2134         /* Release list */
2135         vc_cmd_list_destroy(vc_cmd_list, true);
2136
2137         return;
2138 }
2139
2140 static Eina_Bool __vc_mgr_notify_result(void *data)
2141 {
2142         char* temp_text = NULL;
2143         int event;
2144         vc_cmd_list_h vc_cmd_list = NULL;
2145
2146         vc_result_cb callback = NULL;
2147         void* user_data = NULL;
2148
2149         vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
2150         if (NULL == callback) {
2151                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
2152                 return EINA_FALSE;
2153         }
2154
2155         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
2156                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
2157                 return EINA_FALSE;
2158         }
2159
2160         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
2161
2162         SLOG(LOG_INFO, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event);
2163
2164         vc_cmd_print_list(vc_cmd_list);
2165
2166         vc_mgr_client_use_callback(g_vc_m);
2167         callback(event, vc_cmd_list, temp_text, user_data);
2168         vc_mgr_client_not_use_callback(g_vc_m);
2169         SLOG(LOG_INFO, TAG_VCM, "Result callback called");
2170
2171         vc_cmd_list_destroy(vc_cmd_list, true);
2172
2173         /* Release result */
2174         if (NULL != temp_text)  free(temp_text);
2175
2176         return EINA_FALSE;
2177 }
2178
2179 void __vc_mgr_cb_all_result(vc_result_type_e type)
2180 {
2181         if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) {
2182                 __vc_mgr_notify_all_result(type);
2183         } else {
2184                 __vc_mgr_notify_result(0);
2185         }
2186
2187         return;
2188 }
2189
2190 void __vc_mgr_cb_pre_result(vc_pre_result_event_e event, const char* pre_result)
2191 {
2192         vc_mgr_pre_result_cb callback = NULL;
2193         void* user_data = NULL;
2194
2195         vc_mgr_client_get_pre_result_cb(g_vc_m, &callback, &user_data);
2196         if (NULL == callback) {
2197                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client pre result callback is NULL");
2198                 return;
2199         }
2200
2201         vc_mgr_client_use_callback(g_vc_m);
2202         callback(event, pre_result, user_data);
2203         vc_mgr_client_not_use_callback(g_vc_m);
2204         SLOG(LOG_DEBUG, TAG_VCM, "Pre result callback is called");
2205
2206         return;
2207 }
2208
2209 void __vc_mgr_cb_system_result()
2210 {
2211         __vc_mgr_notify_result(NULL);
2212         return;
2213 }
2214
2215 static Eina_Bool __vc_mgr_speech_detected(void *data)
2216 {
2217         vc_mgr_begin_speech_detected_cb callback = NULL;
2218         void* user_data = NULL;
2219
2220         vc_mgr_client_get_speech_detected_cb(g_vc_m, &callback, &user_data);
2221         if (NULL == callback) {
2222                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client speech detected callback is NULL");
2223                 return EINA_FALSE;
2224         }
2225
2226         vc_mgr_client_use_callback(g_vc_m);
2227         callback(user_data);
2228         vc_mgr_client_not_use_callback(g_vc_m);
2229         SLOG(LOG_DEBUG, TAG_VCM, "Speech detected callback called");
2230
2231         return EINA_FALSE;
2232 }
2233
2234 void __vc_mgr_cb_speech_detected()
2235 {
2236         __vc_mgr_speech_detected(NULL);
2237
2238         return;
2239 }
2240
2241 int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data)
2242 {
2243         if (NULL == callback)
2244                 return VC_ERROR_INVALID_PARAMETER;
2245
2246         vc_state_e state;
2247         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2248                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
2249                 return VC_ERROR_INVALID_STATE;
2250         }
2251
2252         /* check state */
2253         if (state != VC_STATE_INITIALIZED) {
2254                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : Current state is not 'Initialized'");
2255                 return VC_ERROR_INVALID_STATE;
2256         }
2257
2258         vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data);
2259
2260         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set all result callback");
2261
2262         return 0;
2263 }
2264
2265 int vc_mgr_unset_all_result_cb()
2266 {
2267         vc_state_e state;
2268         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2269                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
2270                 return VC_ERROR_INVALID_STATE;
2271         }
2272
2273         /* check state */
2274         if (state != VC_STATE_INITIALIZED) {
2275                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : Current state is not 'Initialized'");
2276                 return VC_ERROR_INVALID_STATE;
2277         }
2278
2279         vc_mgr_client_set_all_result_cb(g_vc_m, NULL, NULL);
2280
2281         return 0;
2282 }
2283
2284 int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data)
2285 {
2286         if (NULL == callback)
2287                 return VC_ERROR_INVALID_PARAMETER;
2288
2289         vc_state_e state;
2290         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2291                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
2292                 return VC_ERROR_INVALID_STATE;
2293         }
2294
2295         /* check state */
2296         if (state != VC_STATE_INITIALIZED) {
2297                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : Current state is not 'Initialized'");
2298                 return VC_ERROR_INVALID_STATE;
2299         }
2300
2301         vc_mgr_client_set_result_cb(g_vc_m, callback, user_data);
2302
2303         return 0;
2304 }
2305
2306 int vc_mgr_unset_result_cb()
2307 {
2308         vc_state_e state;
2309         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2310                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
2311                 return VC_ERROR_INVALID_STATE;
2312         }
2313
2314         /* check state */
2315         if (state != VC_STATE_INITIALIZED) {
2316                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : Current state is not 'Initialized'");
2317                 return VC_ERROR_INVALID_STATE;
2318         }
2319
2320         vc_mgr_client_set_result_cb(g_vc_m, NULL, NULL);
2321
2322         return 0;
2323 }
2324
2325 int vc_mgr_set_pre_result_cb(vc_mgr_pre_result_cb callback, void* user_data)
2326 {
2327         if (NULL == callback)
2328                 return VC_ERROR_INVALID_PARAMETER;
2329
2330         vc_state_e state;
2331         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2332                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set pre result callback : A handle is not available");
2333                 return VC_ERROR_INVALID_STATE;
2334         }
2335
2336         /* check state */
2337         if (state != VC_STATE_INITIALIZED) {
2338                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set pre result callback : Current state is not 'Initialized'");
2339                 return VC_ERROR_INVALID_STATE;
2340         }
2341
2342         vc_mgr_client_set_pre_result_cb(g_vc_m, callback, user_data);
2343
2344         return 0;
2345 }
2346
2347 int vc_mgr_unset_pre_result_cb()
2348 {
2349         vc_state_e state;
2350         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2351                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset pre result callback : A handle is not available");
2352                 return VC_ERROR_INVALID_STATE;
2353         }
2354
2355         /* check state */
2356         if (state != VC_STATE_INITIALIZED) {
2357                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset pre result callback : Current state is not 'Initialize'");
2358                 return VC_ERROR_INVALID_STATE;
2359         }
2360
2361         vc_mgr_client_set_pre_result_cb(g_vc_m, NULL, NULL);
2362
2363         return 0;
2364 }
2365
2366 int vc_mgr_get_error_message(char** err_msg)
2367 {
2368         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get error message");
2369
2370         if (NULL == err_msg) {
2371                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] invalid parameter");
2372                 return VC_ERROR_INVALID_PARAMETER;
2373         }
2374
2375         if (false == g_err_callback_status) {
2376                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not in error callback");
2377                 return VC_ERROR_OPERATION_FAILED;
2378         }
2379
2380         int ret;
2381         ret = vc_mgr_client_get_error_message(g_vc_m, err_msg);
2382         if (0 != ret) {
2383                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get error message");
2384         }
2385
2386         SLOG(LOG_DEBUG, TAG_VCM, "=====");
2387         SLOG(LOG_DEBUG, TAG_VCM, " ");
2388
2389         return ret;
2390 }
2391
2392 static Eina_Bool __vc_mgr_notify_error(void *data)
2393 {
2394         vc_h vc_m = (vc_h)data;
2395
2396         vc_error_cb callback = NULL;
2397         void* user_data = NULL;
2398         int reason;
2399
2400         vc_mgr_client_get_error_cb(vc_m, &callback, &user_data);
2401         vc_mgr_client_get_error(vc_m, &reason);
2402
2403         if (NULL != callback) {
2404                 vc_mgr_client_use_callback(vc_m);
2405                 g_err_callback_status = true;
2406                 callback(reason, user_data);
2407                 g_err_callback_status = false;
2408                 vc_mgr_client_not_use_callback(vc_m);
2409                 SLOG(LOG_DEBUG, TAG_VCM, "Error callback is called");
2410         } else {
2411                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
2412         }
2413
2414         return EINA_FALSE;
2415 }
2416
2417 int __vc_mgr_cb_error(int reason, int daemon_pid, char* msg)
2418 {
2419         vc_state_e state;
2420         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2421                 SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Invalid client");
2422                 return -1;
2423         }
2424
2425         /* check state */
2426         if (state != VC_STATE_READY) {
2427                 SLOG(LOG_ERROR, TAG_VCM, "[WARNING] not connected client yet");
2428                 return -1;
2429         }
2430
2431         vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
2432
2433         if (VC_ERROR_SERVICE_RESET == reason) {
2434                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] VC daemon reset");
2435
2436                 vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED);
2437                 __vc_mgr_notify_state_changed(g_vc_m);
2438
2439                 if (0 != vc_mgr_prepare()) {
2440                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to prepare");
2441                 }
2442         }
2443
2444         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Error reason(%d), msg(%s)", reason, msg);
2445
2446         vc_mgr_client_set_error(g_vc_m, reason);
2447         vc_mgr_client_set_error_message(g_vc_m, msg);
2448         __vc_mgr_notify_error(g_vc_m);
2449
2450         return 0;
2451 }
2452
2453 static Eina_Bool __vc_mgr_notify_state_changed(void *data)
2454 {
2455         vc_state_changed_cb changed_callback = NULL;
2456         void* user_data;
2457
2458         vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data);
2459
2460         vc_state_e current_state;
2461         vc_state_e before_state;
2462
2463         vc_mgr_client_get_before_state(g_vc_m, &current_state, &before_state);
2464
2465         if (NULL != changed_callback) {
2466                 vc_mgr_client_use_callback(g_vc_m);
2467                 changed_callback(before_state, current_state, user_data);
2468                 vc_mgr_client_not_use_callback(g_vc_m);
2469                 SLOG(LOG_DEBUG, TAG_VCM, "State changed callback is called");
2470         } else {
2471                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
2472         }
2473
2474         return EINA_FALSE;
2475 }
2476
2477 int vc_mgr_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
2478 {
2479         if (callback == NULL)
2480                 return VC_ERROR_INVALID_PARAMETER;
2481
2482         vc_state_e state;
2483         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2484                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2485                 return VC_ERROR_INVALID_STATE;
2486         }
2487
2488         /* check state */
2489         if (state != VC_STATE_INITIALIZED) {
2490                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2491                 return VC_ERROR_INVALID_STATE;
2492         }
2493
2494         vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data);
2495
2496         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set state changed callback");
2497         return 0;
2498 }
2499
2500 int vc_mgr_unset_state_changed_cb()
2501 {
2502         vc_state_e state;
2503         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2504                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2505                 return VC_ERROR_INVALID_STATE;
2506         }
2507
2508         /* check state */
2509         if (state != VC_STATE_INITIALIZED) {
2510                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2511                 return VC_ERROR_INVALID_STATE;
2512         }
2513
2514         vc_mgr_client_set_state_changed_cb(g_vc_m, NULL, NULL);
2515
2516         return 0;
2517 }
2518
2519 int __vc_mgr_cb_service_state(int state)
2520 {
2521         vc_service_state_e current_state = (vc_service_state_e)state;
2522         vc_service_state_e before_state;
2523         vc_mgr_client_get_service_state(g_vc_m, &before_state);
2524
2525         if (current_state == before_state) {
2526                 SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : Before(%d) Current(%d)",
2527                         before_state, current_state);
2528                 return 0;
2529         }
2530
2531         SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
2532                 before_state, current_state);
2533
2534         vc_internal_state_e internal_state = -1;
2535         vc_mgr_client_get_internal_state(g_vc_m, &internal_state);
2536         if ((VC_INTERNAL_STATE_STARTING == internal_state && VC_SERVICE_STATE_RECORDING == current_state) ||
2537                 (VC_INTERNAL_STATE_STOPPING == internal_state && VC_SERVICE_STATE_PROCESSING == current_state) ||
2538                 (VC_INTERNAL_STATE_CANCELING == internal_state && VC_SERVICE_STATE_READY == current_state)) {
2539                         SLOG(LOG_DEBUG, TAG_VCM, "Internal state is changed to NONE");
2540                         vc_mgr_client_set_internal_state(g_vc_m, VC_INTERNAL_STATE_NONE);
2541         }
2542
2543         /* Save service state */
2544         vc_mgr_client_set_service_state(g_vc_m, current_state);
2545
2546         vc_service_state_changed_cb callback = NULL;
2547         void* service_user_data = NULL;
2548         vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
2549
2550         if (NULL != callback) {
2551                 vc_mgr_client_use_callback(g_vc_m);
2552                 callback(before_state, current_state, service_user_data);
2553                 vc_mgr_client_not_use_callback(g_vc_m);
2554                 SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
2555         } else {
2556                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
2557         }
2558
2559         return 0;
2560 }
2561
2562 int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
2563 {
2564         if (callback == NULL)
2565                 return VC_ERROR_INVALID_PARAMETER;
2566
2567         vc_state_e state;
2568         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2569                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2570                 return VC_ERROR_INVALID_STATE;
2571         }
2572
2573         /* check state */
2574         if (state != VC_STATE_INITIALIZED) {
2575                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
2576                 return VC_ERROR_INVALID_STATE;
2577         }
2578
2579         vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data);
2580
2581         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set sevice state changed callback");
2582         return 0;
2583 }
2584
2585 int vc_mgr_unset_service_state_changed_cb()
2586 {
2587         vc_state_e state;
2588         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2589                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2590                 return VC_ERROR_INVALID_STATE;
2591         }
2592
2593         /* check state */
2594         if (state != VC_STATE_INITIALIZED) {
2595                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2596                 return VC_ERROR_INVALID_STATE;
2597         }
2598
2599         vc_mgr_client_set_service_state_changed_cb(g_vc_m, NULL, NULL);
2600         return 0;
2601 }
2602
2603 int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data)
2604 {
2605         if (callback == NULL)
2606                 return VC_ERROR_INVALID_PARAMETER;
2607
2608         vc_state_e state;
2609         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2610                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
2611                 return VC_ERROR_INVALID_STATE;
2612         }
2613
2614         /* check state */
2615         if (state != VC_STATE_INITIALIZED) {
2616                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set speech detected callback : Current state is not 'Initialized'");
2617                 return VC_ERROR_INVALID_STATE;
2618         }
2619
2620         vc_mgr_client_set_speech_detected_cb(g_vc_m, callback, user_data);
2621
2622         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set speech detected callback");
2623         return 0;
2624 }
2625
2626 int vc_mgr_unset_speech_detected_cb()
2627 {
2628         vc_state_e state;
2629         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2630                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
2631                 return VC_ERROR_INVALID_STATE;
2632         }
2633
2634         /* check state */
2635         if (state != VC_STATE_INITIALIZED) {
2636                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
2637                 return VC_ERROR_INVALID_STATE;
2638         }
2639
2640         vc_mgr_client_set_speech_detected_cb(g_vc_m, NULL, NULL);
2641         return 0;
2642 }
2643
2644 int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
2645 {
2646         if (NULL == callback)
2647                 return VC_ERROR_INVALID_PARAMETER;
2648
2649         vc_state_e state;
2650         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2651                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : A handle is not available");
2652                 return VC_ERROR_INVALID_STATE;
2653         }
2654
2655         /* check state */
2656         if (state != VC_STATE_INITIALIZED) {
2657                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : Current state is not 'Initialized'");
2658                 return VC_ERROR_INVALID_STATE;
2659         }
2660
2661         vc_mgr_client_set_current_lang_changed_cb(g_vc_m, callback, user_data);
2662
2663         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set current language changed callback");
2664         return 0;
2665 }
2666
2667 int vc_mgr_unset_current_language_changed_cb()
2668 {
2669         vc_state_e state;
2670         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2671                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : A handle is not available");
2672                 return VC_ERROR_INVALID_STATE;
2673         }
2674
2675         /* check state */
2676         if (state != VC_STATE_INITIALIZED) {
2677                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
2678                 return VC_ERROR_INVALID_STATE;
2679         }
2680
2681         vc_mgr_client_set_current_lang_changed_cb(g_vc_m, NULL, NULL);
2682
2683         return 0;
2684 }
2685
2686 int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data)
2687 {
2688         if (NULL == callback)
2689                 return VC_ERROR_INVALID_PARAMETER;
2690
2691         vc_state_e state;
2692         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2693                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2694                 return VC_ERROR_INVALID_STATE;
2695         }
2696
2697         /* check state */
2698         if (state != VC_STATE_INITIALIZED) {
2699                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : Current state is not 'Initialized'");
2700                 return VC_ERROR_INVALID_STATE;
2701         }
2702
2703         vc_mgr_client_set_error_cb(g_vc_m, callback,  user_data);
2704
2705         return 0;
2706 }
2707
2708 int vc_mgr_unset_error_cb()
2709 {
2710         vc_state_e state;
2711         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2712                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2713                 return VC_ERROR_INVALID_STATE;
2714         }
2715
2716         /* check state */
2717         if (state != VC_STATE_INITIALIZED) {
2718                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2719                 return VC_ERROR_INVALID_STATE;
2720         }
2721
2722         vc_mgr_client_set_error_cb(g_vc_m, NULL, NULL);
2723
2724         return 0;
2725 }
2726
2727 int __vc_mgr_cb_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
2728 {
2729         vc_mgr_dialog_request_cb callback = NULL;
2730         void* user_data = NULL;
2731
2732         vc_mgr_client_get_dialog_request_cb(g_vc_m, &callback, &user_data);
2733
2734         if (NULL != callback) {
2735                 vc_mgr_client_use_callback(g_vc_m);
2736                 callback(pid, disp_text, utt_text, continuous, user_data);
2737                 vc_mgr_client_not_use_callback(g_vc_m);
2738                 SLOG(LOG_DEBUG, TAG_VCM, "Dialog callback is called");
2739         } else {
2740                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
2741         }
2742
2743         return 0;
2744 }
2745
2746 int vc_mgr_set_dialog_request_cb(vc_mgr_dialog_request_cb callback, void* user_data)
2747 {
2748         if (NULL == callback)
2749                 return VC_ERROR_INVALID_PARAMETER;
2750
2751         vc_state_e state;
2752         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2753                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
2754                 return VC_ERROR_INVALID_STATE;
2755         }
2756
2757         /* check state */
2758         if (state != VC_STATE_INITIALIZED) {
2759                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : Current state is not 'Initialized'");
2760                 return VC_ERROR_INVALID_STATE;
2761         }
2762
2763         vc_mgr_client_set_dialog_request_cb(g_vc_m, callback,  user_data);
2764
2765         return 0;
2766 }
2767
2768 int vc_mgr_unset_dialog_request_cb()
2769 {
2770         vc_state_e state;
2771         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
2772                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
2773                 return VC_ERROR_INVALID_STATE;
2774         }
2775
2776         /* check state */
2777         if (state != VC_STATE_INITIALIZED) {
2778                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : Current state is not 'Initialized'");
2779                 return VC_ERROR_INVALID_STATE;
2780         }
2781
2782         vc_mgr_client_set_dialog_request_cb(g_vc_m, NULL, NULL);
2783
2784         return 0;
2785 }
2786
2787 static bool __vc_mgr_check_demandable_client(int pid)
2788 {
2789         if (0 == g_slist_length(g_demandable_client_list)) {
2790                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] No demandable clients");
2791                 return false;
2792         }
2793
2794         char appid[128] = {'\0', };
2795         aul_app_get_appid_bypid(pid, appid, sizeof(appid));
2796
2797         if (0 >= strlen(appid)) {
2798                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No appid");
2799                 return false;
2800         }
2801         SLOG(LOG_DEBUG, TAG_VCM, "[CHECK] Appid - %s", appid);
2802
2803         GSList *iter = NULL;
2804         vc_demandable_client_s* temp_client;
2805         iter = g_slist_nth(g_demandable_client_list, 0);
2806
2807         while (NULL != iter) {
2808                 temp_client = iter->data;
2809
2810                 if (NULL != temp_client) {
2811                         if (NULL != temp_client->appid) {
2812                                 if (!strcmp(temp_client->appid, appid)) {
2813                                         SLOG(LOG_DEBUG, TAG_VCM, "pid(%d) is available", pid);
2814                                         return true;
2815                                 }
2816                         }
2817                 }
2818
2819                 iter = g_slist_next(iter);
2820         }
2821
2822         return false;
2823 }
2824
2825 /* Authority */
2826 int __vc_mgr_request_auth_enable(int pid)
2827 {
2828         if (false == __vc_mgr_check_demandable_client(pid)) {
2829                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not demandable client");
2830                 return VC_ERROR_INVALID_PARAMETER;
2831         }
2832
2833         /* check already authorized */
2834         if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
2835                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already authorized");
2836                 return VC_ERROR_INVALID_PARAMETER;
2837         }
2838
2839         /* add authorized list */
2840         if (0 != vc_mgr_client_add_authorized_client(g_vc_m, pid)) {
2841                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add authorized client");
2842                 return VC_ERROR_OPERATION_FAILED;
2843         }
2844
2845         /* foreground check */
2846         int fore_pid = 0;
2847         if (0 != vc_mgr_client_get_foreground(g_vc_m, &fore_pid)) {
2848                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground");
2849                 return VC_ERROR_OPERATION_FAILED;
2850         }
2851
2852         if (pid == fore_pid) {
2853                 vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
2854         }
2855
2856         return 0;
2857 }
2858
2859 int __vc_mgr_request_auth_disable(int pid)
2860 {
2861         /* check authorized */
2862         if (false == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
2863                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No authorized");
2864                 return VC_ERROR_INVALID_PARAMETER;
2865         }
2866
2867         /* remove authorized list */
2868         if (0 != vc_mgr_client_remove_authorized_client(g_vc_m, pid)) {
2869                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to remove authorized client");
2870                 return VC_ERROR_OPERATION_FAILED;
2871         }
2872
2873         /* check authority valid */
2874         if (true == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2875                 SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed");
2876                 if (0 != vc_mgr_client_set_valid_authorized_client(g_vc_m, -1)) {
2877                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set valid authorized client");
2878                         return VC_ERROR_OPERATION_FAILED;
2879                 }
2880         }
2881
2882         return 0;
2883 }
2884
2885 static Eina_Bool __request_auth_start(void* data)
2886 {
2887         SLOG(LOG_DEBUG, TAG_VCM, "Request Start");
2888
2889         if (0 != vc_mgr_client_set_start_by_client(g_vc_m, true)) {
2890                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
2891         }
2892
2893         if (0 != vc_mgr_start(false)) {
2894                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed");
2895                 /* TODO - Error handling? */
2896         }
2897
2898         if (0 != vc_mgr_client_set_start_by_client(g_vc_m, false)) {
2899                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
2900         }
2901
2902
2903         return EINA_FALSE;
2904 }
2905
2906 int __vc_mgr_request_auth_start(int pid)
2907 {
2908         /* check authorized */
2909         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2910                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
2911                 return VC_ERROR_INVALID_PARAMETER;
2912         }
2913
2914         /* add timer for start recording */
2915         ecore_timer_add(0, __request_auth_start, NULL);
2916
2917         return 0;
2918 }
2919
2920 static Eina_Bool __request_auth_stop(void* data)
2921 {
2922         SLOG(LOG_DEBUG, TAG_VCM, "Request Stop");
2923
2924         if (0 != vc_mgr_stop()) {
2925                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed");
2926                 /* TODO - Error handling? */
2927         }
2928
2929         return EINA_FALSE;
2930 }
2931
2932 int __vc_mgr_request_auth_stop(int pid)
2933 {
2934         /* check authorized */
2935         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2936                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
2937                 return VC_ERROR_INVALID_PARAMETER;
2938         }
2939
2940         /* add timer for start recording */
2941         ecore_timer_add(0, __request_auth_stop, NULL);
2942
2943         return 0;
2944 }
2945
2946 static Eina_Bool __request_auth_cancel(void* data)
2947 {
2948         SLOG(LOG_DEBUG, TAG_VCM, "Request Cancel");
2949
2950         if (0 != vc_mgr_cancel()) {
2951                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed");
2952                 /* TODO - Error handling? */
2953         }
2954
2955         return EINA_FALSE;
2956 }
2957
2958 int __vc_mgr_request_auth_cancel(int pid)
2959 {
2960         /* check authorized */
2961         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2962                 SLOG(LOG_ERROR,  TAG_VCM, "[ERROR] No valid authorized client");
2963                 return VC_ERROR_INVALID_PARAMETER;
2964         }
2965
2966         /* add timer for start recording */
2967         ecore_timer_add(0, __request_auth_cancel, NULL);
2968
2969         return 0;
2970 }