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