client/vc_mgr.c

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