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