client/vc_mgr.c

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