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