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