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