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 <aul.h>
  18
  19 #include "vc_info_parser.h"
  20 #include "vc_config_mgr.h"
  21 #include "vc_command.h"
  22 #include "vc_main.h"
  23 #include "vc_mgr_client.h"
  24 #include "vc_mgr_dbus.h"
  25 #include "voice_control.h"
  26 #include "voice_control_command.h"
  27 #include "voice_control_command_expand.h"
  28 #include "voice_control_common.h"
  29 #include "voice_control_manager.h"
  30
  31
  32 #define VC_MANAGER_CONFIG_HANDLE        100000
  33
  34 static Ecore_Timer* g_m_connect_timer = NULL;
  35
  36 static vc_h g_vc_m = NULL;
  37
  38 static GSList* g_demandable_client_list = NULL;
  39
  40 static float g_volume_db = 0;
  41
  42 static Eina_Bool __vc_mgr_notify_state_changed(void *data);
  43 static Eina_Bool __vc_mgr_notify_error(void *data);
  44 static Eina_Bool __vc_mgr_notify_result(void *data);
  45
  46 static const char* __vc_mgr_get_error_code(vc_error_e err)
  47 {
  48         switch (err) {
  49         case VC_ERROR_NONE:                     return "VC_ERROR_NONE";                 break;
  50         case VC_ERROR_OUT_OF_MEMORY:            return "VC_ERROR_OUT_OF_MEMORY";        break;
  51         case VC_ERROR_IO_ERROR:                 return "VC_ERROR_IO_ERROR";             break;
  52         case VC_ERROR_INVALID_PARAMETER:        return "VC_ERROR_INVALID_PARAMETER";    break;
  53         case VC_ERROR_TIMED_OUT:                return "VC_ERROR_TIMED_OUT";            break;
  54         case VC_ERROR_RECORDER_BUSY:            return "VC_ERROR_RECORDER_BUSY";        break;
  55         case VC_ERROR_INVALID_STATE:            return "VC_ERROR_INVALID_STATE";        break;
  56         case VC_ERROR_INVALID_LANGUAGE:         return "VC_ERROR_INVALID_LANGUAGE";     break;
  57         case VC_ERROR_ENGINE_NOT_FOUND:         return "VC_ERROR_ENGINE_NOT_FOUND";     break;
  58         case VC_ERROR_OPERATION_FAILED:         return "VC_ERROR_OPERATION_FAILED";     break;
  59         default:                                return "Invalid error code";            break;
  60         }
  61         return NULL;
  62 }
  63
  64 static void __vc_mgr_lang_changed_cb(const char* before_lang, const char* current_lang)
  65 {
  66         SLOG(LOG_DEBUG, TAG_VCM, "Lang changed : Before lang(%s) Current lang(%s)",
  67                                 before_lang, current_lang);
  68
  69         vc_current_language_changed_cb callback = NULL;
  70         void* lang_user_data;
  71         vc_mgr_client_get_current_lang_changed_cb(g_vc_m, &callback, &lang_user_data);
  72
  73         if (NULL != callback) {
  74                 vc_mgr_client_use_callback(g_vc_m);
  75                 callback(before_lang, current_lang, lang_user_data);
  76                 vc_mgr_client_not_use_callback(g_vc_m);
  77                 SLOG(LOG_DEBUG, TAG_VCM, "Language changed callback is called");
  78         } else {
  79                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Language changed callback is null");
  80         }
  81
  82         return;
  83 }
  84
  85 int vc_mgr_initialize()
  86 {
  87         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Initialize");
  88
  89         /* check handle */
  90         if (true == vc_mgr_client_is_valid(g_vc_m)) {
  91                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already initialized");
  92                 return VC_ERROR_NONE;
  93         }
  94
  95         if (0 != vc_mgr_dbus_open_connection()) {
  96                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to open connection");
  97                 return VC_ERROR_OPERATION_FAILED;
  98         }
  99
 100         if (0 != vc_mgr_client_create(&g_vc_m)) {
 101                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create client!!!!!");
 102                 return VC_ERROR_OUT_OF_MEMORY;
 103         }
 104
 105         int ret = vc_config_mgr_initialize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
 106         if (0 != ret) {
 107                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to init config manager : %d", ret);
 108                 vc_mgr_client_destroy(g_vc_m);
 109                 return VC_ERROR_OPERATION_FAILED;
 110         }
 111
 112         ret = vc_config_mgr_set_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE, __vc_mgr_lang_changed_cb);
 113         if (0 != ret) {
 114                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set callback : %d", ret);
 115                 vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
 116                 vc_mgr_client_destroy(g_vc_m);
 117                 return VC_ERROR_OPERATION_FAILED;
 118         }
 119
 120         SLOG(LOG_DEBUG, TAG_VCM, "[Success] pid(%d)", g_vc_m->handle);
 121
 122         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 123         SLOG(LOG_DEBUG, TAG_VCM, " ");
 124
 125         return VC_ERROR_NONE;
 126 }
 127
 128 static void __vc_mgr_internal_unprepare()
 129 {
 130         int ret = vc_mgr_dbus_request_finalize(g_vc_m->handle);
 131         if (0 != ret) {
 132                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request finalize : %s", __vc_mgr_get_error_code(ret));
 133         }
 134
 135         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
 136         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
 137
 138         return;
 139 }
 140
 141 int vc_mgr_deinitialize()
 142 {
 143         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Deinitialize");
 144
 145         if (false == vc_mgr_client_is_valid(g_vc_m)) {
 146                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] NOT initialized");
 147                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 148                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 149                 return VC_ERROR_INVALID_STATE;
 150         }
 151
 152         vc_state_e state;
 153         vc_mgr_client_get_client_state(g_vc_m, &state);
 154
 155         /* check state */
 156         switch (state) {
 157         case VC_STATE_READY:
 158                 __vc_mgr_internal_unprepare();
 159                 /* no break. need to next step*/
 160         case VC_STATE_INITIALIZED:
 161                 if (NULL != g_m_connect_timer) {
 162                         SLOG(LOG_DEBUG, TAG_VCM, "Connect Timer is deleted");
 163                         ecore_timer_del(g_m_connect_timer);
 164                 }
 165
 166                 vc_config_mgr_unset_lang_cb(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
 167                 vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
 168
 169                 /* Free client resources */
 170                 vc_mgr_client_destroy(g_vc_m);
 171                 g_vc_m = NULL;
 172                 break;
 173         case VC_STATE_NONE:
 174                 break;
 175         default:
 176                 break;
 177         }
 178
 179         SLOG(LOG_DEBUG, TAG_VCM, "Success: destroy");
 180
 181         if (0 != vc_mgr_dbus_close_connection()) {
 182                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to close connection");
 183         }
 184
 185         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 186         SLOG(LOG_DEBUG, TAG_VCM, " ");
 187
 188         return VC_ERROR_NONE;
 189 }
 190
 191 static Eina_Bool __vc_mgr_connect_daemon(void *data)
 192 {
 193         /* Send hello */
 194         if (0 != vc_mgr_dbus_request_hello()) {
 195                 return EINA_TRUE;
 196         }
 197
 198         g_m_connect_timer = NULL;
 199         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Connect daemon");
 200
 201         /* request initialization */
 202         int ret = -1;
 203         int service_state = 0;
 204         int foreground = VC_RUNTIME_INFO_NO_FOREGROUND;
 205         ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground);
 206
 207         if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
 208                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
 209
 210                 vc_mgr_client_set_error(g_vc_m, VC_ERROR_ENGINE_NOT_FOUND);
 211                 ecore_timer_add(0, __vc_mgr_notify_error, g_vc_m);
 212
 213                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 214                 SLOG(LOG_DEBUG, TAG_VCM, "  ");
 215                 return EINA_FALSE;
 216
 217         } else if (0 != ret) {
 218                 SLOG(LOG_ERROR, TAG_VCM, "[WARNING] Fail to connection. Retry to connect : %s", __vc_mgr_get_error_code(ret));
 219                 return EINA_TRUE;
 220         } else {
 221                 /* Success to connect */
 222         }
 223
 224         /* Set service state */
 225         vc_mgr_client_set_service_state(g_vc_m, (vc_service_state_e)service_state);
 226
 227         /* Set foreground */
 228         vc_mgr_client_set_foreground(g_vc_m, foreground, true);
 229
 230         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Connected daemon");
 231
 232         vc_mgr_client_set_client_state(g_vc_m, VC_STATE_READY);
 233
 234         vc_state_changed_cb changed_callback = NULL;
 235         void* user_data = NULL;
 236
 237         vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data);
 238
 239         vc_state_e current_state;
 240         vc_state_e before_state;
 241
 242         vc_mgr_client_get_before_state(g_vc_m, &current_state, &before_state);
 243
 244         if (NULL != changed_callback) {
 245                 vc_mgr_client_use_callback(g_vc_m);
 246                 changed_callback(before_state, current_state, user_data);
 247                 vc_mgr_client_not_use_callback(g_vc_m);
 248                 SLOG(LOG_DEBUG, TAG_VCM, "State changed callback is called");
 249         } else {
 250                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
 251         }
 252
 253         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 254         SLOG(LOG_DEBUG, TAG_VCM, "  ");
 255
 256         return EINA_FALSE;
 257 }
 258
 259 int vc_mgr_prepare()
 260 {
 261         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Prepare");
 262
 263         vc_state_e state;
 264         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 265                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 266                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 267                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 268                 return VC_ERROR_INVALID_STATE;
 269         }
 270
 271         /* check state */
 272         if (state != VC_STATE_INITIALIZED) {
 273                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'CREATED'");
 274                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 275                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 276                 return VC_ERROR_INVALID_STATE;
 277         }
 278
 279         g_m_connect_timer = ecore_timer_add(0, __vc_mgr_connect_daemon, NULL);
 280
 281         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 282         SLOG(LOG_DEBUG, TAG_VCM, " ");
 283
 284         return VC_ERROR_NONE;
 285 }
 286
 287 int vc_mgr_unprepare()
 288 {
 289         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Unprepare");
 290
 291         vc_state_e state;
 292         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 293                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 294                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 295                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 296                 return VC_ERROR_INVALID_STATE;
 297         }
 298
 299         /* check state */
 300         if (state != VC_STATE_READY) {
 301                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 302                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 303                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 304                 return VC_ERROR_INVALID_STATE;
 305         }
 306
 307         __vc_mgr_internal_unprepare();
 308
 309         vc_mgr_client_set_client_state(g_vc_m, VC_STATE_INITIALIZED);
 310         ecore_timer_add(0, __vc_mgr_notify_state_changed, g_vc_m);
 311
 312         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 313         SLOG(LOG_DEBUG, TAG_VCM, " ");
 314
 315         return VC_ERROR_NONE;
 316 }
 317
 318 int vc_mgr_foreach_supported_languages(vc_supported_language_cb callback, void* user_data)
 319 {
 320         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Foreach Supported Language");
 321
 322         if (NULL == callback) {
 323                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 324                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 325                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 326                 return VC_ERROR_INVALID_PARAMETER;
 327         }
 328
 329         vc_state_e state;
 330         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 331                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 332                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 333                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 334                 return VC_ERROR_INVALID_STATE;
 335         }
 336
 337         int ret = -1;
 338         ret = vc_config_mgr_get_language_list(callback, user_data);
 339         if (0 != ret) {
 340                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 341                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get languages : %s", __vc_mgr_get_error_code(ret));
 342         }
 343
 344         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 345         SLOG(LOG_DEBUG, TAG_VCM, " ");
 346
 347         return VC_ERROR_NONE;
 348 }
 349
 350 int vc_mgr_get_current_language(char** language)
 351 {
 352         if (NULL == language) {
 353                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 354                 return VC_ERROR_INVALID_PARAMETER;
 355         }
 356
 357         vc_state_e state;
 358         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 359                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 360                 return VC_ERROR_INVALID_STATE;
 361         }
 362
 363         int ret = -1;
 364         ret = vc_config_mgr_get_default_language(language);
 365         if (0 != ret) {
 366                 ret = vc_config_convert_error_code((vc_config_error_e)ret);
 367                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get current languages : %s", __vc_mgr_get_error_code(ret));
 368         } else {
 369                 SLOG(LOG_DEBUG, TAG_VCM, "[Get current language] language : %s", *language);
 370         }
 371
 372         return ret;
 373 }
 374
 375 int vc_mgr_get_state(vc_state_e* state)
 376 {
 377         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get State");
 378
 379         if (NULL == state) {
 380                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 381                 return VC_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         vc_state_e temp;
 385         if (0 != vc_mgr_client_get_client_state(g_vc_m, &temp)) {
 386                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 387                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 388                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 389                 return VC_ERROR_INVALID_STATE;
 390         }
 391
 392         *state = temp;
 393
 394         switch (*state) {
 395         case VC_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'None'");            break;
 396         case VC_STATE_INITIALIZED:      SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Created'");         break;
 397         case VC_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCM, "Current state is 'Ready'");           break;
 398         default:                        SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");              break;
 399         }
 400
 401         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 402         SLOG(LOG_DEBUG, TAG_VCM, " ");
 403
 404         return VC_ERROR_NONE;
 405 }
 406
 407 int vc_mgr_get_service_state(vc_service_state_e* state)
 408 {
 409         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get Service State");
 410
 411         if (NULL == state) {
 412                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 413                 return VC_ERROR_INVALID_PARAMETER;
 414         }
 415
 416         vc_state_e client_state;
 417         if (0 != vc_mgr_client_get_client_state(g_vc_m, &client_state)) {
 418                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 419                 return VC_ERROR_INVALID_STATE;
 420         }
 421
 422         /* check state */
 423         if (client_state != VC_STATE_READY) {
 424                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Current state is not 'READY'");
 425                 return VC_ERROR_INVALID_STATE;
 426         }
 427
 428         /* get service state */
 429         vc_service_state_e service_state;
 430         if (0 != vc_mgr_client_get_service_state(g_vc_m, &service_state)) {
 431                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get service state");
 432                 return VC_ERROR_OPERATION_FAILED;
 433         }
 434
 435         *state = service_state;
 436
 437         switch (*state) {
 438         case VC_SERVICE_STATE_NONE:             SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'None'");            break;
 439         case VC_SERVICE_STATE_READY:            SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Ready'");           break;
 440         case VC_SERVICE_STATE_RECORDING:        SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Recording'");       break;
 441         case VC_SERVICE_STATE_PROCESSING:       SLOG(LOG_DEBUG, TAG_VCM, "Current service state is 'Processing'");      break;
 442         default:                                SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid state");                      break;
 443         }
 444
 445         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 446         SLOG(LOG_DEBUG, TAG_VCM, " ");
 447
 448         return VC_ERROR_NONE;
 449 }
 450
 451 int vc_mgr_set_demandable_client_rule(const char* rule)
 452 {
 453         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Demandable client rule");
 454
 455         vc_state_e state;
 456         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 457                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 458                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 459                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 460                 return VC_ERROR_INVALID_STATE;
 461         }
 462
 463         /* check state */
 464         if (state != VC_STATE_READY) {
 465                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 466                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 467                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 468                 return VC_ERROR_INVALID_STATE;
 469         }
 470
 471         int ret = -1;
 472         ret = vc_info_parser_set_demandable_client(rule);
 473         if (0 != ret) {
 474                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] rule is NOT valid");
 475                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 476                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 477                 return VC_ERROR_INVALID_PARAMETER;
 478         }
 479
 480         if (0 != vc_info_parser_get_demandable_clients(&g_demandable_client_list)) {
 481                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get demandable clients");
 482                 return VC_ERROR_OPERATION_FAILED;
 483         }
 484
 485         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 486         SLOG(LOG_DEBUG, TAG_VCM, " ");
 487
 488         return 0;
 489
 490         /*
 491         int count = 0;
 492         ret = -1;
 493         while (0 != ret) {
 494                 ret = vc_mgr_dbus_request_demandable_client(g_vc_m->handle);
 495                 if (0 != ret) {
 496                         if (VC_ERROR_TIMED_OUT != ret) {
 497                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set client rule to daemon : %s", __vc_mgr_get_error_code(ret));
 498                                 break;
 499                         } else {
 500                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request set client rule : %s", __vc_mgr_get_error_code(ret));
 501                                 usleep(10000);
 502                                 count++;
 503                                 if (VC_RETRY_COUNT == count) {
 504                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 505                                         break;
 506                                 }
 507                         }
 508                 }
 509         }
 510
 511         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 512         SLOG(LOG_DEBUG, TAG_VCM, " ");
 513
 514         return 0;
 515         */
 516 }
 517
 518 int vc_mgr_unset_demandable_client_rule()
 519 {
 520         vc_info_parser_set_demandable_client(NULL);
 521
 522         int count = 0;
 523         int ret = -1;
 524         while (0 != ret) {
 525                 ret = vc_mgr_dbus_request_demandable_client(g_vc_m->handle);
 526                 if (0 != ret) {
 527                         if (VC_ERROR_TIMED_OUT != ret) {
 528                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset client rule to daemon : %s", __vc_mgr_get_error_code(ret));
 529                                 break;
 530                         } else {
 531                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request unset client rule : %s", __vc_mgr_get_error_code(ret));
 532                                 usleep(10000);
 533                                 count++;
 534                                 if (VC_RETRY_COUNT == count) {
 535                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 536                                         break;
 537                                 }
 538                         }
 539                 }
 540         }
 541
 542         return 0;
 543 }
 544
 545 int vc_mgr_is_command_format_supported(vc_cmd_format_e format, bool* support)
 546 {
 547         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Is command type supported");
 548
 549         vc_state_e state;
 550         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 551                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 552                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 553                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 554                 return VC_ERROR_INVALID_STATE;
 555         }
 556
 557         /* check support */
 558         bool non_fixed_support = false;
 559         if (0 != vc_config_mgr_get_nonfixed_support(&non_fixed_support)) {
 560                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get nonfixed support info");
 561         }
 562
 563         switch (format) {
 564         case VC_CMD_FORMAT_FIXED:                       *support = true;                break;
 565         case VC_CMD_FORMAT_FIXED_AND_EXTRA:     *support = non_fixed_support;   break;
 566         case VC_CMD_FORMAT_EXTRA_AND_FIXED:     *support = non_fixed_support;   break;
 567         default:                                        *support = false;               break;
 568         }
 569
 570         SLOG(LOG_ERROR, TAG_VCM, "[DEBUG] Format(%d) support(%s)", format, *support ? "true" : "false");
 571
 572         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 573         SLOG(LOG_DEBUG, TAG_VCM, " ");
 574
 575         return VC_ERROR_NONE;
 576 }
 577
 578 int vc_mgr_set_command_list(vc_cmd_list_h vc_cmd_list)
 579 {
 580         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set Command list");
 581
 582         vc_state_e state;
 583         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 584                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 585                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 586                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 587                 return VC_ERROR_INVALID_STATE;
 588         }
 589
 590         /* check state */
 591         if (state != VC_STATE_READY) {
 592                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 593                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 594                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 595                 return VC_ERROR_INVALID_STATE;
 596         }
 597
 598         /* Check service state */
 599         vc_service_state_e service_state = -1;
 600         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 601         if (service_state != VC_SERVICE_STATE_READY) {
 602                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 603                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 604                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 605                 return VC_ERROR_INVALID_STATE;
 606         }
 607
 608         vc_cmd_list_s* list = NULL;
 609         list = (vc_cmd_list_s*)vc_cmd_list;
 610
 611         int system_ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_SYSTEM, list->list);
 612         int exclsive_ret = vc_cmd_parser_save_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE, list->list);
 613         int ret = 0;
 614
 615         if (0 != system_ret && 0 != exclsive_ret) {
 616                 ret = VC_ERROR_INVALID_PARAMETER;
 617                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to save command group : %s", __vc_mgr_get_error_code(ret));
 618         } else {
 619                 int count = 0;
 620                 do {
 621                         ret = vc_mgr_dbus_request_set_command(g_vc_m->handle);
 622                         if (0 != ret) {
 623                                 if (VC_ERROR_TIMED_OUT != ret) {
 624                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request set command to daemon : %s", __vc_mgr_get_error_code(ret));
 625                                         break;
 626                                 } else {
 627                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request set command : %s", __vc_mgr_get_error_code(ret));
 628                                         usleep(10000);
 629                                         count++;
 630                                         if (VC_RETRY_COUNT == count) {
 631                                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 632                                                 break;
 633                                         }
 634                                 }
 635                         }
 636                 } while (0 != ret);
 637         }
 638
 639         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 640         SLOG(LOG_DEBUG, TAG_VCM, " ");
 641
 642         return ret;
 643 }
 644
 645 int vc_mgr_unset_command_list()
 646 {
 647         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Unset Command list");
 648
 649         vc_state_e state;
 650         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 651                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 652                 return VC_ERROR_INVALID_STATE;
 653         }
 654
 655         /* check state */
 656         if (state != VC_STATE_READY) {
 657                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Current state is not 'READY'");
 658                 return VC_ERROR_INVALID_STATE;
 659         }
 660
 661         int count = 0;
 662         int ret = -1;
 663         while (0 != ret) {
 664                 ret = vc_mgr_dbus_request_unset_command(g_vc_m->handle);
 665                 if (0 != ret) {
 666                         if (VC_ERROR_TIMED_OUT != ret) {
 667                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request unset command to daemon : %s", __vc_mgr_get_error_code(ret));
 668                                 break;
 669                         } else {
 670                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry request unset command : %s", __vc_mgr_get_error_code(ret));
 671                                 usleep(10000);
 672                                 count++;
 673                                 if (VC_RETRY_COUNT == count) {
 674                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 675                                         break;
 676                                 }
 677                         }
 678                 }
 679         }
 680
 681         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_SYSTEM);
 682         vc_cmd_parser_delete_file(getpid(), VC_COMMAND_TYPE_EXCLUSIVE);
 683
 684         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 685         SLOG(LOG_DEBUG, TAG_VCM, " ");
 686
 687         return 0;
 688 }
 689
 690 int vc_mgr_set_audio_type(const char* audio_id)
 691 {
 692         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set audio type");
 693
 694         if (NULL == audio_id) {
 695                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 696                 return VC_ERROR_INVALID_PARAMETER;
 697         }
 698
 699         vc_state_e state;
 700         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 701                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 702                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 703                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 704                 return VC_ERROR_INVALID_STATE;
 705         }
 706
 707         /* check state */
 708         if (state != VC_STATE_READY) {
 709                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 710                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 711                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 712                 return VC_ERROR_INVALID_STATE;
 713         }
 714
 715         /* Check service state */
 716         vc_service_state_e service_state = -1;
 717         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 718         if (service_state != VC_SERVICE_STATE_READY) {
 719                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 720                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 721                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 722                 return VC_ERROR_INVALID_STATE;
 723         }
 724
 725         int ret;
 726         int count = 0;
 727
 728         /* Request */
 729         ret = -1;
 730         count = 0;
 731         while (0 != ret) {
 732                 ret = vc_mgr_dbus_request_set_audio_type(g_vc_m->handle, audio_id);
 733                 if (0 != ret) {
 734                         if (VC_ERROR_TIMED_OUT != ret) {
 735                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio type : %s", __vc_mgr_get_error_code(ret));
 736                                 break;
 737                         } else {
 738                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set audio type : %s", __vc_mgr_get_error_code(ret));
 739                                 usleep(10000);
 740                                 count++;
 741                                 if (VC_RETRY_COUNT == count) {
 742                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 743                                         break;
 744                                 }
 745                         }
 746                 } else {
 747                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set audio type");
 748                         /* Save */
 749                         vc_mgr_client_set_audio_type(g_vc_m, audio_id);
 750                 }
 751         }
 752
 753         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 754         SLOG(LOG_DEBUG, TAG_VCM, " ");
 755
 756         return ret;
 757 }
 758
 759 int vc_mgr_get_audio_type(char** audio_id)
 760 {
 761         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get audio type");
 762
 763         if (NULL == audio_id) {
 764                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
 765                 return VC_ERROR_INVALID_PARAMETER;
 766         }
 767
 768         vc_state_e state;
 769         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 770                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 771                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 772                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 773                 return VC_ERROR_INVALID_STATE;
 774         }
 775
 776         /* check state */
 777         if (state != VC_STATE_READY) {
 778                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 779                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 780                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 781                 return VC_ERROR_INVALID_STATE;
 782         }
 783
 784         /* Check service state */
 785         vc_service_state_e service_state = -1;
 786         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 787         if (service_state != VC_SERVICE_STATE_READY) {
 788                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 789                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 790                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 791                 return VC_ERROR_INVALID_STATE;
 792         }
 793
 794         char* temp = NULL;
 795
 796         vc_mgr_client_get_audio_type(g_vc_m, &temp);
 797
 798         if (NULL == temp) {
 799                 /* Not initiallized */
 800                 int ret = -1;
 801                 int count = 0;
 802                 while (0 != ret) {
 803                         ret = vc_mgr_dbus_request_get_audio_type(g_vc_m->handle, &temp);
 804                         if (0 != ret) {
 805                                 if (VC_ERROR_TIMED_OUT != ret) {
 806                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get audio type : %s", __vc_mgr_get_error_code(ret));
 807                                         break;
 808                                 } else {
 809                                         SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to get audio type : %s", __vc_mgr_get_error_code(ret));
 810                                         usleep(10000);
 811                                         count++;
 812                                         if (VC_RETRY_COUNT == count) {
 813                                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 814                                                 break;
 815                                         }
 816                                 }
 817                         } else {
 818                                 SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Get audio type : %s", temp);
 819                                 /* Save */
 820                                 vc_mgr_client_set_audio_type(g_vc_m, temp);
 821                         }
 822                 }
 823         }
 824
 825         if (NULL != temp) {
 826                 *audio_id = strdup(temp);
 827                 free(temp);
 828                 temp = NULL;
 829         }
 830
 831         return 0;
 832 }
 833
 834 int vc_mgr_get_current_commands(vc_cmd_list_h* vc_cmd_list)
 835 {
 836         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Foreach current commands");
 837
 838         vc_state_e state;
 839         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
 840                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
 841                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 842                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 843                 return VC_ERROR_INVALID_STATE;
 844         }
 845
 846         /* check state */
 847         if (state != VC_STATE_READY) {
 848                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
 849                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 850                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 851                 return VC_ERROR_INVALID_STATE;
 852         }
 853
 854         /* Check service state */
 855         vc_service_state_e service_state = -1;
 856         vc_mgr_client_get_service_state(g_vc_m, &service_state);
 857         if (service_state != VC_SERVICE_STATE_READY) {
 858                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
 859                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 860                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 861                 return VC_ERROR_INVALID_STATE;
 862         }
 863
 864         if (NULL == vc_cmd_list) {
 865                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid Parameter");
 866                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
 867                 SLOG(LOG_DEBUG, TAG_VCM, " ");
 868                 return VC_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         vc_cmd_list_h temp_list = NULL;
 872         if (0 != vc_cmd_list_create(&temp_list)) {
 873                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create list");
 874                 return VC_ERROR_INVALID_PARAMETER;
 875         }
 876
 877         *vc_cmd_list = temp_list;
 878
 879         int fg_pid = 0;
 880         int mgr_pid = 0;
 881         int count = 0;
 882         int ret = -1;
 883
 884         /* Get foreground pid */
 885         if (0 != vc_mgr_client_get_foreground(g_vc_m, &fg_pid)) {
 886                 /* There is no foreground app for voice control */
 887                 SLOG(LOG_WARN, TAG_VCM, "[Manager WARNING] No foreground pid for voice control");
 888         } else {
 889                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Foreground pid(%d)", fg_pid);
 890         }
 891
 892         if (0 != vc_mgr_client_get_pid(g_vc_m, &mgr_pid)) {
 893                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Fail to get manager pid");
 894                 return VC_ERROR_OPERATION_FAILED;
 895         } else {
 896                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Manager pid(%d)", mgr_pid);
 897         }
 898
 899         /* Get system command */
 900         ret = vc_cmd_parser_append_commands(mgr_pid, VC_COMMAND_TYPE_SYSTEM, temp_list);
 901         if (0 != ret) {
 902                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No system commands");
 903         }
 904
 905         /* Request */
 906         ret = -1;
 907         count = 0;
 908         while (0 != ret) {
 909                 ret = vc_mgr_dbus_request_set_client_info(g_vc_m->handle);
 910                 if (0 != ret) {
 911                         if (VC_ERROR_TIMED_OUT != ret) {
 912                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set client info : %s", __vc_mgr_get_error_code(ret));
 913                                 break;
 914                         } else {
 915                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to set client info : %s", __vc_mgr_get_error_code(ret));
 916                                 usleep(10000);
 917                                 count++;
 918                                 if (VC_RETRY_COUNT == count) {
 919                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
 920                                         break;
 921                                 }
 922                         }
 923                 } else {
 924                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set client info");
 925                 }
 926         }
 927
 928         GSList *iter = NULL;
 929         GSList* client_info_list = NULL;
 930         vc_client_info_s *client_info = NULL;
 931         bool is_fgpid = false;
 932
 933         if (0 != vc_info_parser_get_client_info(&client_info_list)) {
 934                 SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] No client");
 935                 return 0;
 936         }
 937
 938         if (VC_NO_FOREGROUND_PID != fg_pid) {
 939                 iter = g_slist_nth(client_info_list, 0);
 940                 while (NULL != iter) {
 941                         client_info = iter->data;
 942                         if (NULL != client_info) {
 943                                 if (fg_pid == client_info->pid) {
 944                                         is_fgpid = true;
 945                                         break;
 946                                 }
 947                         }
 948                         iter = g_slist_next(iter);
 949                 }
 950         }
 951
 952         /* Get foreground commands and widget */
 953         if (true == is_fgpid) {
 954                 /* Get handle */
 955                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] fore cmd(%d)", client_info->fg_cmd);
 956
 957                 /* Get foreground command */
 958                 if (true == client_info->fg_cmd) {
 959                         ret = vc_cmd_parser_append_commands(fg_pid, VC_COMMAND_TYPE_FOREGROUND, temp_list);
 960                         if (0 != ret) {
 961                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the fg command list");
 962                         }
 963                 } else {
 964                         SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground commands");
 965                 }
 966
 967                 /* Check exclusive option */
 968                 if (true == client_info->exclusive_cmd) {
 969                         SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Exclusive command is ON");
 970
 971                         /* Set background command for exclusive option */
 972                         if (true == client_info->bg_cmd) {
 973                                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set background command");
 974                                 ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
 975                                 if (0 != ret) {
 976                                         SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
 977                                 }
 978                         }
 979
 980                         /* need to release client info */
 981                         iter = g_slist_nth(client_info_list, 0);
 982
 983                         while (NULL != iter) {
 984                                 client_info = iter->data;
 985                                 if (NULL != client_info) {
 986                                         free(client_info);
 987                                 }
 988                                 client_info_list = g_slist_remove_link(client_info_list, iter);
 989                                 iter = g_slist_nth(client_info_list, 0);
 990                         }
 991
 992                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
 993                         SLOG(LOG_DEBUG, TAG_VCM, " ");
 994
 995                         return 0;
 996                 }
 997         } else {
 998                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No foreground app");
 999         }
1000
1001         /* Get background commands */
1002         if (0 < g_slist_length(client_info_list)) {
1003                 iter = g_slist_nth(client_info_list, 0);
1004
1005                 while (NULL != iter) {
1006                         client_info = iter->data;
1007
1008                         if (NULL != client_info) {
1009                                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Pid(%d) Back cmd(%d)", client_info->pid, client_info->bg_cmd);
1010                                 if (true == client_info->bg_cmd) {
1011                                         ret = vc_cmd_parser_append_commands(client_info->pid, VC_COMMAND_TYPE_BACKGROUND, temp_list);
1012                                         if (0 != ret) {
1013                                                 SLOG(LOG_ERROR, TAG_VCM, "[Client Data ERROR] Fail to get the bg command list : pid(%d)", client_info->pid);
1014                                         }
1015                                 }
1016                                 free(client_info);
1017                         }
1018                         client_info_list = g_slist_remove_link(client_info_list, iter);
1019
1020                         iter = g_slist_nth(client_info_list, 0);
1021                 }
1022         } else {
1023                 /* NO client */
1024                 SLOG(LOG_DEBUG, TAG_VCM, "[Manager] No background commands");
1025         }
1026
1027         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1028         SLOG(LOG_DEBUG, TAG_VCM, " ");
1029
1030         return 0;
1031 }
1032
1033 int vc_mgr_set_recognition_mode(vc_recognition_mode_e mode)
1034 {
1035         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Set recognition mode = %d", mode);
1036
1037         vc_state_e state;
1038         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1039                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1040                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1041                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1042                 return VC_ERROR_INVALID_STATE;
1043         }
1044
1045         /* check state */
1046         if (state != VC_STATE_READY) {
1047                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1048                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1049                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1050                 return VC_ERROR_INVALID_STATE;
1051         }
1052
1053         /* Check service state */
1054         vc_service_state_e service_state = -1;
1055         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1056         if (service_state != VC_SERVICE_STATE_READY) {
1057                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1058                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1059                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1060                 return VC_ERROR_INVALID_STATE;
1061         }
1062
1063         vc_mgr_client_set_recognition_mode(g_vc_m, mode);
1064         return 0;
1065 }
1066
1067 int vc_mgr_get_recognition_mode(vc_recognition_mode_e* mode)
1068 {
1069         int ret = -1;
1070
1071         ret = vc_mgr_client_get_recognition_mode(g_vc_m, mode);
1072         if (0 != ret) {
1073                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1074                 return ret;
1075         }
1076
1077         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Get recognition mode = %d", *mode);
1078         return 0;
1079 }
1080
1081 int vc_mgr_start(bool exclusive_command_option)
1082 {
1083         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request start");
1084
1085         vc_state_e state;
1086         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1087                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1088                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1089                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1090                 return VC_ERROR_INVALID_STATE;
1091         }
1092
1093         /* check state */
1094         if (state != VC_STATE_READY) {
1095                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
1096                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1097                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1098                 return VC_ERROR_INVALID_STATE;
1099         }
1100
1101         /* Check service state */
1102         vc_service_state_e service_state = -1;
1103         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1104         if (service_state != VC_SERVICE_STATE_READY) {
1105                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY'");
1106                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1107                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1108                 return VC_ERROR_INVALID_STATE;
1109         }
1110
1111         vc_mgr_client_set_exclusive_command(g_vc_m, exclusive_command_option);
1112
1113         bool start_by_client = false;
1114         if (0 != vc_mgr_client_get_start_by_client(g_vc_m, &start_by_client)) {
1115                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get start by client");
1116         }
1117
1118         int ret;
1119         int count = 0;
1120         vc_recognition_mode_e recognition_mode = VC_RECOGNITION_MODE_STOP_BY_SILENCE;
1121         if (0 != vc_mgr_get_recognition_mode(&recognition_mode)) {
1122                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get recognition mode");
1123         }
1124
1125         /* Request */
1126         ret = -1;
1127         count = 0;
1128         while (0 != ret) {
1129                 ret = vc_mgr_dbus_request_start(g_vc_m->handle, (int)recognition_mode, exclusive_command_option, start_by_client);
1130                 if (0 != ret) {
1131                         if (VC_ERROR_TIMED_OUT != ret) {
1132                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to start request start : %s", __vc_mgr_get_error_code(ret));
1133                                 break;
1134                         } else {
1135                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry start request start : %s", __vc_mgr_get_error_code(ret));
1136                                 usleep(10000);
1137                                 count++;
1138                                 if (VC_RETRY_COUNT == count) {
1139                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1140                                         vc_mgr_client_set_exclusive_command(g_vc_m, false);
1141                                         break;
1142                                 }
1143                         }
1144                 } else {
1145                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] start recognition");
1146                 }
1147         }
1148
1149         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1150         SLOG(LOG_DEBUG, TAG_VCM, " ");
1151
1152         return ret;
1153 }
1154
1155 int vc_mgr_stop()
1156 {
1157         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request stop");
1158
1159         vc_state_e state;
1160         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1161                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1162                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1163                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1164                 return VC_ERROR_INVALID_STATE;
1165         }
1166
1167         /* check state */
1168         if (state != VC_STATE_READY) {
1169                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: client state is not 'READY'");
1170                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1171                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1172                 return VC_ERROR_INVALID_STATE;
1173         }
1174
1175         /* Check service state */
1176         vc_service_state_e service_state = -1;
1177         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1178         if (service_state != VC_SERVICE_STATE_RECORDING) {
1179                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'RECORDING'");
1180                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1181                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1182                 return VC_ERROR_INVALID_STATE;
1183         }
1184
1185         int ret = -1;
1186         int count = 0;
1187         /* do request */
1188         while (0 != ret) {
1189                 ret = vc_mgr_dbus_request_stop(g_vc_m->handle);
1190                 if (0 != ret) {
1191                         if (VC_ERROR_TIMED_OUT != ret) {
1192                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to stop request : %s", __vc_mgr_get_error_code(ret));
1193                                 break;
1194                         } else {
1195                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry stop request : %s", __vc_mgr_get_error_code(ret));
1196                                 usleep(10000);
1197                                 count++;
1198                                 if (VC_RETRY_COUNT == count) {
1199                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1200                                         break;
1201                                 }
1202                         }
1203                 } else {
1204                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Stop recognition");
1205                 }
1206         }
1207
1208         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1209         SLOG(LOG_DEBUG, TAG_VCM, " ");
1210
1211         return ret;
1212 }
1213
1214 int vc_mgr_cancel()
1215 {
1216         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Request cancel");
1217
1218         vc_state_e state;
1219         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1220                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1221                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1222                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1223                 return VC_ERROR_INVALID_STATE;
1224         }
1225
1226         /* check state */
1227         if (state != VC_STATE_READY) {
1228                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: client state is not 'READY'");
1229                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1230                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1231                 return VC_ERROR_INVALID_STATE;
1232         }
1233
1234         /* Check service state */
1235         vc_service_state_e service_state = -1;
1236         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1237         if (service_state != VC_SERVICE_STATE_RECORDING && service_state != VC_SERVICE_STATE_PROCESSING) {
1238                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'RECORDING' or 'PROCESSING'");
1239                 SLOG(LOG_DEBUG, TAG_VCM, "=====");
1240                 SLOG(LOG_DEBUG, TAG_VCM, " ");
1241                 return VC_ERROR_INVALID_STATE;
1242         }
1243
1244         int ret = -1;
1245         int count = 0;
1246         while (0 != ret) {
1247                 ret = vc_mgr_dbus_request_cancel(g_vc_m->handle);
1248                 if (0 != ret) {
1249                         if (VC_ERROR_TIMED_OUT != ret) {
1250                                 SLOG(LOG_DEBUG, TAG_VCM, "[ERROR] Fail to cancel request : %s", __vc_mgr_get_error_code(ret));
1251                                 break;
1252                         } else {
1253                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry cancel request : %s", __vc_mgr_get_error_code(ret));
1254                                 usleep(10000);
1255                                 count++;
1256                                 if (VC_RETRY_COUNT == count) {
1257                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1258                                         break;
1259                                 }
1260                         }
1261                 } else {
1262                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Cancel recognition");
1263                 }
1264         }
1265
1266         vc_mgr_client_set_exclusive_command(g_vc_m, false);
1267
1268         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1269         SLOG(LOG_DEBUG, TAG_VCM, " ");
1270
1271         return ret;
1272 }
1273
1274 int __vc_mgr_cb_set_volume(float volume)
1275 {
1276         g_volume_db = volume;
1277         SLOG(LOG_DEBUG, TAG_VCM, "Set volume (%f)", g_volume_db);
1278
1279         return 0;
1280 }
1281
1282 int vc_mgr_get_recording_volume(float* volume)
1283 {
1284         if (NULL == volume) {
1285                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Input parameter is NULL");
1286                 return VC_ERROR_INVALID_PARAMETER;
1287         }
1288
1289         vc_service_state_e service_state = -1;
1290         if (0 != vc_mgr_client_get_service_state(g_vc_m, &service_state)) {
1291                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
1292                 return VC_ERROR_INVALID_STATE;
1293         }
1294
1295         /* check state */
1296         if (VC_SERVICE_STATE_RECORDING != service_state) {
1297                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Service state is not 'RECORDING'");
1298                 return VC_ERROR_INVALID_STATE;
1299         }
1300
1301         *volume = g_volume_db;
1302
1303         return 0;
1304 }
1305
1306 int __vc_mgr_cb_set_foreground(int pid, bool value)
1307 {
1308         vc_mgr_client_set_foreground(g_vc_m, pid, value);
1309
1310         /* get authorized valid app */
1311         int tmp_pid;
1312         if (0 != vc_mgr_client_get_valid_authorized_client(g_vc_m, &tmp_pid)) {
1313                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get authorized valid app");
1314                 return VC_ERROR_INVALID_PARAMETER;
1315         }
1316
1317         if (true == value) {
1318                 /* compare & set valid */
1319                 if (tmp_pid != pid) {
1320                         SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1321
1322                         /* set authorized valid */
1323                         if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
1324                                 SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) change to valid", pid);
1325                                 vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
1326                         } else {
1327                                 SLOG(LOG_DEBUG, TAG_VCM, "No valid Authority");
1328                                 vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
1329                         }
1330                 }
1331         } else {
1332                 if (tmp_pid == pid) {
1333                         SLOG(LOG_DEBUG, TAG_VCM, "Authority(%d) changed to invalid", tmp_pid);
1334                         vc_mgr_client_set_valid_authorized_client(g_vc_m, -1);
1335                 }
1336         }
1337
1338         return 0;
1339 }
1340
1341 int vc_mgr_set_selected_results(vc_cmd_list_h vc_cmd_list)
1342 {
1343         SLOG(LOG_DEBUG, TAG_VCM, "===== [Manager] Select result");
1344
1345         /* Do not check state for 'restart continusly' mode */
1346
1347         vc_service_state_e service_state = -1;
1348         vc_mgr_client_get_service_state(g_vc_m, &service_state);
1349         if (service_state != VC_SERVICE_STATE_PROCESSING) {
1350                 vc_recognition_mode_e recognition_mode;
1351                 vc_mgr_get_recognition_mode(&recognition_mode);
1352
1353                 if (VC_RECOGNITION_MODE_RESTART_CONTINUOUSLY != recognition_mode) {
1354                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'PROCESSING' and mode is not 'Restart continously'");
1355                         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1356                         SLOG(LOG_DEBUG, TAG_VCM, " ");
1357                         return VC_ERROR_INVALID_STATE;
1358                 }
1359         }
1360
1361         if (NULL != vc_cmd_list) {
1362                 int event = 0;
1363                 char* result_text = NULL;
1364
1365                 vc_mgr_client_get_all_result(g_vc_m, &event, &result_text);
1366
1367                 vc_info_parser_set_result(result_text, event, NULL, vc_cmd_list, false);
1368
1369                 if (NULL != result_text) {
1370                         free(result_text);
1371                         result_text = NULL;
1372                 }
1373         }
1374
1375         int ret;
1376         int count = 0;
1377
1378         /* Request */
1379         ret = -1;
1380         count = 0;
1381         while (0 != ret) {
1382                 ret = vc_mgr_dbus_send_result_selection(g_vc_m->handle);
1383                 if (0 != ret) {
1384                         if (VC_ERROR_TIMED_OUT != ret) {
1385                                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to send result selection : %s", __vc_mgr_get_error_code(ret));
1386                                 break;
1387                         } else {
1388                                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry send result selection : %s", __vc_mgr_get_error_code(ret));
1389                                 usleep(10000);
1390                                 count++;
1391                                 if (VC_RETRY_COUNT == count) {
1392                                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to request");
1393                                         break;
1394                                 }
1395                         }
1396                 } else {
1397                         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] result selection");
1398                 }
1399         }
1400
1401         vc_mgr_client_unset_all_result(g_vc_m);
1402
1403         SLOG(LOG_DEBUG, TAG_VCM, "=====");
1404         SLOG(LOG_DEBUG, TAG_VCM, " ");
1405
1406         return 0;
1407 }
1408
1409 static Eina_Bool __vc_mgr_set_select_result(void *data)
1410 {
1411         vc_mgr_set_selected_results(NULL);
1412         return EINA_FALSE;
1413 }
1414
1415 static void __vc_mgr_notify_all_result(vc_result_type_e result_type)
1416 {
1417         char* temp_text = NULL;
1418         int event;
1419         char* temp_message = NULL;
1420         vc_cmd_list_h vc_cmd_list = NULL;
1421
1422         vc_mgr_all_result_cb all_callback = NULL;
1423         void* all_user_data = NULL;
1424
1425         vc_mgr_client_get_all_result_cb(g_vc_m, &all_callback, &all_user_data);
1426         if (NULL == all_callback) {
1427                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] All result callback is NULL");
1428                 return;
1429         }
1430
1431         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1432                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
1433                 return;
1434         }
1435
1436         vc_info_parser_get_result(&temp_text, &event, &temp_message, -1, vc_cmd_list, vc_mgr_client_get_exclusive_command(g_vc_m));
1437
1438         SLOG(LOG_DEBUG, TAG_VCM, "Result info : result type(%d) result text(%s) event(%d) result_message(%s)",
1439                 result_type, temp_text, event, temp_message);
1440
1441         vc_cmd_print_list(vc_cmd_list);
1442
1443         bool cb_ret;
1444
1445         vc_mgr_client_use_callback(g_vc_m);
1446         cb_ret = all_callback(event, vc_cmd_list, temp_text, temp_message, all_user_data);
1447         vc_mgr_client_not_use_callback(g_vc_m);
1448
1449         if (true == vc_mgr_client_get_exclusive_command(g_vc_m)) {
1450                 /* exclusive */
1451                 vc_result_cb callback = NULL;
1452                 void* user_data = NULL;
1453
1454                 vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
1455                 if (NULL == callback) {
1456                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
1457                         return;
1458                 }
1459
1460                 vc_mgr_client_use_callback(g_vc_m);
1461                 callback(event, vc_cmd_list, temp_text, user_data);
1462                 vc_mgr_client_not_use_callback(g_vc_m);
1463                 SLOG(LOG_DEBUG, TAG_VCM, "Exclusive result callback called");
1464
1465                 /* Release result */
1466                 if (NULL != temp_text)  free(temp_text);
1467
1468                 /* Release list */
1469                 vc_cmd_list_destroy(vc_cmd_list, true);
1470
1471                 vc_mgr_client_set_exclusive_command(g_vc_m, false);
1472
1473                 return;
1474         }
1475
1476         int count = 0;
1477         vc_cmd_list_get_count(vc_cmd_list, &count);
1478         if (0 < count) {
1479                 if (true == cb_ret) {
1480                         SLOG(LOG_DEBUG, TAG_VCM, "Callback result is true");
1481                         if (VC_RESULT_TYPE_NOTIFICATION != result_type)
1482                                 ecore_idler_add(__vc_mgr_set_select_result, NULL);
1483                 } else {
1484                         SLOG(LOG_DEBUG, TAG_VCM, "Callback result is false");
1485                         /* need to select conflicted result */
1486
1487                         vc_mgr_client_set_all_result(g_vc_m, event, temp_text);
1488                 }
1489         } else {
1490                 if (VC_RESULT_TYPE_NOTIFICATION != result_type)
1491                         ecore_idler_add(__vc_mgr_set_select_result, NULL);
1492
1493                 vc_mgr_client_set_exclusive_command(g_vc_m, false);
1494                 vc_mgr_client_unset_all_result(g_vc_m);
1495         }
1496
1497         /* Release result */
1498         if (NULL != temp_text)  free(temp_text);
1499
1500         /* Release list */
1501         vc_cmd_list_destroy(vc_cmd_list, true);
1502
1503         return;
1504 }
1505
1506 static Eina_Bool __vc_mgr_notify_result(void *data)
1507 {
1508         char* temp_text;
1509         int event;
1510         vc_cmd_list_h vc_cmd_list = NULL;
1511
1512         vc_result_cb callback = NULL;
1513         void* user_data = NULL;
1514
1515         vc_mgr_client_get_result_cb(g_vc_m, &callback, &user_data);
1516         if (NULL == callback) {
1517                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client result callback is NULL");
1518                 return EINA_FALSE;
1519         }
1520
1521         if (0 != vc_cmd_list_create(&vc_cmd_list)) {
1522                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to create command list");
1523                 return EINA_FALSE;
1524         }
1525
1526         vc_info_parser_get_result(&temp_text, &event, NULL, getpid(), vc_cmd_list, false);
1527
1528         SLOG(LOG_DEBUG, TAG_VCM, "Result : result text(%s) event(%d)", temp_text, event);
1529
1530         vc_cmd_print_list(vc_cmd_list);
1531
1532         vc_mgr_client_use_callback(g_vc_m);
1533         callback(event, vc_cmd_list, temp_text, user_data);
1534         vc_mgr_client_not_use_callback(g_vc_m);
1535         SLOG(LOG_DEBUG, TAG_VCM, "Result callback called");
1536
1537         vc_cmd_list_destroy(vc_cmd_list, true);
1538
1539         /* Release result */
1540         if (NULL != temp_text)  free(temp_text);
1541
1542         return EINA_FALSE;
1543 }
1544
1545 void __vc_mgr_cb_all_result(vc_result_type_e type)
1546 {
1547         if (false == vc_mgr_client_get_exclusive_command(g_vc_m)) {
1548                 __vc_mgr_notify_all_result(type);
1549         } else {
1550                 __vc_mgr_notify_result(0);
1551         }
1552
1553         return;
1554 }
1555
1556 void __vc_mgr_cb_system_result()
1557 {
1558         __vc_mgr_notify_result(NULL);
1559         return;
1560 }
1561
1562 static Eina_Bool __vc_mgr_speech_detected(void *data)
1563 {
1564         vc_mgr_begin_speech_detected_cb callback = NULL;
1565         void* user_data = NULL;
1566
1567         vc_mgr_client_get_speech_detected_cb(g_vc_m, &callback, &user_data);
1568         if (NULL == callback) {
1569                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Client speech detected callback is NULL");
1570                 return EINA_FALSE;
1571         }
1572
1573         vc_mgr_client_use_callback(g_vc_m);
1574         callback(user_data);
1575         vc_mgr_client_not_use_callback(g_vc_m);
1576         SLOG(LOG_DEBUG, TAG_VCM, "Speech detected callback called");
1577
1578         return EINA_FALSE;
1579 }
1580
1581 void __vc_mgr_cb_speech_detected()
1582 {
1583         __vc_mgr_speech_detected(NULL);
1584
1585         return;
1586 }
1587
1588 int vc_mgr_set_all_result_cb(vc_mgr_all_result_cb callback, void* user_data)
1589 {
1590         if (NULL == callback)
1591                 return VC_ERROR_INVALID_PARAMETER;
1592
1593         vc_state_e state;
1594         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1595                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
1596                 return VC_ERROR_INVALID_STATE;
1597         }
1598
1599         /* check state */
1600         if (state != VC_STATE_INITIALIZED) {
1601                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : Current state is not 'Initialized'");
1602                 return VC_ERROR_INVALID_STATE;
1603         }
1604
1605         vc_mgr_client_set_all_result_cb(g_vc_m, callback, user_data);
1606
1607         SLOG(LOG_DEBUG, TAG_VCM, "[SUCCESS] Set all result callback");
1608
1609         return 0;
1610 }
1611
1612 int vc_mgr_unset_all_result_cb()
1613 {
1614         vc_state_e state;
1615         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1616                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
1617                 return VC_ERROR_INVALID_STATE;
1618         }
1619
1620         /* check state */
1621         if (state != VC_STATE_INITIALIZED) {
1622                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1623                 return VC_ERROR_INVALID_STATE;
1624         }
1625
1626         vc_mgr_client_set_all_result_cb(g_vc_m, NULL, NULL);
1627
1628         return 0;
1629 }
1630
1631 int vc_mgr_set_result_cb(vc_result_cb callback, void* user_data)
1632 {
1633         if (NULL == callback)
1634                 return VC_ERROR_INVALID_PARAMETER;
1635
1636         vc_state_e state;
1637         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1638                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : A handle is not available");
1639                 return VC_ERROR_INVALID_STATE;
1640         }
1641
1642         /* check state */
1643         if (state != VC_STATE_INITIALIZED) {
1644                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set result callback : Current state is not 'Initialized'");
1645                 return VC_ERROR_INVALID_STATE;
1646         }
1647
1648         vc_mgr_client_set_result_cb(g_vc_m, callback, user_data);
1649
1650         return 0;
1651 }
1652
1653 int vc_mgr_unset_result_cb()
1654 {
1655         vc_state_e state;
1656         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1657                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : A handle is not available");
1658                 return VC_ERROR_INVALID_STATE;
1659         }
1660
1661         /* check state */
1662         if (state != VC_STATE_INITIALIZED) {
1663                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset result callback : Current state is not 'Initialized'");
1664                 return VC_ERROR_INVALID_STATE;
1665         }
1666
1667         vc_mgr_client_set_result_cb(g_vc_m, NULL, NULL);
1668
1669         return 0;
1670 }
1671
1672 static Eina_Bool __vc_mgr_notify_error(void *data)
1673 {
1674         vc_h vc_m = (vc_h)data;
1675
1676         vc_error_cb callback = NULL;
1677         void* user_data = NULL;
1678         int reason;
1679
1680         vc_mgr_client_get_error_cb(vc_m, &callback, &user_data);
1681         vc_mgr_client_get_error(vc_m, &reason);
1682
1683         if (NULL != callback) {
1684                 vc_mgr_client_use_callback(vc_m);
1685                 callback(reason, user_data);
1686                 vc_mgr_client_not_use_callback(vc_m);
1687                 SLOG(LOG_DEBUG, TAG_VCM, "Error callback is called");
1688         } else {
1689                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Error callback is null");
1690         }
1691
1692         return EINA_FALSE;
1693 }
1694
1695 int __vc_mgr_cb_error(int pid, int reason)
1696 {
1697         if (0 != vc_mgr_client_get_handle(pid, &g_vc_m)) {
1698                 SLOG(LOG_ERROR, TAG_VCM, "Handle is not valid");
1699                 return -1;
1700         }
1701
1702         vc_mgr_client_set_error(g_vc_m, reason);
1703         __vc_mgr_notify_error(g_vc_m);
1704
1705         return 0;
1706 }
1707
1708 static Eina_Bool __vc_mgr_notify_state_changed(void *data)
1709 {
1710         vc_state_changed_cb changed_callback = NULL;
1711         void* user_data;
1712
1713         vc_mgr_client_get_state_changed_cb(g_vc_m, &changed_callback, &user_data);
1714
1715         vc_state_e current_state;
1716         vc_state_e before_state;
1717
1718         vc_mgr_client_get_before_state(g_vc_m, &current_state, &before_state);
1719
1720         if (NULL != changed_callback) {
1721                 vc_mgr_client_use_callback(g_vc_m);
1722                 changed_callback(before_state, current_state, user_data);
1723                 vc_mgr_client_not_use_callback(g_vc_m);
1724                 SLOG(LOG_DEBUG, TAG_VCM, "State changed callback is called");
1725         } else {
1726                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] State changed callback is null");
1727         }
1728
1729         return EINA_FALSE;
1730 }
1731
1732 int vc_mgr_set_state_changed_cb(vc_state_changed_cb callback, void* user_data)
1733 {
1734         if (callback == NULL)
1735                 return VC_ERROR_INVALID_PARAMETER;
1736
1737         vc_state_e state;
1738         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1739                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
1740                 return VC_ERROR_INVALID_STATE;
1741         }
1742
1743         /* check state */
1744         if (state != VC_STATE_INITIALIZED) {
1745                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1746                 return VC_ERROR_INVALID_STATE;
1747         }
1748
1749         vc_mgr_client_set_state_changed_cb(g_vc_m, callback, user_data);
1750
1751         return 0;
1752 }
1753
1754 int vc_mgr_unset_state_changed_cb()
1755 {
1756         vc_state_e state;
1757         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1758                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
1759                 return VC_ERROR_INVALID_STATE;
1760         }
1761
1762         /* check state */
1763         if (state != VC_STATE_INITIALIZED) {
1764                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1765                 return VC_ERROR_INVALID_STATE;
1766         }
1767
1768         vc_mgr_client_set_state_changed_cb(g_vc_m, NULL, NULL);
1769
1770         return 0;
1771 }
1772
1773 int __vc_mgr_cb_service_state(int state)
1774 {
1775         vc_service_state_e current_state = (vc_service_state_e)state;
1776         vc_service_state_e before_state;
1777         vc_mgr_client_get_service_state(g_vc_m, &before_state);
1778
1779         if (current_state == before_state) {
1780                 SLOG(LOG_WARN, TAG_VCM, "Service State NOT changed : Before(%d) Current(%d)",
1781                         before_state, current_state);
1782                 return 0;
1783         }
1784
1785         SLOG(LOG_DEBUG, TAG_VCM, "Service State changed : Before(%d) Current(%d)",
1786                 before_state, current_state);
1787
1788         /* Save service state */
1789         vc_mgr_client_set_service_state(g_vc_m, current_state);
1790
1791         vc_service_state_changed_cb callback = NULL;
1792         void* service_user_data = NULL;
1793         vc_mgr_client_get_service_state_changed_cb(g_vc_m, &callback, &service_user_data);
1794
1795         if (NULL != callback) {
1796                 vc_mgr_client_use_callback(g_vc_m);
1797                 callback(before_state, current_state, service_user_data);
1798                 vc_mgr_client_not_use_callback(g_vc_m);
1799                 SLOG(LOG_DEBUG, TAG_VCM, "Service state changed callback is called");
1800         } else {
1801                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] Service state changed callback is null");
1802         }
1803
1804         return 0;
1805 }
1806
1807 int vc_mgr_set_service_state_changed_cb(vc_service_state_changed_cb callback, void* user_data)
1808 {
1809         if (callback == NULL)
1810                 return VC_ERROR_INVALID_PARAMETER;
1811
1812         vc_state_e state;
1813         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1814                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
1815                 return VC_ERROR_INVALID_STATE;
1816         }
1817
1818         /* check state */
1819         if (state != VC_STATE_INITIALIZED) {
1820                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : Current state is not 'Initialized'");
1821                 return VC_ERROR_INVALID_STATE;
1822         }
1823
1824         vc_mgr_client_set_service_state_changed_cb(g_vc_m, callback, user_data);
1825
1826         return 0;
1827 }
1828
1829 int vc_mgr_unset_service_state_changed_cb()
1830 {
1831         vc_state_e state;
1832         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1833                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
1834                 return VC_ERROR_INVALID_STATE;
1835         }
1836
1837         /* check state */
1838         if (state != VC_STATE_INITIALIZED) {
1839                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1840                 return VC_ERROR_INVALID_STATE;
1841         }
1842
1843         vc_mgr_client_set_service_state_changed_cb(g_vc_m, NULL, NULL);
1844         return 0;
1845 }
1846
1847 int vc_mgr_set_speech_detected_cb(vc_mgr_begin_speech_detected_cb callback, void* user_data)
1848 {
1849         if (callback == NULL)
1850                 return VC_ERROR_INVALID_PARAMETER;
1851
1852         vc_state_e state;
1853         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1854                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set state changed callback : A handle is not available");
1855                 return VC_ERROR_INVALID_STATE;
1856         }
1857
1858         /* check state */
1859         if (state != VC_STATE_INITIALIZED) {
1860                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set speech detected callback : Current state is not 'Initialized'");
1861                 return VC_ERROR_INVALID_STATE;
1862         }
1863
1864         vc_mgr_client_set_speech_detected_cb(g_vc_m, callback, user_data);
1865
1866         return 0;
1867 }
1868
1869 int vc_mgr_unset_speech_detected_cb()
1870 {
1871         vc_state_e state;
1872         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1873                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : A handle is not available");
1874                 return VC_ERROR_INVALID_STATE;
1875         }
1876
1877         /* check state */
1878         if (state != VC_STATE_INITIALIZED) {
1879                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset state changed callback : Current state is not 'Initialized'");
1880                 return VC_ERROR_INVALID_STATE;
1881         }
1882
1883         vc_mgr_client_set_speech_detected_cb(g_vc_m, NULL, NULL);
1884         return 0;
1885 }
1886
1887 int vc_mgr_set_current_language_changed_cb(vc_current_language_changed_cb callback, void* user_data)
1888 {
1889         if (NULL == callback)
1890                 return VC_ERROR_INVALID_PARAMETER;
1891
1892         vc_state_e state;
1893         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1894                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : A handle is not available");
1895                 return VC_ERROR_INVALID_STATE;
1896         }
1897
1898         /* check state */
1899         if (state != VC_STATE_INITIALIZED) {
1900                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set current language changed : Current state is not 'Initialized'");
1901                 return VC_ERROR_INVALID_STATE;
1902         }
1903
1904         vc_mgr_client_set_current_lang_changed_cb(g_vc_m, callback, user_data);
1905
1906         return 0;
1907 }
1908
1909 int vc_mgr_unset_current_language_changed_cb()
1910 {
1911         vc_state_e state;
1912         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1913                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : A handle is not available");
1914                 return VC_ERROR_INVALID_STATE;
1915         }
1916
1917         /* check state */
1918         if (state != VC_STATE_INITIALIZED) {
1919                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset current language changed : Current state is not 'Initialized'");
1920                 return VC_ERROR_INVALID_STATE;
1921         }
1922
1923         vc_mgr_client_set_current_lang_changed_cb(g_vc_m, NULL, NULL);
1924
1925         return 0;
1926 }
1927
1928 int vc_mgr_set_error_cb(vc_error_cb callback, void* user_data)
1929 {
1930         if (NULL == callback)
1931                 return VC_ERROR_INVALID_PARAMETER;
1932
1933         vc_state_e state;
1934         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1935                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : A handle is not available");
1936                 return VC_ERROR_INVALID_STATE;
1937         }
1938
1939         /* check state */
1940         if (state != VC_STATE_INITIALIZED) {
1941                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Set error callback : Current state is not 'Initialized'");
1942                 return VC_ERROR_INVALID_STATE;
1943         }
1944
1945         vc_mgr_client_set_error_cb(g_vc_m, callback,  user_data);
1946
1947         return 0;
1948 }
1949
1950 int vc_mgr_unset_error_cb()
1951 {
1952         vc_state_e state;
1953         if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
1954                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : A handle is not available");
1955                 return VC_ERROR_INVALID_STATE;
1956         }
1957
1958         /* check state */
1959         if (state != VC_STATE_INITIALIZED) {
1960                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Unset error callback : Current state is not 'Initialized'");
1961                 return VC_ERROR_INVALID_STATE;
1962         }
1963
1964         vc_mgr_client_set_error_cb(g_vc_m, NULL, NULL);
1965
1966         return 0;
1967 }
1968
1969 static bool __vc_mgr_check_demandable_client(int pid)
1970 {
1971         if (0 == g_slist_length(g_demandable_client_list)) {
1972                 SLOG(LOG_WARN, TAG_VCM, "[WARNING] No demandable clients");
1973                 return false;
1974         }
1975
1976         char appid[128] = {'\0', };
1977         aul_app_get_appid_bypid(pid, appid, sizeof(appid));
1978
1979         if (0 >= strlen(appid)) {
1980                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No appid");
1981                 return false;
1982         }
1983         SLOG(LOG_DEBUG, TAG_VCM, "[CHECK] Appid - %s", appid);
1984
1985         GSList *iter = NULL;
1986         vc_demandable_client_s* temp_client;
1987         iter = g_slist_nth(g_demandable_client_list, 0);
1988
1989         while (NULL != iter) {
1990                 temp_client = iter->data;
1991
1992                 if (NULL != temp_client) {
1993                         if (NULL != temp_client->appid) {
1994                                 if (!strcmp(temp_client->appid, appid)) {
1995                                         SLOG(LOG_DEBUG, TAG_VCM, "pid(%d) is available", pid);
1996                                         return true;
1997                                 }
1998                         }
1999                 }
2000
2001                 iter = g_slist_next(iter);
2002         }
2003
2004         return false;
2005 }
2006
2007 /* Authority */
2008 int __vc_mgr_request_auth_enable(int pid)
2009 {
2010         if (false == __vc_mgr_check_demandable_client(pid)) {
2011                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Not demandable client");
2012                 return VC_ERROR_INVALID_PARAMETER;
2013         }
2014
2015         /* check already authorized */
2016         if (true == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
2017                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Already authorized");
2018                 return VC_ERROR_INVALID_PARAMETER;
2019         }
2020
2021         /* add authorized list */
2022         if (0 != vc_mgr_client_add_authorized_client(g_vc_m, pid)) {
2023                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to add authorized client");
2024                 return VC_ERROR_OPERATION_FAILED;
2025         }
2026
2027         /* foreground check */
2028         int fore_pid = 0;
2029         if (0 != vc_mgr_client_get_foreground(g_vc_m, &fore_pid)) {
2030                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to get foreground");
2031                 return VC_ERROR_OPERATION_FAILED;
2032         }
2033
2034         if (pid == fore_pid) {
2035                 vc_mgr_client_set_valid_authorized_client(g_vc_m, pid);
2036         }
2037
2038         return 0;
2039 }
2040
2041 int __vc_mgr_request_auth_disable(int pid)
2042 {
2043         /* check authorized */
2044         if (false == vc_mgr_client_is_authorized_client(g_vc_m, pid)) {
2045                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No authorized");
2046                 return VC_ERROR_INVALID_PARAMETER;
2047         }
2048
2049         /* remove authorized list */
2050         if (0 != vc_mgr_client_remove_authorized_client(g_vc_m, pid)) {
2051                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to remove authorized client");
2052                 return VC_ERROR_OPERATION_FAILED;
2053         }
2054
2055         /* check authority valid */
2056         if (true == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2057                 SLOG(LOG_DEBUG, TAG_VCM, "Valid authorized client is removed");
2058                 if (0 != vc_mgr_client_set_valid_authorized_client(g_vc_m, -1)) {
2059                         SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set valid authorized client");
2060                         return VC_ERROR_OPERATION_FAILED;
2061                 }
2062         }
2063
2064         return 0;
2065 }
2066
2067 static Eina_Bool __request_auth_start(void* data)
2068 {
2069         SLOG(LOG_DEBUG, TAG_VCM, "Request Start");
2070
2071         if (0 != vc_mgr_client_set_start_by_client(g_vc_m, true)) {
2072                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
2073         }
2074
2075         if (0 != vc_mgr_start(false)) {
2076                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request start is failed");
2077                 /* TODO - Error handling? */
2078         }
2079
2080         if (0 != vc_mgr_client_set_start_by_client(g_vc_m, false)) {
2081                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set start by client");
2082         }
2083
2084
2085         return EINA_FALSE;
2086 }
2087
2088 int __vc_mgr_request_auth_start(int pid)
2089 {
2090         /* check authorized */
2091         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2092                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
2093                 return VC_ERROR_INVALID_PARAMETER;
2094         }
2095
2096         /* add timer for start recording */
2097         ecore_timer_add(0, __request_auth_start, NULL);
2098
2099         return 0;
2100 }
2101
2102 static Eina_Bool __request_auth_stop(void* data)
2103 {
2104         SLOG(LOG_DEBUG, TAG_VCM, "Request Stop");
2105
2106         if (0 != vc_mgr_stop()) {
2107                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request stop is failed");
2108                 /* TODO - Error handling? */
2109         }
2110
2111         return EINA_FALSE;
2112 }
2113
2114 int __vc_mgr_request_auth_stop(int pid)
2115 {
2116         /* check authorized */
2117         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2118                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] No valid authorized client");
2119                 return VC_ERROR_INVALID_PARAMETER;
2120         }
2121
2122         /* add timer for start recording */
2123         ecore_timer_add(0, __request_auth_stop, NULL);
2124
2125         return 0;
2126 }
2127
2128 static Eina_Bool __request_auth_cancel(void* data)
2129 {
2130         SLOG(LOG_DEBUG, TAG_VCM, "Request Cancel");
2131
2132         if (0 != vc_mgr_cancel()) {
2133                 SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Request cancel is failed");
2134                 /* TODO - Error handling? */
2135         }
2136
2137         return EINA_FALSE;
2138 }
2139
2140 int __vc_mgr_request_auth_cancel(int pid)
2141 {
2142         /* check authorized */
2143         if (false == vc_mgr_client_is_valid_authorized_client(g_vc_m, pid)) {
2144                 SLOG(LOG_ERROR,  TAG_VCM, "[ERROR] No valid authorized client");
2145                 return VC_ERROR_INVALID_PARAMETER;
2146         }
2147
2148         /* add timer for start recording */
2149         ecore_timer_add(0, __request_auth_cancel, NULL);
2150
2151         return 0;
2152 }