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