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