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