server/sttd_server.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <aul.h>
  15 #include <pthread.h>
  16 #include <sound_manager.h>
  17 #include <wav_player.h>
  18
  19 #include "stt_network.h"
  20 #include "sttd_client_data.h"
  21 #include "sttd_config.h"
  22 #include "sttd_dbus.h"
  23 #include "sttd_engine_agent.h"
  24 #include "sttd_main.h"
  25 #include "sttd_recorder.h"
  26 #include "stt_defs.h"
  27 #include "sttd_server.h"
  28
  29
  30 #define CLIENT_CLEAN_UP_TIME 500
  31
  32
  33 static pthread_mutex_t stte_result_mutex = PTHREAD_MUTEX_INITIALIZER;
  34 static pthread_mutex_t stte_result_time_mutex = PTHREAD_MUTEX_INITIALIZER;
  35
  36
  37 /*
  38 * STT Server static variable
  39 */
  40 static double g_processing_timeout = 60;
  41
  42 static double g_recording_timeout = 60;
  43
  44 static Ecore_Timer *g_check_client_timer = NULL;
  45 static Ecore_Timer *g_recording_timer = NULL;
  46 static Ecore_Timer *g_processing_timer = NULL;
  47 static Ecore_Timer *g_stop_by_silence_timer = NULL;
  48
  49 static int g_recording_log_count = 0;
  50
  51 static GList *g_proc_list = NULL;
  52
  53 /*
  54 * STT Server Callback Functions
  55 */
  56 static void __cancel_recognition_internal();
  57
  58 static Eina_Bool __stop_by_silence(void *data)
  59 {
  60         SLOG(LOG_INFO, TAG_STTD, "===== Stop by silence detection");
  61
  62         unsigned int uid = stt_client_get_current_recognition();
  63
  64         if (STT_INVALID_UID != uid) {
  65                 int ret = sttd_server_stop(uid);
  66                 if (STTD_ERROR_NONE != ret) {
  67                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Fail to stop recording");
  68                         __cancel_recognition_internal();
  69                 }
  70         } else {
  71                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
  72         }
  73
  74         SLOG(LOG_INFO, TAG_STTD, "=====");
  75         SLOG(LOG_DEBUG, TAG_STTD, "  ");
  76
  77         g_stop_by_silence_timer = NULL;
  78         return EINA_FALSE;
  79 }
  80
  81 static void __cancel_recognition_internal()
  82 {
  83         if (NULL != g_recording_timer)  {
  84                 ecore_timer_del(g_recording_timer);
  85                 g_recording_timer = NULL;
  86         }
  87
  88         int ret = 0;
  89         unsigned int uid = stt_client_get_current_recognition();
  90
  91         app_state_e state = 0;
  92         ret = sttd_client_get_state(uid, &state);
  93
  94         if (0 != ret) {
  95                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
  96                 return;
  97         }
  98
  99         if (0 != uid && (APP_STATE_PROCESSING == state || APP_STATE_RECORDING == state)) {
 100                 SLOG(LOG_INFO, TAG_STTD, "===== cancel by internal");
 101                 /* cancel engine recognition */
 102                 ret = sttd_server_cancel(uid);
 103                 if (0 != ret) {
 104                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
 105                 }
 106         } else {
 107                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
 108         }
 109 }
 110
 111 static void __cancel_by_error(void *data)
 112 {
 113         SLOG(LOG_INFO, TAG_STTD, "===== Cancel by error");
 114
 115         __cancel_recognition_internal();
 116
 117         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 118         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 119
 120         return;
 121 }
 122
 123 static int __server_audio_recorder_callback(const void* data, const unsigned int length)
 124 {
 125         int ret;
 126
 127         if (NULL == data || 0 == length) {
 128                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Recording data is not valid");
 129                 ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 130                 return -1;
 131         }
 132
 133         unsigned int uid = stt_client_get_current_recognition();
 134         if (STT_INVALID_UID != uid) {
 135                 ret = sttd_engine_agent_set_recording_data(data, length);
 136                 if (ret < 0) {
 137                         ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 138                         return -1;
 139                 }
 140                 g_recording_log_count++;
 141                 if (200 <= g_recording_log_count) {
 142                         SLOG(LOG_DEBUG, TAG_STTD, "=== Set recording data ===");
 143                         g_recording_log_count = 0;
 144                 }
 145         } else {
 146                 if (NULL != g_recording_timer)  {
 147                         ecore_timer_del(g_recording_timer);
 148                         g_recording_timer = NULL;
 149                 }
 150                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current uid in recording is is not valid");
 151                 return -1;
 152         }
 153
 154         return 0;
 155 }
 156
 157 static void __server_audio_interrupt_callback()
 158 {
 159         SLOG(LOG_INFO, TAG_STTD, "===== Cancel by sound interrupt");
 160
 161         __cancel_recognition_internal();
 162
 163         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 164         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 165 }
 166
 167 static int __server_recognition_result_callback(stte_result_event_e event, const char* type,
 168                                         const char** data, int data_count, const char* msg, void *user_data)
 169 {
 170         // critical section
 171         pthread_mutex_lock(&stte_result_mutex);
 172
 173         SLOG(LOG_INFO, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
 174
 175         /* check uid */
 176         unsigned int uid = stt_client_get_current_recognition();
 177
 178         app_state_e state;
 179         if (STT_INVALID_UID == uid || 0 != sttd_client_get_state(uid, &state)) {
 180                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid (%u)", uid);
 181                 SLOG(LOG_DEBUG, TAG_STTD, "=====");
 182                 SLOG(LOG_DEBUG, TAG_STTD, "  ");
 183                 pthread_mutex_unlock(&stte_result_mutex);
 184                 return STTD_ERROR_OPERATION_FAILED;
 185         }
 186
 187         SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%u), event(%d)", uid, event);
 188
 189         /* send result to client */
 190         if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
 191                 if (APP_STATE_PROCESSING != state) {
 192                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
 193                 }
 194                 SLOG(LOG_INFO, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
 195
 196                 /* Delete timer for processing time out */
 197                 ecore_thread_main_loop_begin();
 198                 if (NULL != g_processing_timer) {
 199                         SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
 200                         ecore_timer_del(g_processing_timer);
 201                         g_processing_timer = NULL;
 202                 }
 203                 ecore_thread_main_loop_end();
 204
 205                 sttd_config_time_save();
 206                 sttd_config_time_reset();
 207
 208                 sttd_recorder_clear();
 209
 210                 sttd_client_set_state(uid, APP_STATE_READY);
 211                 stt_client_unset_current_recognition();
 212
 213                 if (NULL == data || 0 == data_count) {
 214                         if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
 215                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 216                                 int reason = (int)STTD_ERROR_OPERATION_FAILED;
 217
 218                                 if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 219                                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 220                                 }
 221                         }
 222                 } else {
 223                         if (0 != sttdc_send_result(uid, event, data, data_count, msg)) {
 224                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 225                                 int reason = (int)STTD_ERROR_OPERATION_FAILED;
 226
 227                                 if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 228                                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 229                                 }
 230                         }
 231                 }
 232
 233         } else if (STTE_RESULT_EVENT_PARTIAL_RESULT == event) {
 234                 SLOG(LOG_INFO, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
 235
 236                 sttd_config_time_save();
 237                 sttd_config_time_reset();
 238
 239                 if (0 != sttdc_send_result(uid, event, data, data_count, msg)) {
 240                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 241                         int reason = (int)STTD_ERROR_OPERATION_FAILED;
 242
 243                         if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 244                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 245                         }
 246                 }
 247
 248         } else if (STTE_RESULT_EVENT_ERROR == event) {
 249                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The event of recognition result is ERROR");
 250
 251                 /* Delete timer for processing time out */
 252                 ecore_thread_main_loop_begin();
 253                 if (NULL != g_processing_timer) {
 254                         SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
 255                         ecore_timer_del(g_processing_timer);
 256                         g_processing_timer = NULL;
 257                 }
 258                 ecore_thread_main_loop_end();
 259                 sttd_config_time_reset();
 260
 261                 int ret = 0;
 262                 if (APP_STATE_RECORDING == state) {
 263                         ret = sttd_engine_agent_recognize_cancel();
 264                         if (0 != ret) {
 265                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel: result(%d)", ret);
 266                         }
 267                 }
 268
 269                 sttd_client_set_state(uid, APP_STATE_READY);
 270                 stt_client_unset_current_recognition();
 271
 272                 if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
 273                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
 274
 275                         /* send error msg */
 276                         int reason = (int)STTD_ERROR_INVALID_STATE;
 277                         if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
 278                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
 279                         }
 280                 }
 281         } else {
 282                 /* nothing */
 283         }
 284
 285         SLOG(LOG_INFO, TAG_STTD, "=====");
 286         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 287         pthread_mutex_unlock(&stte_result_mutex);
 288
 289         return STTD_ERROR_NONE;
 290 }
 291
 292 static bool __server_result_time_callback(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
 293 {
 294         pthread_mutex_lock(&stte_result_time_mutex);
 295
 296         SECURE_SLOG(LOG_INFO, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
 297                 index, event, text, start_time, end_time);
 298
 299         int ret;
 300         ret = sttd_config_time_add(index, (int)event, text, start_time, end_time);
 301         if (0 != ret) {
 302                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add time info");
 303                 pthread_mutex_unlock(&stte_result_time_mutex);
 304                 return false;
 305         }
 306
 307         pthread_mutex_unlock(&stte_result_time_mutex);
 308
 309         return true;
 310 }
 311
 312 static int __server_speech_status_callback(stte_speech_status_e status, void *user_param)
 313 {
 314         SLOG(LOG_INFO, TAG_STTD, "===== Speech status detected Callback");
 315
 316         unsigned int uid = stt_client_get_current_recognition();
 317         if (STT_INVALID_UID != uid) {
 318                 app_state_e state;
 319                 if (0 != sttd_client_get_state(uid, &state)) {
 320                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is not valid ");
 321                         return STTD_ERROR_OPERATION_FAILED;
 322                 }
 323
 324                 if (APP_STATE_RECORDING != state && APP_STATE_PROCESSING != state) {
 325                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording, state(%d), status(%d)", state, status);
 326                         return STTD_ERROR_INVALID_STATE;
 327                 }
 328
 329                 if (STTE_SPEECH_STATUS_BEGINNING_POINT_DETECTED == status) {
 330                         SLOG(LOG_DEBUG, TAG_STTD, "Begin Speech detected");
 331                         sttdc_send_speech_status(uid, status);
 332                 } else if (STTE_SPEECH_STATUS_END_POINT_DETECTED == status) {
 333                         SLOG(LOG_DEBUG, TAG_STTD, "End Speech detected");
 334                         ecore_thread_main_loop_begin();
 335                         if (NULL == g_stop_by_silence_timer) {
 336                                 g_stop_by_silence_timer = ecore_timer_add(0, __stop_by_silence, NULL);
 337                         }
 338                         ecore_thread_main_loop_end();
 339                 }
 340         } else {
 341                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recognition uid is not valid ");
 342         }
 343
 344         SLOG(LOG_INFO, TAG_STTD, "=====");
 345         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 346
 347         return STTD_ERROR_NONE;
 348 }
 349
 350 static int __server_error_callback(stte_error_e error, const char* msg)
 351 {
 352         SLOG(LOG_ERROR, TAG_STTD, "[Server] Error Callback is called, error(%d), err_msg(%s)", error, msg);
 353         ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 354
 355         return STTD_ERROR_NONE;
 356 }
 357
 358 static void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data)
 359 {
 360         if (NULL == engine_id) {
 361                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
 362                 return;
 363         } else {
 364                 SLOG(LOG_INFO, TAG_STTD, "[Server] New default engine : %s", engine_id);
 365         }
 366
 367         return;
 368 }
 369
 370 static void __sttd_server_language_changed_cb(const char* language, void* user_data)
 371 {
 372         if (NULL == language) {
 373                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
 374                 return;
 375         } else {
 376                 SLOG(LOG_INFO, TAG_STTD, "[Server] Get language changed : %s", language);
 377         }
 378
 379         int ret = sttd_engine_agent_set_default_language(language);
 380         if (0 != ret)
 381                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
 382
 383         return;
 384 }
 385
 386 static void __sttd_server_silence_changed_cb(bool value, void* user_data)
 387 {
 388         SLOG(LOG_INFO, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
 389
 390         int ret = 0;
 391         ret = sttd_engine_agent_set_silence_detection(value);
 392         if (0 != ret)
 393                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
 394
 395         return;
 396 }
 397
 398 /*
 399 * Daemon function
 400 */
 401 int sttd_initialize(stte_request_callback_s *callback)
 402 {
 403         int ret = 0;
 404
 405         if (0 != pthread_mutex_init(&stte_result_mutex, NULL)) {
 406                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize stte result mutex.");
 407         }
 408
 409         if (0 != pthread_mutex_init(&stte_result_time_mutex, NULL)) {
 410                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize stte stte_result_time_mutex.");
 411         }
 412
 413         if (sttd_config_initialize(__sttd_server_engine_changed_cb, __sttd_server_language_changed_cb,
 414                 __sttd_server_silence_changed_cb, NULL)) {
 415                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize config.");
 416         }
 417
 418         ret = sttd_recorder_initialize(__server_audio_recorder_callback, __server_audio_interrupt_callback);
 419         if (0 != ret) {
 420                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize recorder : result(%d)", ret);
 421                 return ret;
 422         }
 423
 424         /* Engine Agent initialize */
 425         ret = sttd_engine_agent_init(__server_recognition_result_callback, __server_result_time_callback,
 426                 __server_speech_status_callback, __server_error_callback);
 427         if (0 != ret) {
 428                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
 429                 return ret;
 430         }
 431
 432         /* load engine */
 433         ret = sttd_engine_agent_load_current_engine(callback);
 434         if (0 != ret) {
 435                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
 436                 return ret;
 437         }
 438
 439         g_check_client_timer = ecore_timer_add(CLIENT_CLEAN_UP_TIME, sttd_cleanup_client, NULL);
 440         if (NULL == g_check_client_timer) {
 441                 SLOG(LOG_WARN, TAG_STTD, "[Main Warning] Fail to create timer of client check");
 442         }
 443
 444         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] initialize");
 445
 446         return 0;
 447 }
 448
 449 int sttd_finalize()
 450 {
 451         if (0 != pthread_mutex_destroy(&stte_result_mutex)) {
 452                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stte result mutex.");
 453         }
 454
 455         if (0 != pthread_mutex_destroy(&stte_result_time_mutex)) {
 456                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stte_result_time_mutex.");
 457         }
 458
 459         GList *iter = NULL;
 460         if (0 < g_list_length(g_proc_list)) {
 461                 iter = g_list_first(g_proc_list);
 462                 while (NULL != iter) {
 463                         g_proc_list = g_list_delete_link(g_proc_list, iter);
 464                         iter = g_list_first(g_proc_list);
 465                 }
 466         }
 467
 468         sttd_recorder_deinitialize();
 469
 470         sttd_config_finalize();
 471
 472         sttd_engine_agent_release();
 473
 474         if (NULL != g_check_client_timer) {
 475                 ecore_timer_del(g_check_client_timer);
 476                 g_check_client_timer = NULL;
 477
 478                 SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete ecore timer handle");
 479         }
 480
 481         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] finalize");
 482
 483         return STTD_ERROR_NONE;
 484 }
 485
 486 static void __read_proc()
 487 {
 488         DIR *dp = NULL;
 489         struct dirent *dirp = NULL;
 490         int tmp;
 491
 492         GList *iter = NULL;
 493         if (0 < g_list_length(g_proc_list)) {
 494                 iter = g_list_first(g_proc_list);
 495                 while (NULL != iter) {
 496                         g_proc_list = g_list_delete_link(g_proc_list, iter);
 497                         iter = g_list_first(g_proc_list);
 498                 }
 499         }
 500
 501         dp = opendir("/proc");
 502         if (NULL == dp) {
 503                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to open proc");
 504         } else {
 505                 do {
 506                         dirp = readdir(dp);
 507
 508                         if (NULL != dirp) {
 509                                 tmp = atoi(dirp->d_name);
 510                                 if (0 >= tmp)   continue;
 511                                 g_proc_list = g_list_append(g_proc_list, GINT_TO_POINTER(tmp));
 512                         }
 513                 } while (NULL != dirp);
 514                 closedir(dp);
 515         }
 516         return;
 517 }
 518
 519 Eina_Bool sttd_cleanup_client(void *data)
 520 {
 521         unsigned int* client_list = NULL;
 522         int client_count = 0;
 523         int i = 0;
 524         int j = 0;
 525         bool exist = false;
 526
 527         if (0 != sttd_client_get_list(&client_list, &client_count)) {
 528                 if (NULL != client_list)
 529                         free(client_list);
 530
 531                 return EINA_TRUE;
 532         }
 533
 534         if (NULL != client_list) {
 535                 SLOG(LOG_INFO, TAG_STTD, "===== Clean up client ");
 536
 537                 __read_proc();
 538
 539                 for (i = 0; i < client_count; i++) {
 540                         int pid = sttd_client_get_pid(client_list[i]);
 541                         if (0 > pid) {
 542                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Invalid pid");
 543                                 continue;
 544                         }
 545
 546                         exist = false;
 547                         GList *iter = NULL;
 548                         for (j = 0; j < g_list_length(g_proc_list); j++) {
 549                                 iter = g_list_nth(g_proc_list, j);
 550                                 if (NULL != iter) {
 551                                         if (pid == GPOINTER_TO_INT(iter->data)) {
 552                                                 SLOG(LOG_DEBUG, TAG_STTD, "uid (%u) is running", client_list[i]);
 553                                                 exist = true;
 554                                                 break;
 555                                         }
 556                                 }
 557                         }
 558
 559                         if (false == exist) {
 560                                 SLOG(LOG_ERROR, TAG_STTD, "uid (%u) should be removed", client_list[i]);
 561                                 sttd_server_finalize(client_list[i]);
 562                         }
 563                 }
 564
 565                 SLOG(LOG_INFO, TAG_STTD, "=====");
 566                 SLOG(LOG_DEBUG, TAG_STTD, "  ");
 567
 568                 free(client_list);
 569         }
 570
 571         return EINA_TRUE;
 572 }
 573
 574 /*
 575 * STT Server Functions for Client
 576 */
 577
 578 int sttd_server_initialize(int pid, unsigned int uid, bool* silence, bool* credential)
 579 {
 580         int ret = STTD_ERROR_NONE;
 581
 582         SLOG(LOG_INFO, TAG_STTD, "[Server] server initialize");
 583
 584         /* check if uid is valid */
 585         app_state_e state;
 586         if (0 == sttd_client_get_state(uid, &state)) {
 587                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid has already been registered");
 588                 return STTD_ERROR_NONE;
 589         }
 590
 591         ret = sttd_engine_agent_get_option_supported(silence);
 592         if (0 != ret) {
 593                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
 594                 return ret;
 595         }
 596
 597         ret = sttd_engine_agent_is_credential_needed(uid, credential);
 598         if (0 != ret) {
 599                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
 600                 return ret;
 601         }
 602
 603         /* Add client information to client manager */
 604         ret = sttd_client_add(pid, uid);
 605         if (0 != ret) {
 606                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add client info");
 607                 return ret;
 608         }
 609
 610         SLOG(LOG_INFO, TAG_STTD, "[Server Success] server initialize");
 611
 612         return STTD_ERROR_NONE;
 613 }
 614
 615 static Eina_Bool __quit_ecore_loop(void *data)
 616 {
 617         SLOG(LOG_INFO, TAG_STTD, "[Server] Quit");
 618
 619         stt_network_finalize();
 620         sttd_finalize();
 621         sttd_dbus_close_connection();
 622         ecore_main_loop_quit();
 623
 624         SLOG(LOG_INFO, TAG_STTD, "");
 625
 626         return EINA_FALSE;
 627 }
 628
 629 static void delete_timers_related_to_recording_session()
 630 {
 631         if (NULL != g_recording_timer)  {
 632                 ecore_timer_del(g_recording_timer);
 633                 g_recording_timer = NULL;
 634         }
 635
 636         if (NULL != g_processing_timer) {
 637                 SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
 638                 ecore_timer_del(g_processing_timer);
 639                 g_processing_timer = NULL;
 640         }
 641
 642         if (NULL != g_stop_by_silence_timer) {
 643                 ecore_timer_del(g_stop_by_silence_timer);
 644                 g_stop_by_silence_timer = NULL;
 645         }
 646 }
 647
 648 int sttd_server_finalize(unsigned int uid)
 649 {
 650         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter Finalize");
 651
 652         /* check if uid is valid */
 653         app_state_e state;
 654         if (0 != sttd_client_get_state(uid, &state)) {
 655                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 656                 return STTD_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         /* release recorder */
 660         if (APP_STATE_RECORDING == state || APP_STATE_PROCESSING == state) {
 661                 delete_timers_related_to_recording_session();
 662
 663                 SLOG(LOG_INFO, TAG_STTD, "[Server INFO] stt_cancel is invoked while state is (%d)", state);
 664                 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
 665                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
 666                 }
 667
 668                 stt_client_unset_current_recognition();
 669         }
 670
 671         /* Remove client information */
 672         if (0 != sttd_client_delete(uid)) {
 673                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to delete client");
 674         }
 675
 676         /* unload engine, if ref count of client is 0 */
 677         if (0 == sttd_client_get_ref_count()) {
 678                 ecore_timer_add(0, __quit_ecore_loop, NULL);
 679         }
 680
 681         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End Finalize");
 682
 683         return STTD_ERROR_NONE;
 684 }
 685
 686 int sttd_server_get_supported_engines(unsigned int uid, GSList** engine_list)
 687 {
 688         /* Check if uid is valid */
 689         app_state_e state;
 690         if (0 != sttd_client_get_state(uid, &state)) {
 691                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 692                 return STTD_ERROR_INVALID_PARAMETER;
 693         }
 694
 695         /* Check state of uid */
 696         if (APP_STATE_READY != state) {
 697                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
 698                 return STTD_ERROR_INVALID_STATE;
 699         }
 700
 701         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported egnines");
 702
 703         int ret;
 704         ret = sttd_engine_agent_get_engine_list(engine_list);
 705         if (0 != ret) {
 706                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine list");
 707                 return ret;
 708         }
 709
 710         return STTD_ERROR_NONE;
 711 }
 712
 713 int sttd_server_set_current_engine(unsigned int uid, const char* engine_id, bool* silence, bool* credential)
 714 {
 715         /* Check if uid is valid */
 716         app_state_e state;
 717         if (0 != sttd_client_get_state(uid, &state)) {
 718                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 719                 return STTD_ERROR_INVALID_PARAMETER;
 720         }
 721
 722         /* Check state of uid */
 723         if (APP_STATE_READY != state) {
 724                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
 725                 return STTD_ERROR_INVALID_STATE;
 726         }
 727
 728         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%u), engine_id(%s)", uid, engine_id);
 729
 730         int ret;
 731         ret = sttd_engine_agent_load_current_engine(NULL);
 732         if (0 != ret) {
 733                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : %d", ret);
 734                 return ret;
 735         }
 736
 737         ret = sttd_engine_agent_get_option_supported(silence);
 738         if (0 != ret) {
 739                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine options : %d", ret);
 740                 return ret;
 741         }
 742
 743         if (0 != sttd_engine_agent_is_credential_needed(uid, credential)) {
 744                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
 745                 return ret;
 746         }
 747
 748         return STTD_ERROR_NONE;
 749 }
 750
 751 int sttd_server_get_current_engine(unsigned int uid, char** engine_id)
 752 {
 753         /* Check if uid is valid */
 754         app_state_e state;
 755         if (0 != sttd_client_get_state(uid, &state)) {
 756                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 757                 return STTD_ERROR_INVALID_PARAMETER;
 758         }
 759
 760         /* Check state of uid */
 761         if (APP_STATE_READY != state) {
 762                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
 763                 return STTD_ERROR_INVALID_STATE;
 764         }
 765
 766         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%u)", uid);
 767
 768         int ret;
 769         ret = sttd_engine_agent_get_current_engine(engine_id);
 770         if (0 != ret) {
 771                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine : %d", ret);
 772                 return ret;
 773         }
 774
 775         return STTD_ERROR_NONE;
 776 }
 777
 778 int sttd_server_check_app_agreed(unsigned int uid, const char* appid, bool* available)
 779 {
 780         /* Check if uid is valid */
 781         app_state_e state;
 782         if (0 != sttd_client_get_state(uid, &state)) {
 783                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 784                 return STTD_ERROR_INVALID_PARAMETER;
 785         }
 786
 787         /* Check state of uid */
 788         if (APP_STATE_READY != state) {
 789                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
 790                 return STTD_ERROR_INVALID_STATE;
 791         }
 792
 793         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] check app agreed");
 794
 795         /* Ask engine available */
 796         int ret;
 797         bool temp = false;
 798         ret = sttd_engine_agent_check_app_agreed(appid, &temp);
 799         if (0 != ret) {
 800                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
 801                 return ret;
 802         }
 803
 804         if (true == temp) {
 805                 stt_client_set_app_agreed(uid);
 806                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] App(%s) confirmed that engine is available", appid);
 807         }
 808
 809         *available = temp;
 810
 811         return STTD_ERROR_NONE;
 812 }
 813
 814
 815 int sttd_server_get_supported_languages(unsigned int uid, GSList** lang_list)
 816 {
 817         /* check if uid is valid */
 818         app_state_e state;
 819         if (0 != sttd_client_get_state(uid, &state)) {
 820                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 821                 return STTD_ERROR_INVALID_PARAMETER;
 822         }
 823
 824         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported languages");
 825
 826         /* get language list from engine */
 827         int ret = sttd_engine_agent_supported_langs(lang_list);
 828         if (0 != ret) {
 829                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get supported languages");
 830                 return ret;
 831         }
 832
 833         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] sttd_server_get_supported_languages");
 834
 835         return STTD_ERROR_NONE;
 836 }
 837
 838 int sttd_server_get_current_langauage(unsigned int uid, char** current_lang)
 839 {
 840         /* check if uid is valid */
 841         app_state_e state;
 842         if (0 != sttd_client_get_state(uid, &state)) {
 843                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 844                 return STTD_ERROR_INVALID_PARAMETER;
 845         }
 846
 847         if (NULL == current_lang) {
 848                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 849                 return STTD_ERROR_INVALID_PARAMETER;
 850         }
 851
 852         /*get current language from engine */
 853         int ret = sttd_engine_agent_get_default_lang(current_lang);
 854         if (0 != ret) {
 855                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get default language :result(%d)", ret);
 856                 return ret;
 857         }
 858
 859         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get default language, current_lang(%s)", *current_lang);
 860
 861         return STTD_ERROR_NONE;
 862 }
 863
 864 int sttd_server_set_private_data(unsigned int uid, const char* key, const char* data)
 865 {
 866         /* check if uid is valid */
 867         app_state_e state;
 868         if (0 != sttd_client_get_state(uid, &state)) {
 869                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 870                 return STTD_ERROR_INVALID_PARAMETER;
 871         }
 872
 873         if (NULL == key || NULL == data) {
 874                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 875                 return STTD_ERROR_INVALID_PARAMETER;
 876         }
 877
 878         /* set private data to engine */
 879         int ret = -1;
 880         ret = sttd_engine_agent_set_private_data(key, data);
 881         if (0 != ret) {
 882                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set private data :result(%d)", ret);
 883                 return ret;
 884         }
 885
 886         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Set private data");
 887
 888         return STTD_ERROR_NONE;
 889 }
 890
 891 int sttd_server_get_private_data(unsigned int uid, const char* key, char** data)
 892 {
 893         /* check if uid is valid */
 894         app_state_e state;
 895         if (0 != sttd_client_get_state(uid, &state)) {
 896                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 897                 return STTD_ERROR_INVALID_PARAMETER;
 898         }
 899
 900         if (NULL == key || NULL == data) {
 901                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 902                 return STTD_ERROR_INVALID_PARAMETER;
 903         }
 904
 905         /* get private data to engine */
 906         int ret = -1;
 907         ret = sttd_engine_agent_get_private_data(key, data);
 908         if (0 != ret) {
 909                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get private data :result(%d)", ret);
 910                 return ret;
 911         }
 912
 913         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
 914
 915         return STTD_ERROR_NONE;
 916 }
 917
 918 int sttd_server_is_recognition_type_supported(unsigned int uid, const char* type, int* support)
 919 {
 920         /* check if uid is valid */
 921         app_state_e state;
 922         if (0 != sttd_client_get_state(uid, &state)) {
 923                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 924                 return STTD_ERROR_INVALID_PARAMETER;
 925         }
 926
 927         if (NULL == type || NULL == support) {
 928                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 929                 return STTD_ERROR_INVALID_PARAMETER;
 930         }
 931
 932         bool temp;
 933         int ret = sttd_engine_agent_is_recognition_type_supported(type, &temp);
 934         if (0 != ret) {
 935                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
 936                 return ret;
 937         }
 938
 939         *support = (int)temp;
 940
 941         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
 942
 943         return STTD_ERROR_NONE;
 944 }
 945
 946 int sttd_server_get_audio_format(unsigned int uid, stte_audio_type_e *type, int *rate, int *num_of_channels)
 947 {
 948         /* check if uid is valid */
 949         app_state_e state = APP_STATE_CREATED;
 950         if (0 != sttd_client_get_state(uid, &state)) {
 951                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 952                 return STTD_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         if (NULL == type || NULL == rate || NULL == num_of_channels) {
 956                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 957                 return STTD_ERROR_INVALID_PARAMETER;
 958         }
 959
 960         int ret = sttd_engine_agent_get_audio_format(type, rate, num_of_channels);
 961         if (0 != ret) {
 962                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
 963                 return ret;
 964         }
 965
 966         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Audio format: type(%d), rate(%d), number of channels(%d)", *type, *rate, *num_of_channels);
 967         return STTD_ERROR_NONE;
 968 }
 969
 970 int sttd_server_set_start_sound(unsigned int uid, const char* file)
 971 {
 972         /* check if uid is valid */
 973         app_state_e state;
 974         if (0 != sttd_client_get_state(uid, &state)) {
 975                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 976                 return STTD_ERROR_INVALID_PARAMETER;
 977         }
 978
 979         int ret = sttd_client_set_start_sound(uid, file);
 980         if (0 != ret) {
 981                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
 982                 return ret;
 983         }
 984
 985         return 0;
 986 }
 987
 988 int sttd_server_set_stop_sound(unsigned int uid, const char* file)
 989 {
 990         /* check if uid is valid */
 991         app_state_e state;
 992         if (0 != sttd_client_get_state(uid, &state)) {
 993                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 994                 return STTD_ERROR_INVALID_PARAMETER;
 995         }
 996
 997         int ret = sttd_client_set_stop_sound(uid, file);
 998         if (0 != ret) {
 999                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
1000                 return ret;
1001         }
1002
1003         return 0;
1004 }
1005
1006 static Eina_Bool __stop_by_recording_timeout(void *data)
1007 {
1008         SLOG(LOG_INFO, TAG_STTD, "===== Stop by timeout");
1009         g_recording_timer = NULL;
1010
1011         unsigned int uid = stt_client_get_current_recognition();
1012         if (STT_INVALID_UID != uid) {
1013                 /* cancel engine recognition */
1014                 int ret = sttd_server_stop(uid);
1015                 if (STTD_ERROR_NONE != ret) {
1016                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop : result(%d)", ret);
1017                 }
1018         }
1019
1020         SLOG(LOG_INFO, TAG_STTD, "=====");
1021         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1022
1023         return EINA_FALSE;
1024 }
1025
1026 static void __sttd_server_recorder_start(void* data)
1027 {
1028         uintptr_t puid = (uintptr_t)data;
1029         unsigned int uid = (unsigned int)puid;
1030         int current_uid = stt_client_get_current_recognition();
1031
1032         if (uid != current_uid) {
1033                 stt_client_unset_current_recognition();
1034                 return;
1035         }
1036
1037         char appid[1024] = {0, };
1038         int pid = sttd_client_get_pid(uid);
1039         int ret = -1;
1040         ret = aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1);
1041         if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1042                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to get application ID");
1043         } else {
1044                 SLOG(LOG_DEBUG, TAG_STTD, "[DEBUG] Current app id is %s", appid);
1045         }
1046
1047         ret = sttd_engine_agent_recognize_start_recorder(uid, appid);
1048         if (0 != ret) {
1049                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1050                 return;
1051         }
1052
1053         app_state_e temp_app_state;
1054         if (0 != sttd_client_get_state(uid, &temp_app_state)) {
1055                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1056                 return;
1057         }
1058         if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
1059                 /* Notify uid state change */
1060                 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1061                 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1062         }
1063 }
1064
1065 static void __sttd_start_sound_completed_cb(int id, void *user_data)
1066 {
1067         SLOG(LOG_INFO, TAG_STTD, "===== Start sound completed");
1068
1069         /* After wav play callback, recorder start */
1070         ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
1071
1072         SLOG(LOG_INFO, TAG_STTD, "=====");
1073         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1074         return;
1075 }
1076
1077 static int __sttd_server_check_precondition_to_start(unsigned int uid, const char* appid)
1078 {
1079         /* check if uid is valid */
1080         app_state_e state;
1081         if (0 != sttd_client_get_state(uid, &state)) {
1082                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1083                 return STTD_ERROR_INVALID_PARAMETER;
1084         }
1085
1086         /* check uid state */
1087         if (APP_STATE_READY != state) {
1088                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] sttd_server_start : current state is not ready");
1089                 return STTD_ERROR_INVALID_STATE;
1090         }
1091
1092         int ret = STTD_ERROR_NONE;
1093         if (false == stt_client_get_app_agreed(uid)) {
1094                 bool temp = false;
1095                 ret = sttd_engine_agent_check_app_agreed(appid, &temp);
1096                 if (0 != ret) {
1097                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
1098                         return ret;
1099                 }
1100
1101                 if (false == temp) {
1102                         SLOG(LOG_ERROR, TAG_STTD, "[Server] App(%s) NOT confirmed that engine is available", appid);
1103                         return STTD_ERROR_PERMISSION_DENIED;
1104                 }
1105
1106                 stt_client_set_app_agreed(uid);
1107         }
1108
1109         /* check if engine use network */
1110         if (true == sttd_engine_agent_need_network()) {
1111                 if (false == stt_network_is_connected()) {
1112                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
1113                         return STTD_ERROR_OUT_OF_NETWORK;
1114                 }
1115         }
1116         return ret;
1117 }
1118
1119 int sttd_server_start(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential, const char* audio_id)
1120 {
1121         if (NULL == lang || NULL == recognition_type) {
1122                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1123                 return STTD_ERROR_INVALID_PARAMETER;
1124         }
1125
1126         int ret = __sttd_server_check_precondition_to_start(uid, appid);
1127         if (0 != ret) {
1128                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to satisfy preconditions, ret(0x%x)", ret);
1129                 return ret;
1130         }
1131
1132         if (0 != stt_client_set_current_recognition(uid)) {
1133                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1134                 return STTD_ERROR_RECORDER_BUSY;
1135         }
1136
1137         delete_timers_related_to_recording_session();
1138
1139         char* sound = NULL;
1140         ret = sttd_client_get_start_sound(uid, &sound);
1141         if (0 != ret) {
1142                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1143                 return ret;
1144         }
1145
1146         ret = sttd_client_set_audio_id(uid, audio_id);
1147         if (0 != ret) {
1148                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set audio_id(%s)", audio_id);
1149                 if (NULL != sound)      free(sound);
1150                 return ret;
1151         }
1152
1153         /* engine start recognition */
1154         SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%u), lang(%s), recog_type(%s)",
1155                         uid, lang, recognition_type);
1156         if (NULL != sound)
1157                 SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
1158
1159         /* 1. Set audio session */
1160         ret = sttd_recorder_set_audio_session();
1161         if (0 != ret) {
1162                 stt_client_unset_current_recognition();
1163                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
1164                 if (NULL != sound)      free(sound);
1165                 return ret;
1166         }
1167
1168         bool is_sound_done = false;
1169
1170         /* 2. Request wav play */
1171         if (NULL != sound) {
1172                 int id = 0;
1173                 uintptr_t puid = (uintptr_t)uid;
1174                 sound_stream_info_h wav_stream_info_h;
1175                 if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
1176                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
1177                         is_sound_done = true;
1178                 } else {
1179                         ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_start_sound_completed_cb, (void*)puid, &id);
1180                         if (WAV_PLAYER_ERROR_NONE != ret) {
1181                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1182                                 is_sound_done = true;
1183                         }
1184
1185                         if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
1186                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
1187                         }
1188                 }
1189                 free(sound);
1190                 sound = NULL;
1191         } else {
1192                 is_sound_done = true;
1193         }
1194
1195         /* 3. Create recorder & engine initialize */
1196         ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, appid, credential, NULL);
1197         if (0 != ret) {
1198                 stt_client_unset_current_recognition();
1199                 sttd_recorder_unset_audio_session();
1200                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1201                 return ret;
1202         }
1203
1204         if (0 != strcmp(STTE_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
1205                 if (NULL == g_processing_timer) {
1206                         g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
1207                 }
1208         }
1209
1210         /* change uid state */
1211         sttd_client_set_state(uid, APP_STATE_RECORDING);
1212
1213         g_recording_log_count = 0;
1214
1215         app_state_e temp_app_state;
1216
1217         if (true == is_sound_done) {
1218                 SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
1219
1220                 ret = sttd_engine_agent_recognize_start_recorder(uid, appid);
1221                 if (0 != ret) {
1222                         stt_client_unset_current_recognition();
1223                         sttd_recorder_unset_audio_session();
1224
1225                         sttd_engine_agent_recognize_cancel();
1226                         if (NULL != g_recording_timer)  {
1227                                 ecore_timer_del(g_recording_timer);
1228                                 g_recording_timer = NULL;
1229                         }
1230                         sttd_client_set_state(uid, APP_STATE_READY);
1231
1232                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
1233                         return ret;
1234                 }
1235
1236                 if (0 != sttd_client_get_state(uid, &temp_app_state)) {
1237                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid");
1238                         return STTD_ERROR_INVALID_PARAMETER;
1239                 }
1240                 if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
1241                         /* Notify uid state change */
1242                         sttdc_send_set_state(uid, APP_STATE_RECORDING);
1243                 }
1244
1245                 SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Start recognition");
1246         } else {
1247                 SLOG(LOG_INFO, TAG_STTD, "[Server] Wait sound finish");
1248         }
1249
1250         sttd_client_set_streaming(uid, false);
1251         return STTD_ERROR_NONE;
1252 }
1253
1254 static Eina_Bool __time_out_for_processing(void *data)
1255 {
1256         g_processing_timer = NULL;
1257         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter __time_out_for_processing");
1258
1259         /* current uid */
1260         unsigned int uid = stt_client_get_current_recognition();
1261         if (STT_INVALID_UID == uid)     return EINA_FALSE;
1262
1263         SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by timeout for processing");
1264
1265         /* Cancel engine */
1266         int ret = sttd_engine_agent_recognize_cancel();
1267         if (0 != ret) {
1268                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1269         }
1270
1271         if (0 != sttdc_send_result(uid, STTE_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
1272                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
1273
1274                 /* send error msg */
1275                 int reason = (int)STTD_ERROR_TIMED_OUT;
1276                 if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
1277                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
1278                 }
1279         }
1280
1281         /* Change uid state */
1282         sttd_client_set_state(uid, APP_STATE_READY);
1283
1284         stt_client_unset_current_recognition();
1285
1286         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End __time_out_for_processing");
1287
1288         return EINA_FALSE;
1289 }
1290
1291 static void __sttd_server_engine_stop(void* data)
1292 {
1293         uintptr_t puid = (uintptr_t)data;
1294         unsigned int uid = (unsigned int)puid;
1295         /* change uid state */
1296         sttd_client_set_state(uid, APP_STATE_PROCESSING);
1297
1298         /* Notify uid state change */
1299         sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1300
1301         /* Unset audio session */
1302         int ret = sttd_recorder_unset_audio_session();
1303         if (0 != ret) {
1304                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1305                 return;
1306         }
1307
1308         /* Stop engine */
1309         ret = sttd_engine_agent_recognize_stop_engine();
1310         if (0 != ret) {
1311                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1312                 return;
1313         }
1314
1315         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1316 }
1317
1318 static void __sttd_stop_sound_completed_cb(int id, void *user_data)
1319 {
1320         SLOG(LOG_INFO, TAG_STTD, "===== Stop sound completed");
1321
1322         /* After wav play callback, engine stop */
1323         ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
1324
1325         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1326         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1327         return;
1328 }
1329
1330 int sttd_server_stop(unsigned int uid)
1331 {
1332         /* check if uid is valid */
1333         app_state_e state;
1334         if (0 != sttd_client_get_state(uid, &state)) {
1335                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1336                 return STTD_ERROR_INVALID_PARAMETER;
1337         }
1338
1339         /* check uid state */
1340         if (APP_STATE_PROCESSING == state) {
1341                 SLOG(LOG_INFO, TAG_STTD, "[Server] State is already processing. Skip stop behavior");
1342                 return STTD_ERROR_NONE;
1343         }
1344
1345         if (APP_STATE_RECORDING != state) {
1346                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1347                 return STTD_ERROR_INVALID_STATE;
1348         }
1349
1350         if (sttd_client_is_streaming(uid)) {
1351                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current client is not started as default");
1352                 return STTD_ERROR_OPERATION_FAILED;
1353         }
1354
1355         delete_timers_related_to_recording_session();
1356
1357         char* sound = NULL;
1358         if (0 != sttd_client_get_stop_sound(uid, &sound)) {
1359                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1360                 return STTD_ERROR_OPERATION_FAILED;
1361         }
1362
1363         SLOG(LOG_INFO, TAG_STTD, "[Server] stop sound path : %s", sound);
1364
1365         int ret;
1366         /* 1. Stop recorder */
1367         ret = sttd_engine_agent_recognize_stop_recorder();
1368         if (0 != ret) {
1369                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
1370                 if (0 != sttd_engine_agent_recognize_cancel()) {
1371                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
1372                 }
1373                 if (NULL != sound)      free(sound);
1374                 return ret;
1375         }
1376
1377         /* 2. Request wav play */
1378         if (NULL != sound) {
1379                 int id = 0;
1380                 uintptr_t puid = (uintptr_t)uid;
1381                 sound_stream_info_h wav_stream_info_h;
1382                 if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
1383                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
1384                 } else {
1385                         ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_stop_sound_completed_cb, (void*)puid, &id);
1386                         if (WAV_PLAYER_ERROR_NONE != ret) {
1387                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1388                         } else {
1389                                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
1390                         }
1391
1392                         if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
1393                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
1394                         }
1395                 }
1396                 free(sound);
1397         } else {
1398                 SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
1399
1400                 /* Unset audio session */
1401                 ret = sttd_recorder_unset_audio_session();
1402                 if (0 != ret) {
1403                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1404                         return ret;
1405                 }
1406
1407                 /* Stop engine */
1408                 ret = sttd_engine_agent_recognize_stop_engine();
1409                 if (0 != ret) {
1410                         stt_client_unset_current_recognition();
1411                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1412                         return ret;
1413                 }
1414
1415                 /* change uid state */
1416                 sttd_client_set_state(uid, APP_STATE_PROCESSING);
1417
1418                 /* Notify uid state change */
1419                 sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1420
1421                 SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Stop recognition");
1422         }
1423
1424         SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
1425         if (NULL == g_processing_timer) {
1426                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1427         }
1428
1429         return STTD_ERROR_NONE;
1430 }
1431
1432 static bool play_sound(const char *path, wav_player_playback_completed_cb callback, void *user_data)
1433 {
1434         sound_stream_info_h wav_stream_info_h = NULL;
1435         if (SOUND_MANAGER_ERROR_NONE != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
1436                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
1437                 return false;
1438         }
1439
1440         int ret = wav_player_start_new(path, wav_stream_info_h, callback, user_data, NULL);
1441         if (SOUND_MANAGER_ERROR_NONE != sound_manager_destroy_stream_information(wav_stream_info_h)) {
1442                 SLOG(LOG_WARN, TAG_STTD, "[Server WARN] Fail to destroy stream info for playing wav");
1443         }
1444
1445         if (WAV_PLAYER_ERROR_NONE != ret) {
1446                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1447                 return false;
1448         }
1449
1450         return true;
1451 }
1452
1453 static bool play_start_sound_for_uid(unsigned int uid)
1454 {
1455         char* sound = NULL;
1456         if (STTD_ERROR_NONE != sttd_client_get_start_sound(uid, &sound)) {
1457                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start sound");
1458                 return false;
1459         }
1460
1461         if (NULL == sound) {
1462                 SLOG(LOG_INFO, TAG_STTD, "[Server] There is no start sound");
1463                 return false;
1464         }
1465
1466         SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
1467         bool ret = play_sound(sound, NULL, NULL);
1468         free(sound);
1469
1470         return ret;
1471 }
1472
1473 int sttd_server_start_audio_streaming(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential, const char* audio_id)
1474 {
1475         if (NULL == lang || NULL == recognition_type) {
1476                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1477                 return STTD_ERROR_INVALID_PARAMETER;
1478         }
1479
1480         int ret = __sttd_server_check_precondition_to_start(uid, appid);
1481         if (STTD_ERROR_NONE != ret) {
1482                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to satisfy preconditions, ret(0x%x)", ret);
1483                 return ret;
1484         }
1485
1486         if (STTD_ERROR_NONE != stt_client_set_current_recognition(uid)) {
1487                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1488                 return STTD_ERROR_RECORDER_BUSY;
1489         }
1490
1491         delete_timers_related_to_recording_session();
1492
1493         ret = sttd_client_set_audio_id(uid, audio_id);
1494         if (STTD_ERROR_NONE != ret) {
1495                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set audio_id(%s)", audio_id);
1496                 return ret;
1497         }
1498
1499         /* engine start recognition */
1500         SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%u), lang(%s), recog_type(%s)", uid, lang, recognition_type);
1501
1502         play_start_sound_for_uid(uid);
1503
1504         /* 3. Create recorder & engine initialize */
1505         ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, appid, credential, NULL);
1506         if (STTD_ERROR_NONE != ret) {
1507                 stt_client_unset_current_recognition();
1508                 sttd_recorder_unset_audio_session();
1509                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d/%s)", ret, get_error_message(ret));
1510                 return ret;
1511         }
1512
1513         if (STTD_ERROR_NONE != strcmp(STTE_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
1514                 if (NULL == g_processing_timer) {
1515                         g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
1516                 }
1517         }
1518
1519         /* change uid state */
1520         sttd_client_set_state(uid, APP_STATE_RECORDING);
1521
1522         g_recording_log_count = 0;
1523
1524         app_state_e temp_app_state = APP_STATE_CREATED;
1525         if (0 != sttd_client_get_state(uid, &temp_app_state)) {
1526                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid");
1527                 return STTD_ERROR_INVALID_PARAMETER;
1528         }
1529
1530         if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
1531                 /* Notify uid state change */
1532                 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1533         }
1534
1535         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Start recognition");
1536
1537         sttd_client_set_streaming(uid, true);
1538         return STTD_ERROR_NONE;
1539 }
1540
1541 int sttd_server_send_audio_streaming(unsigned int uid, const char *data, size_t data_size)
1542 {
1543         app_state_e state = APP_STATE_CREATED;
1544         if (0 != sttd_client_get_state(uid, &state)) {
1545                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1546                 return STTD_ERROR_INVALID_PARAMETER;
1547         }
1548
1549         /* check uid state */
1550         if (APP_STATE_PROCESSING == state) {
1551                 SLOG(LOG_INFO, TAG_STTD, "[Server] State is already processing. Skip stop behavior");
1552                 return STTD_ERROR_NONE;
1553         }
1554
1555         if (APP_STATE_RECORDING != state) {
1556                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1557                 return STTD_ERROR_INVALID_STATE;
1558         }
1559
1560         if (false == sttd_client_is_streaming(uid)) {
1561                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current client is not started as audio streaming");
1562                 return STTD_ERROR_OPERATION_FAILED;
1563         }
1564
1565         int ret = __server_audio_recorder_callback(data, data_size);
1566         if (0 != ret) {
1567                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send audio data");
1568                 return STTD_ERROR_OPERATION_FAILED;
1569         }
1570
1571         return STTD_ERROR_NONE;
1572 }
1573
1574 static bool play_stop_sound_for_uid(unsigned int uid)
1575 {
1576         char* sound = NULL;
1577         if (STTD_ERROR_NONE != sttd_client_get_stop_sound(uid, &sound)) {
1578                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start sound");
1579                 return false;
1580         }
1581
1582         if (NULL == sound) {
1583                 SLOG(LOG_INFO, TAG_STTD, "[Server] There is no start sound");
1584                 return false;
1585         }
1586
1587         SLOG(LOG_INFO, TAG_STTD, "[Server] stop sound : %s", sound);
1588         bool ret = play_sound(sound, NULL, NULL);
1589         free(sound);
1590
1591         return ret;
1592 }
1593
1594 int sttd_server_stop_audio_streaming(unsigned int uid)
1595 {
1596         /* check if uid is valid */
1597         app_state_e state = APP_STATE_CREATED;
1598         if (0 != sttd_client_get_state(uid, &state)) {
1599                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1600                 return STTD_ERROR_INVALID_PARAMETER;
1601         }
1602
1603         /* check uid state */
1604         if (APP_STATE_PROCESSING == state) {
1605                 SLOG(LOG_INFO, TAG_STTD, "[Server] State is already processing. Skip stop behavior");
1606                 return STTD_ERROR_NONE;
1607         }
1608
1609         if (APP_STATE_RECORDING != state) {
1610                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1611                 return STTD_ERROR_INVALID_STATE;
1612         }
1613
1614         if (false == sttd_client_is_streaming(uid)) {
1615                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current client is not started as audio streaming");
1616                 return STTD_ERROR_OPERATION_FAILED;
1617         }
1618
1619         delete_timers_related_to_recording_session();
1620
1621         /* 2. Request wav play */
1622         play_stop_sound_for_uid(uid);
1623
1624         /* Stop engine */
1625         int ret = sttd_engine_agent_recognize_stop_engine();
1626         if (0 != ret) {
1627                 stt_client_unset_current_recognition();
1628                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1629                 return ret;
1630         }
1631
1632         /* change uid state */
1633         sttd_client_set_state(uid, APP_STATE_PROCESSING);
1634
1635         /* Notify uid state change */
1636         sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1637
1638         SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Stop recognition");
1639
1640         SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
1641         if (NULL == g_processing_timer) {
1642                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1643         }
1644
1645         sttd_client_set_streaming(uid, false);
1646         return STTD_ERROR_NONE;
1647 }
1648
1649 static int __sttd_server_cancel(unsigned int uid)
1650 {
1651         /* check if uid is valid */
1652         app_state_e state;
1653         if (0 != sttd_client_get_state(uid, &state)) {
1654                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1655                 return STTD_ERROR_INVALID_PARAMETER;
1656         }
1657
1658         /* check uid state */
1659         if (APP_STATE_READY == state) {
1660                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
1661                 return STTD_ERROR_NONE;
1662         }
1663
1664         stt_client_unset_current_recognition();
1665
1666         delete_timers_related_to_recording_session();
1667
1668         if (APP_STATE_RECORDING == state) {
1669                 /* Unset audio session */
1670                 int ret = sttd_recorder_unset_audio_session();
1671                 if (0 != ret) {
1672                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1673                         return ret;
1674                 }
1675         }
1676
1677         /* change uid state */
1678         sttd_client_set_state(uid, APP_STATE_READY);
1679
1680         SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by app's request");
1681
1682         /* cancel engine recognition */
1683         int ret = sttd_engine_agent_recognize_cancel();
1684         if (0 != ret) {
1685                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1686                 return ret;
1687         }
1688
1689         /* Notify uid state change */
1690         sttdc_send_set_state(uid, APP_STATE_READY);
1691
1692         return ret;
1693 }
1694
1695 int sttd_server_cancel(unsigned int uid)
1696 {
1697         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter sttd_server_cancel");
1698
1699         int ret = __sttd_server_cancel(uid);
1700         if (0 != ret) {
1701                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(0x%x)", ret);
1702         }
1703
1704         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End sttd_server_cancel");
1705         return ret;
1706 }
1707
1708 int sttd_server_start_file(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential, const char* filepath)
1709 {
1710         if (NULL == lang || NULL == recognition_type || NULL == filepath) {
1711                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1712                 return STTD_ERROR_INVALID_PARAMETER;
1713         }
1714
1715         int ret = __sttd_server_check_precondition_to_start(uid, appid);
1716         if (0 != ret) {
1717                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to satisfy preconditions, ret(0x%x)", ret);
1718                 return ret;
1719         }
1720
1721         if (0 != stt_client_set_current_recognition(uid)) {
1722                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1723                 return STTD_ERROR_RECORDER_BUSY;
1724         }
1725
1726         /* engine start recognition */
1727         SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%u), lang(%s), recog_type(%s), appid(%s), file(%s)", uid, lang, recognition_type, appid, filepath);
1728
1729         /* 1. Set audio session */
1730         ret = sttd_recorder_set_audio_session();
1731         if (0 != ret) {
1732                 stt_client_unset_current_recognition();
1733                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
1734                 return ret;
1735         }
1736
1737         /* 2. Start engine to recognize */
1738         ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, appid, credential, NULL);
1739         if (0 != ret) {
1740                 stt_client_unset_current_recognition();
1741                 sttd_recorder_unset_audio_session();
1742                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start engine : result(%d)", ret);
1743                 return ret;
1744         }
1745
1746         sttd_client_set_state(uid, APP_STATE_RECORDING);
1747         sttdc_send_set_state(uid, APP_STATE_RECORDING);
1748
1749         /* 3. Start to send pcm from file to engine */
1750         ret = sttd_engine_agent_recognize_start_file(uid, filepath);
1751         if (0 != ret) {
1752                 stt_client_unset_current_recognition();
1753                 sttd_recorder_unset_audio_session();
1754                 sttd_engine_agent_recognize_cancel();
1755                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start file : result(%d)", ret);
1756                 return ret;
1757         }
1758
1759         /* 4. Stop to send pcm from file  */
1760         ret = sttd_engine_agent_recognize_stop_file();
1761         if (0 != ret) {
1762                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
1763                 stt_client_unset_current_recognition();
1764                 sttd_recorder_unset_audio_session();
1765                 sttd_engine_agent_recognize_cancel();
1766                 return ret;
1767         }
1768
1769         /* 5. change & notify uid state */
1770         sttd_client_set_state(uid, APP_STATE_PROCESSING);
1771         sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1772
1773         /* 6. Unset audio session */
1774         ret = sttd_recorder_unset_audio_session();
1775         if (0 != ret) {
1776                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1777                 stt_client_unset_current_recognition();
1778                 return ret;
1779         }
1780
1781         /* 7. Stop engine */
1782         ret = sttd_engine_agent_recognize_stop_engine();
1783         if (0 != ret) {
1784                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1785                 stt_client_unset_current_recognition();
1786                 return ret;
1787         }
1788
1789         return STTD_ERROR_NONE;
1790 }
1791
1792 int sttd_server_cancel_file(unsigned int uid)
1793 {
1794         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter sttd_server_cancel_file");
1795
1796         int ret = __sttd_server_cancel(uid);
1797         if (0 != ret) {
1798                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel file : result(0x%x)", ret);
1799         }
1800
1801         SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End sttd_server_cancel_file");
1802         return ret;
1803 }