client/vc_mgr.c

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