server/sttd_server.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 <pthread.h>
  15 #include <sound_manager.h>
  16 #include <wav_player.h>
  17
  18 #include "stt_network.h"
  19 #include "sttd_client_data.h"
  20 #include "sttd_config.h"
  21 #include "sttd_dbus.h"
  22 #include "sttd_engine_agent.h"
  23 #include "sttd_main.h"
  24 #include "sttd_recorder.h"
  25 #include "sttd_server.h"
  26
  27 static pthread_mutex_t sttpe_result_mutex = PTHREAD_MUTEX_INITIALIZER;
  28 static pthread_mutex_t sttpe_result_time_mutex = PTHREAD_MUTEX_INITIALIZER;
  29
  30
  31 /*
  32 * STT Server static variable
  33 */
  34 static double g_processing_timeout = 30;
  35
  36 static double g_recording_timeout = 60;
  37
  38 Ecore_Timer*    g_recording_timer = NULL;
  39 Ecore_Timer*    g_processing_timer = NULL;
  40
  41 static int g_recording_log_count = 0;
  42
  43 static GList *g_proc_list = NULL;
  44
  45 /*
  46 * STT Server Callback Functions
  47 */
  48 void __stop_by_silence(void *data)
  49 {
  50         SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by silence detection");
  51
  52         int uid = 0;
  53
  54         uid = stt_client_get_current_recognition();
  55
  56         int ret;
  57         if (0 != uid) {
  58                 ret = sttd_server_stop(uid);
  59                 if (0 > ret) {
  60                         return;
  61                 }
  62
  63                 if (STTD_RESULT_STATE_DONE == ret) {
  64                         ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
  65                         if (0 != ret) {
  66                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send state : result(%d)", ret);
  67
  68                                 /* Remove client */
  69                                 sttd_server_finalize(uid);
  70                                 stt_client_unset_current_recognition();
  71                         }
  72                 }
  73         } else {
  74                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
  75         }
  76
  77         SLOG(LOG_DEBUG, TAG_STTD, "=====");
  78         SLOG(LOG_DEBUG, TAG_STTD, "  ");
  79
  80         return;
  81 }
  82
  83 static void __cancel_recognition_internal()
  84 {
  85         if (NULL != g_recording_timer)  {
  86                 ecore_timer_del(g_recording_timer);
  87                 g_recording_timer = NULL;
  88         }
  89
  90         int uid = 0;
  91         uid = stt_client_get_current_recognition();
  92
  93         if (0 != uid) {
  94                 /* cancel engine recognition */
  95                 int ret = sttd_engine_agent_recognize_cancel(uid);
  96                 if (0 != ret) {
  97                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
  98                 }
  99
 100                 /* change uid state */
 101                 sttd_client_set_state(uid, APP_STATE_READY);
 102                 stt_client_unset_current_recognition();
 103
 104                 ret = sttdc_send_set_state(uid, (int)APP_STATE_READY);
 105                 if (0 != ret) {
 106                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send state change : result(%d)", ret);
 107                 }
 108         } else {
 109                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
 110         }
 111 }
 112
 113 static void __cancel_by_error(void *data)
 114 {
 115         SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by error");
 116
 117         __cancel_recognition_internal();
 118
 119         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 120         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 121
 122         return;
 123 }
 124
 125 int __server_audio_recorder_callback(const void* data, const unsigned int length)
 126 {
 127         int uid = -1;
 128         int ret;
 129
 130         if (NULL == data || 0 == length) {
 131                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Recording data is not valid");
 132                 ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 133                 return -1;
 134         }
 135
 136         uid = stt_client_get_current_recognition();
 137         if (0 != uid) {
 138                 ret = sttd_engine_agent_set_recording_data(uid, data, length);
 139                 if (ret < 0) {
 140                         ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 141                         return -1;
 142                 }
 143                 g_recording_log_count++;
 144                 if (200 <= g_recording_log_count) {
 145                         SLOG(LOG_DEBUG, TAG_STTD, "=== Set recording data ===");
 146                         g_recording_log_count = 0;
 147                 }
 148         } else {
 149                 if (NULL != g_recording_timer)  {
 150                         ecore_timer_del(g_recording_timer);
 151                         g_recording_timer = NULL;
 152                 }
 153                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current uid in recording is is not valid");
 154                 return -1;
 155         }
 156
 157         return 0;
 158 }
 159
 160 void __server_audio_interrupt_callback()
 161 {
 162         SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by sound interrupt");
 163
 164         __cancel_recognition_internal();
 165
 166         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 167         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 168 }
 169
 170 void __cancel_by_no_record(void *data)
 171 {
 172         SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by no record");
 173
 174         __cancel_recognition_internal();
 175
 176         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 177         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 178
 179         return;
 180 }
 181
 182 void __server_recognition_result_callback(sttp_result_event_e event, const char* type,
 183                                         const char** data, int data_count, const char* msg, void *user_data)
 184 {
 185         // critical section
 186         pthread_mutex_lock(&sttpe_result_mutex);
 187
 188         SLOG(LOG_DEBUG, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
 189
 190         /* check uid */
 191         int uid = stt_client_get_current_recognition();
 192
 193         app_state_e state;
 194         if (0 == uid || 0 != sttd_client_get_state(uid, &state)) {
 195                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 196                 SLOG(LOG_DEBUG, TAG_STTD, "=====");
 197                 SLOG(LOG_DEBUG, TAG_STTD, "  ");
 198                 pthread_mutex_unlock(&sttpe_result_mutex);
 199                 return;
 200         }
 201
 202         SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
 203
 204         /* send result to client */
 205         if (STTP_RESULT_EVENT_FINAL_RESULT == event) {
 206                 if (APP_STATE_PROCESSING != state) {
 207                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
 208                 }
 209                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
 210
 211                 /* Delete timer for processing time out */
 212                 if (NULL != g_processing_timer) {
 213                         ecore_timer_del(g_processing_timer);
 214                         g_processing_timer = NULL;
 215                 }
 216
 217                 sttd_config_time_save();
 218                 sttd_config_time_reset();
 219
 220                 if (NULL == data || 0 == data_count) {
 221                         if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
 222                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 223                                 int reason = (int)STTD_ERROR_OPERATION_FAILED;
 224
 225                                 if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 226                                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 227                                 }
 228                         }
 229                 } else {
 230                         if (0 != sttdc_send_result(uid, event, data, data_count, msg)) {
 231                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 232                                 int reason = (int)STTD_ERROR_OPERATION_FAILED;
 233
 234                                 if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 235                                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 236                                 }
 237                         }
 238                 }
 239
 240                 /* change state of uid */
 241                 sttd_client_set_state(uid, APP_STATE_READY);
 242                 stt_client_unset_current_recognition();
 243
 244         } else if (STTP_RESULT_EVENT_PARTIAL_RESULT == event) {
 245                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
 246
 247                 sttd_config_time_save();
 248                 sttd_config_time_reset();
 249
 250                 if (0 != sttdc_send_result(uid, event, data, data_count, msg)) {
 251                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
 252                         int reason = (int)STTD_ERROR_OPERATION_FAILED;
 253
 254                         if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
 255                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info . Remove client data");
 256                         }
 257                 }
 258
 259         } else if (STTP_RESULT_EVENT_ERROR == event) {
 260                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The event of recognition result is ERROR");
 261
 262                 /* Delete timer for processing time out */
 263                 if (NULL != g_processing_timer) {
 264                         ecore_timer_del(g_processing_timer);
 265                         g_processing_timer = NULL;
 266                 }
 267                 sttd_config_time_reset();
 268
 269                 if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
 270                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
 271
 272                         /* send error msg */
 273                         int reason = (int)STTD_ERROR_INVALID_STATE;
 274                         if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
 275                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
 276                         }
 277                 }
 278
 279                 /* change state of uid */
 280                 sttd_client_set_state(uid, APP_STATE_READY);
 281                 stt_client_unset_current_recognition();
 282         } else {
 283                 /* nothing */
 284         }
 285
 286         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 287         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 288         pthread_mutex_unlock(&sttpe_result_mutex);
 289
 290         return;
 291 }
 292
 293 bool __server_result_time_callback(int index, sttp_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
 294 {
 295         pthread_mutex_lock(&sttpe_result_time_mutex);
 296
 297         SLOG(LOG_DEBUG, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
 298                 index, event, text, start_time, end_time);
 299
 300         if (0 == index) {
 301                 int ret;
 302                 ret = sttd_config_time_add(index, (int)event, text, start_time, end_time);
 303                 if (0 != ret) {
 304                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add time info");
 305                         pthread_mutex_unlock(&sttpe_result_time_mutex);
 306                         return false;
 307                 }
 308         } else {
 309                 pthread_mutex_unlock(&sttpe_result_time_mutex);
 310                 return false;
 311         }
 312
 313         pthread_mutex_unlock(&sttpe_result_time_mutex);
 314
 315         return true;
 316 }
 317
 318 void __server_silence_dectection_callback(sttp_silence_type_e type, void *user_param)
 319 {
 320         SLOG(LOG_DEBUG, TAG_STTD, "===== Silence Detection Callback");
 321
 322         int uid = stt_client_get_current_recognition();
 323         if (0 != uid) {
 324                 app_state_e state;
 325                 if (0 != sttd_client_get_state(uid, &state)) {
 326                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is not valid ");
 327                         return;
 328                 }
 329
 330                 if (APP_STATE_RECORDING != state) {
 331                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
 332                         return;
 333                 }
 334
 335                 if (STTP_SILENCE_TYPE_NO_RECORD_TIMEOUT == type) {
 336                         SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - No Record");
 337                         ecore_main_loop_thread_safe_call_async(__cancel_by_no_record, NULL);
 338                 } else if (STTP_SILENCE_TYPE_END_OF_SPEECH_DETECTED == type) {
 339                         SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - End of Speech");
 340                         ecore_main_loop_thread_safe_call_async(__stop_by_silence, NULL);
 341                 }
 342         } else {
 343                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recogntion uid is not valid ");
 344         }
 345
 346         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 347         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 348
 349         return;
 350 }
 351
 352 void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, void* user_data)
 353 {
 354         if (NULL == engine_id) {
 355                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
 356                 return;
 357         } else {
 358                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
 359         }
 360
 361         /* need to change state of app to ready */
 362         int uid;
 363         uid = stt_client_get_current_recognition();
 364
 365         if (0 != uid) {
 366                 SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
 367
 368                 sttd_server_cancel(uid);
 369                 sttdc_send_set_state(uid, (int)APP_STATE_READY);
 370
 371                 stt_client_unset_current_recognition();
 372         }
 373
 374         /* set engine */
 375         int ret = sttd_engine_agent_set_default_engine(engine_id);
 376         if (0 != ret)
 377                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : result(%d)", ret);
 378
 379         if (NULL != language) {
 380                 ret = sttd_engine_agent_set_default_language(language);
 381                 if (0 != ret)
 382                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
 383         }
 384
 385         ret = sttd_engine_agent_set_silence_detection(support_silence);
 386         if (0 != ret)
 387                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
 388
 389         return;
 390 }
 391
 392 void __sttd_server_language_changed_cb(const char* language, void* user_data)
 393 {
 394         if (NULL == language) {
 395                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
 396                 return;
 397         } else {
 398                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
 399         }
 400
 401         int ret = sttd_engine_agent_set_default_language(language);
 402         if (0 != ret)
 403                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
 404
 405         return;
 406 }
 407
 408 void __sttd_server_silence_changed_cb(bool value, void* user_data)
 409 {
 410         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
 411
 412         int ret = 0;
 413         ret = sttd_engine_agent_set_silence_detection(value);
 414         if (0 != ret)
 415                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
 416
 417         return;
 418 }
 419
 420 /*
 421 * Daemon function
 422 */
 423
 424 int sttd_initialize()
 425 {
 426         int ret = 0;
 427
 428         if (0 != pthread_mutex_init(&sttpe_result_mutex, NULL)) {
 429                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe result mutex.");
 430         }
 431
 432         if (0 != pthread_mutex_init(&sttpe_result_time_mutex, NULL)) {
 433                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe sttpe_result_time_mutex.");
 434         }
 435
 436         if (sttd_config_initialize(__sttd_server_engine_changed_cb, __sttd_server_language_changed_cb,
 437                 __sttd_server_silence_changed_cb, NULL)) {
 438                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize config.");
 439         }
 440
 441         ret = sttd_recorder_initialize(__server_audio_recorder_callback, __server_audio_interrupt_callback);
 442         if (0 != ret) {
 443                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize recorder : result(%d)", ret);
 444         }
 445
 446         /* Engine Agent initialize */
 447         ret = sttd_engine_agent_init(__server_recognition_result_callback, __server_result_time_callback,
 448                 __server_silence_dectection_callback);
 449         if (0 != ret) {
 450                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
 451                 return ret;
 452         }
 453
 454         /* Update engine list */
 455         ret = sttd_engine_agent_initialize_engine_list();
 456         if (0 != ret) {
 457                 if (STTD_ERROR_ENGINE_NOT_FOUND == ret) {
 458                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no stt engine");
 459                 } else {
 460                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to update engine list : %d", ret);
 461                         return ret;
 462                 }
 463         }
 464
 465         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
 466
 467         return 0;
 468 }
 469
 470 int sttd_finalize()
 471 {
 472         if (0 != pthread_mutex_destroy(&sttpe_result_mutex)) {
 473                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy sttpe result mutex.");
 474         }
 475
 476         if (0 != pthread_mutex_destroy(&sttpe_result_time_mutex)) {
 477                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy sttpe_result_time_mutex.");
 478         }
 479
 480         GList *iter = NULL;
 481         if (0 < g_list_length(g_proc_list)) {
 482                 iter = g_list_first(g_proc_list);
 483                 while (NULL != iter) {
 484                         g_proc_list = g_list_remove_link(g_proc_list, iter);
 485                         iter = g_list_first(g_proc_list);
 486                 }
 487         }
 488
 489         sttd_recorder_deinitialize();
 490
 491         sttd_config_finalize();
 492
 493         sttd_engine_agent_release();
 494
 495         return STTD_ERROR_NONE;
 496 }
 497
 498 static void __read_proc()
 499 {
 500         DIR *dp = NULL;
 501         struct dirent entry;
 502         struct dirent *dirp = NULL;
 503         int ret = -1;
 504         int tmp;
 505
 506         GList *iter = NULL;
 507         if (0 < g_list_length(g_proc_list)) {
 508                 iter = g_list_first(g_proc_list);
 509                 while (NULL != iter) {
 510                         g_proc_list = g_list_remove_link(g_proc_list, iter);
 511                         iter = g_list_first(g_proc_list);
 512                 }
 513         }
 514
 515         dp = opendir("/proc");
 516         if (NULL == dp) {
 517                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to open proc");
 518         } else {
 519                 do {
 520                         ret = readdir_r(dp, &entry, &dirp);
 521                         if (0 != ret) {
 522                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to readdir");
 523                                 break;
 524                         }
 525
 526                         if (NULL != dirp) {
 527                                 tmp = atoi(dirp->d_name);
 528                                 if (0 >= tmp)   continue;
 529                                 g_proc_list = g_list_append(g_proc_list, GINT_TO_POINTER(tmp));
 530                         }
 531                 } while (NULL != dirp);
 532                 closedir(dp);
 533         }
 534         return;
 535 }
 536
 537 Eina_Bool sttd_cleanup_client(void *data)
 538 {
 539         int* client_list = NULL;
 540         int client_count = 0;
 541         int i = 0;
 542         int j = 0;
 543         bool exist = false;
 544
 545         if (0 != sttd_client_get_list(&client_list, &client_count)) {
 546                 if (NULL != client_list)
 547                         free(client_list);
 548
 549                 return EINA_TRUE;
 550         }
 551
 552         if (NULL != client_list) {
 553                 SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
 554
 555                 __read_proc();
 556
 557                 for (i = 0; i < client_count; i++) {
 558                         int pid = sttd_client_get_pid(client_list[i]);
 559                         if (0 > pid) {
 560                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Invalid pid");
 561                                 continue;
 562                         }
 563
 564                         exist = false;
 565                         GList *iter = NULL;
 566                         for (j = 0; j < g_list_length(g_proc_list); j++) {
 567                                 iter = g_list_nth(g_proc_list, j);
 568                                 if (NULL != iter) {
 569                                         if (pid == GPOINTER_TO_INT(iter->data)) {
 570                                                 SLOG(LOG_DEBUG, TAG_STTD, "uid (%d) is running", client_list[i]);
 571                                                 exist = true;
 572                                                 break;
 573                                         }
 574                                 }
 575                         }
 576
 577                         if (false == exist) {
 578                                 SLOG(LOG_ERROR, TAG_STTD, "uid (%d) should be removed", client_list[i]);
 579                                 sttd_server_finalize(client_list[i]);
 580                         }
 581 #if 0
 582                         result = sttdc_send_hello(client_list[i]);
 583
 584                         if (0 == result) {
 585                                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", client_list[i]);
 586                                 sttd_server_finalize(client_list[i]);
 587                         } else if (-1 == result) {
 588                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Hello result has error");
 589                         }
 590 #endif
 591                 }
 592
 593                 SLOG(LOG_DEBUG, TAG_STTD, "=====");
 594                 SLOG(LOG_DEBUG, TAG_STTD, "  ");
 595
 596                 free(client_list);
 597         }
 598
 599         return EINA_TRUE;
 600 }
 601
 602 /*
 603 * STT Server Functions for Client
 604 */
 605
 606 int sttd_server_initialize(int pid, int uid, bool* silence)
 607 {
 608         if (false == sttd_engine_agent_is_default_engine()) {
 609                 /* Update installed engine */
 610                 sttd_engine_agent_initialize_engine_list();
 611
 612                 if (false == sttd_engine_agent_is_default_engine()) {
 613                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] No stt-engine");
 614                         return STTD_ERROR_ENGINE_NOT_FOUND;
 615                 }
 616         }
 617
 618         /* check if uid is valid */
 619         app_state_e state;
 620         if (0 == sttd_client_get_state(uid, &state)) {
 621                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid has already been registered");
 622                 return STTD_ERROR_NONE;
 623         }
 624
 625         /* load engine */
 626         if (0 != sttd_engine_agent_load_current_engine(uid, NULL)) {
 627                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
 628                 return STTD_ERROR_OPERATION_FAILED;
 629         }
 630
 631         if (0 != sttd_engine_agent_get_option_supported(uid, silence)) {
 632                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
 633                 return STTD_ERROR_OPERATION_FAILED;
 634         }
 635
 636         /* Add client information to client manager */
 637         if (0 != sttd_client_add(pid, uid)) {
 638                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add client info");
 639                 return STTD_ERROR_OPERATION_FAILED;
 640         }
 641
 642         return STTD_ERROR_NONE;
 643 }
 644
 645 static Eina_Bool __quit_ecore_loop(void *data)
 646 {
 647         ecore_main_loop_quit();
 648         return EINA_FALSE;
 649 }
 650
 651 int sttd_server_finalize(int uid)
 652 {
 653         /* check if uid is valid */
 654         app_state_e state;
 655         if (0 != sttd_client_get_state(uid, &state)) {
 656                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 657                 return STTD_ERROR_INVALID_PARAMETER;
 658         }
 659
 660         /* release recorder */
 661         if (APP_STATE_RECORDING == state || APP_STATE_PROCESSING == state) {
 662                 if (APP_STATE_RECORDING == state) {
 663                         if (NULL != g_recording_timer)  {
 664                                 ecore_timer_del(g_recording_timer);
 665                                 g_recording_timer = NULL;
 666                         }
 667                 }
 668
 669                 if (APP_STATE_PROCESSING == state) {
 670                         if (NULL != g_processing_timer) {
 671                                 ecore_timer_del(g_processing_timer);
 672                                 g_processing_timer = NULL;
 673                         }
 674                 }
 675
 676                 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
 677                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
 678                 }
 679
 680                 stt_client_unset_current_recognition();
 681         }
 682
 683         if (0 != sttd_engine_agent_unload_current_engine(uid)) {
 684                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unload engine");
 685         }
 686
 687         /* Remove client information */
 688         if (0 != sttd_client_delete(uid)) {
 689                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to delete client");
 690         }
 691
 692         /* unload engine, if ref count of client is 0 */
 693         if (0 == sttd_client_get_ref_count()) {
 694                 sttd_dbus_close_connection();
 695                 ecore_timer_add(0, __quit_ecore_loop, NULL);
 696         }
 697
 698         return STTD_ERROR_NONE;
 699 }
 700
 701 int sttd_server_get_supported_engines(int uid, GSList** engine_list)
 702 {
 703         /* Check if uid is valid */
 704         app_state_e state;
 705         if (0 != sttd_client_get_state(uid, &state)) {
 706                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 707                 return STTD_ERROR_INVALID_PARAMETER;
 708         }
 709
 710         /* Check state of uid */
 711         if (APP_STATE_READY != state) {
 712                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 713                 return STTD_ERROR_INVALID_STATE;
 714         }
 715
 716         int ret;
 717         ret = sttd_engine_agent_get_engine_list(engine_list);
 718         if (0 != ret) {
 719                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine list");
 720                 return STTD_ERROR_OPERATION_FAILED;
 721         }
 722
 723         return STTD_ERROR_NONE;
 724 }
 725
 726 int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence)
 727 {
 728         /* Check if uid is valid */
 729         app_state_e state;
 730         if (0 != sttd_client_get_state(uid, &state)) {
 731                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 732                 return STTD_ERROR_INVALID_PARAMETER;
 733         }
 734
 735         /* Check state of uid */
 736         if (APP_STATE_READY != state) {
 737                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 738                 return STTD_ERROR_INVALID_STATE;
 739         }
 740
 741         int ret;
 742         ret = sttd_engine_agent_load_current_engine(uid, engine_id);
 743         if (0 != ret) {
 744                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : %d", ret);
 745                 return STTD_ERROR_OPERATION_FAILED;
 746         }
 747
 748         ret = sttd_engine_agent_get_option_supported(uid, silence);
 749         if (0 != ret) {
 750                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine options : %d", ret);
 751                 return STTD_ERROR_OPERATION_FAILED;
 752         }
 753
 754         return STTD_ERROR_NONE;
 755 }
 756
 757 int sttd_server_get_current_engine(int uid, char** engine_id)
 758 {
 759         /* Check if uid is valid */
 760         app_state_e state;
 761         if (0 != sttd_client_get_state(uid, &state)) {
 762                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 763                 return STTD_ERROR_INVALID_PARAMETER;
 764         }
 765
 766         /* Check state of uid */
 767         if (APP_STATE_READY != state) {
 768                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 769                 return STTD_ERROR_INVALID_STATE;
 770         }
 771
 772         int ret;
 773         ret = sttd_engine_agent_get_current_engine(uid, engine_id);
 774         if (0 != ret) {
 775                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine : %d", ret);
 776                 return STTD_ERROR_OPERATION_FAILED;
 777         }
 778
 779         return STTD_ERROR_NONE;
 780 }
 781
 782 int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
 783 {
 784         /* Check if uid is valid */
 785         app_state_e state;
 786         if (0 != sttd_client_get_state(uid, &state)) {
 787                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 788                 return STTD_ERROR_INVALID_PARAMETER;
 789         }
 790
 791         /* Check state of uid */
 792         if (APP_STATE_READY != state) {
 793                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 794                 return STTD_ERROR_INVALID_STATE;
 795         }
 796
 797         /* Ask engine available */
 798         int ret;
 799         bool temp = false;
 800         ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
 801         if (0 != ret) {
 802                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
 803                 return STTD_ERROR_OPERATION_FAILED;
 804         }
 805
 806         if (true == temp) {
 807                 stt_client_set_app_agreed(uid);
 808                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] App(%s) confirmed that engine is available", appid);
 809         }
 810
 811         *available = temp;
 812
 813         return STTD_ERROR_NONE;
 814 }
 815
 816
 817 int sttd_server_get_supported_languages(int uid, GSList** lang_list)
 818 {
 819         /* check if uid is valid */
 820         app_state_e state;
 821         if (0 != sttd_client_get_state(uid, &state)) {
 822                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 823                 return STTD_ERROR_INVALID_PARAMETER;
 824         }
 825
 826         /* get language list from engine */
 827         int ret = sttd_engine_agent_supported_langs(uid, lang_list);
 828         if (0 != ret) {
 829                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get supported languages");
 830                 return STTD_ERROR_OPERATION_FAILED;
 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(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(uid, current_lang);
 854         if (0 != ret) {
 855                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get default language :result(%d)", ret);
 856                 return STTD_ERROR_OPERATION_FAILED;
 857         }
 858
 859         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
 860
 861         return STTD_ERROR_NONE;
 862 }
 863
 864 int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support)
 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 == type || NULL == support) {
 874                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 875                 return STTD_ERROR_INVALID_PARAMETER;
 876         }
 877
 878         bool temp;
 879         int ret = sttd_engine_agent_is_recognition_type_supported(uid, type, &temp);
 880         if (0 != ret) {
 881                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
 882                 return STTD_ERROR_OPERATION_FAILED;
 883         }
 884
 885         *support = (int)temp;
 886
 887         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
 888
 889         return STTD_ERROR_NONE;
 890 }
 891
 892 int sttd_server_set_start_sound(int uid, const char* file)
 893 {
 894         /* check if uid is valid */
 895         app_state_e state;
 896         if (0 != sttd_client_get_state(uid, &state)) {
 897                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 898                 return STTD_ERROR_INVALID_PARAMETER;
 899         }
 900
 901         int ret = sttd_client_set_start_sound(uid, file);
 902         if (0 != ret) {
 903                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
 904                 return STTD_ERROR_OPERATION_FAILED;
 905         }
 906
 907         return 0;
 908 }
 909
 910 int sttd_server_set_stop_sound(int uid, const char* file)
 911 {
 912         /* check if uid is valid */
 913         app_state_e state;
 914         if (0 != sttd_client_get_state(uid, &state)) {
 915                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 916                 return STTD_ERROR_INVALID_PARAMETER;
 917         }
 918
 919         int ret = sttd_client_set_stop_sound(uid, file);
 920         if (0 != ret) {
 921                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
 922                 return STTD_ERROR_OPERATION_FAILED;
 923         }
 924
 925         return 0;
 926 }
 927
 928 #if 0
 929 Eina_Bool __check_recording_state(void *data)
 930 {
 931         /* current uid */
 932         int uid = stt_client_get_current_recognition();
 933         if (0 == uid)
 934                 return EINA_FALSE;
 935
 936         app_state_e state;
 937         if (0 != sttdc_send_get_state(uid, (int*)&state)) {
 938                 /* client is removed */
 939                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
 940                 sttd_server_finalize(uid);
 941                 return EINA_FALSE;
 942         }
 943
 944         if (APP_STATE_READY == state) {
 945                 /* Cancel stt */
 946                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The daemon should cancel recording", uid);
 947                 sttd_server_cancel(uid);
 948         } else if (APP_STATE_PROCESSING == state) {
 949                 /* Cancel stt and send change state */
 950                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The daemon should cancel recording", uid);
 951                 sttd_server_cancel(uid);
 952                 sttdc_send_set_state(uid, (int)APP_STATE_READY);
 953         } else {
 954                 /* Normal state */
 955                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The states of daemon and client are identical");
 956                 return EINA_TRUE;
 957         }
 958
 959         return EINA_FALSE;
 960 }
 961 #endif
 962
 963 Eina_Bool __stop_by_recording_timeout(void *data)
 964 {
 965         SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
 966
 967         g_recording_timer = NULL;
 968
 969         int uid = 0;
 970         uid = stt_client_get_current_recognition();
 971         if (0 != uid) {
 972                 /* cancel engine recognition */
 973                 int ret = sttd_server_stop(uid);
 974                 if (0 != ret) {
 975                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop : result(%d)", ret);
 976                 }
 977         }
 978
 979         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 980         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 981
 982         return EINA_FALSE;
 983 }
 984
 985 void __sttd_server_recorder_start(void* data)
 986 {
 987         int uid = (int)data;
 988         int current_uid = stt_client_get_current_recognition();
 989
 990         if (uid != current_uid) {
 991                 stt_client_unset_current_recognition();
 992                 return;
 993         }
 994
 995         int ret = sttd_engine_agent_recognize_start_recorder(uid);
 996         if (0 != ret) {
 997                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
 998                 return;
 999         }
1000
1001         /* Notify uid state change */
1002         sttdc_send_set_state(uid, APP_STATE_RECORDING);
1003
1004         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1005 }
1006
1007 void __sttd_start_sound_completed_cb(int id, void *user_data)
1008 {
1009         SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
1010
1011         /* After wav play callback, recorder start */
1012         ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
1013
1014         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1015         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1016         return;
1017 }
1018
1019 int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid)
1020 {
1021         if (NULL == lang || NULL == recognition_type) {
1022                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1023                 return STTD_ERROR_INVALID_PARAMETER;
1024         }
1025
1026         /* check if uid is valid */
1027         app_state_e state;
1028         if (0 != sttd_client_get_state(uid, &state)) {
1029                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1030                 return STTD_ERROR_INVALID_PARAMETER;
1031         }
1032
1033         /* check uid state */
1034         if (APP_STATE_READY != state) {
1035                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] sttd_server_start : current state is not ready");
1036                 return STTD_ERROR_INVALID_STATE;
1037         }
1038
1039         int ret = 0;
1040         if (false == stt_client_get_app_agreed(uid)) {
1041                 bool temp = false;
1042                 ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
1043                 if (0 != ret) {
1044                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
1045                         return STTD_ERROR_OPERATION_FAILED;
1046                 }
1047
1048                 if (false == temp) {
1049                         SLOG(LOG_ERROR, TAG_STTD, "[Server] App(%s) NOT confirmed that engine is available", appid);
1050                         return STTD_ERROR_PERMISSION_DENIED;
1051                 }
1052
1053                 stt_client_set_app_agreed(uid);
1054         }
1055
1056         /* check if engine use network */
1057         if (true == sttd_engine_agent_need_network(uid)) {
1058                 if (false == stt_network_is_connected()) {
1059                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
1060                         return STTD_ERROR_OUT_OF_NETWORK;
1061                 }
1062         }
1063
1064         char* sound = NULL;
1065         if (0 != sttd_client_get_start_sound(uid, &sound)) {
1066                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1067                 return STTD_ERROR_OPERATION_FAILED;
1068         }
1069
1070         if (0 != stt_client_set_current_recognition(uid)) {
1071                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1072                 if (NULL != sound)      free(sound);
1073                 return STTD_ERROR_RECORDER_BUSY;
1074         }
1075
1076         /* engine start recognition */
1077         SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
1078                         uid, lang, recognition_type);
1079         if (NULL != sound)
1080                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
1081
1082         /* 1. Set audio session */
1083         ret = sttd_recorder_set_audio_session();
1084         if (0 != ret) {
1085                 stt_client_unset_current_recognition();
1086                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
1087                 if (NULL != sound)      free(sound);
1088                 return ret;
1089         }
1090
1091         bool is_sound_done = false;
1092
1093         /* 2. Request wav play */
1094         if (NULL != sound) {
1095                 int id = 0;
1096                 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_start_sound_completed_cb, (void*)uid, &id);
1097                 if (WAV_PLAYER_ERROR_NONE != ret) {
1098                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1099                         is_sound_done = true;
1100                 }
1101                 free(sound);
1102                 sound = NULL;
1103         } else {
1104                 is_sound_done = true;
1105         }
1106
1107         /* 3. Create recorder & engine initialize */
1108         ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, NULL);
1109         if (0 != ret) {
1110                 stt_client_unset_current_recognition();
1111                 sttd_recorder_unset_audio_session();
1112                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1113                 return ret;
1114         }
1115
1116         if (0 != strcmp(STTP_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
1117                 g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
1118         }
1119
1120         /* change uid state */
1121         sttd_client_set_state(uid, APP_STATE_RECORDING);
1122
1123         g_recording_log_count = 0;
1124
1125         if (true == is_sound_done) {
1126                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1127
1128                 ret = sttd_engine_agent_recognize_start_recorder(uid);
1129                 if (0 != ret) {
1130                         stt_client_unset_current_recognition();
1131                         sttd_recorder_unset_audio_session();
1132
1133                         sttd_engine_agent_recognize_cancel(uid);
1134                         ecore_timer_del(g_recording_timer);
1135                         sttd_client_set_state(uid, APP_STATE_READY);
1136
1137                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
1138                         return STTD_ERROR_OPERATION_FAILED;
1139                 }
1140
1141                 /* Notify uid state change */
1142                 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1143
1144                 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1145                 return STTD_RESULT_STATE_DONE;
1146         }
1147
1148         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
1149
1150         return STTD_RESULT_STATE_NOT_DONE;
1151 }
1152
1153 Eina_Bool __time_out_for_processing(void *data)
1154 {
1155         g_processing_timer = NULL;
1156
1157         /* current uid */
1158         int uid = stt_client_get_current_recognition();
1159         if (0 == uid)   return EINA_FALSE;
1160
1161         /* Cancel engine */
1162         int ret = sttd_engine_agent_recognize_cancel(uid);
1163         if (0 != ret) {
1164                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1165         }
1166
1167         if (0 != sttdc_send_result(uid, STTP_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
1168                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
1169
1170                 /* send error msg */
1171                 int reason = (int)STTD_ERROR_TIMED_OUT;
1172                 if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
1173                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
1174                 }
1175         }
1176
1177         /* Change uid state */
1178         sttd_client_set_state(uid, APP_STATE_READY);
1179
1180         stt_client_unset_current_recognition();
1181
1182         return EINA_FALSE;
1183 }
1184
1185 void __sttd_server_engine_stop(void* data)
1186 {
1187         int uid = (int)data;
1188         /* change uid state */
1189         sttd_client_set_state(uid, APP_STATE_PROCESSING);
1190
1191         /* Notify uid state change */
1192         sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1193
1194         /* Unset audio session */
1195         int ret = sttd_recorder_unset_audio_session();
1196         if (0 != ret) {
1197                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1198                 return;
1199         }
1200
1201         /* Stop engine */
1202         ret = sttd_engine_agent_recognize_stop_engine(uid);
1203         if (0 != ret) {
1204                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1205                 return;
1206         }
1207
1208         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1209 }
1210
1211 void __sttd_stop_sound_completed_cb(int id, void *user_data)
1212 {
1213         SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
1214
1215         /* After wav play callback, engine stop */
1216         ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
1217
1218         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1219         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1220         return;
1221 }
1222
1223 int sttd_server_stop(int uid)
1224 {
1225         /* check if uid is valid */
1226         app_state_e state;
1227         if (0 != sttd_client_get_state(uid, &state)) {
1228                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1229                 return STTD_ERROR_INVALID_PARAMETER;
1230         }
1231
1232         /* check uid state */
1233         if (APP_STATE_RECORDING != state) {
1234                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1235                 return STTD_ERROR_INVALID_STATE;
1236         }
1237
1238         if (NULL != g_recording_timer)  {
1239                 ecore_timer_del(g_recording_timer);
1240                 g_recording_timer = NULL;
1241         }
1242
1243         char* sound = NULL;
1244         if (0 != sttd_client_get_stop_sound(uid, &sound)) {
1245                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1246                 return STTD_ERROR_OPERATION_FAILED;
1247         }
1248
1249         SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
1250
1251         int ret;
1252         /* 1. Stop recorder */
1253         ret = sttd_engine_agent_recognize_stop_recorder(uid);
1254         if (0 != ret) {
1255                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
1256                 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
1257                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
1258                 }
1259                 if (NULL != sound)      free(sound);
1260                 return STTD_ERROR_OPERATION_FAILED;
1261         }
1262
1263         /* 2. Request wav play */
1264         if (NULL != sound) {
1265                 int id = 0;
1266                 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_stop_sound_completed_cb, (void*)uid, &id);
1267                 if (WAV_PLAYER_ERROR_NONE != ret) {
1268                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1269                 } else {
1270                         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
1271                 }
1272
1273                 free(sound);
1274
1275                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1276
1277                 return STTD_RESULT_STATE_NOT_DONE;
1278         } else {
1279                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1280
1281                 /* Unset audio session */
1282                 ret = sttd_recorder_unset_audio_session();
1283                 if (0 != ret) {
1284                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1285                         return STTD_ERROR_OPERATION_FAILED;
1286                 }
1287
1288                 /* Stop engine */
1289                 ret = sttd_engine_agent_recognize_stop_engine(uid);
1290                 if (0 != ret) {
1291                         stt_client_unset_current_recognition();
1292                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1293                         return STTD_ERROR_OPERATION_FAILED;
1294                 }
1295
1296                 /* change uid state */
1297                 sttd_client_set_state(uid, APP_STATE_PROCESSING);
1298
1299                 /* Notify uid state change */
1300                 sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1301
1302                 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1303
1304                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1305
1306                 return STTD_RESULT_STATE_DONE;
1307         }
1308
1309         return STTD_ERROR_NONE;
1310 }
1311
1312 int sttd_server_cancel(int uid)
1313 {
1314         /* check if uid is valid */
1315         app_state_e state;
1316         if (0 != sttd_client_get_state(uid, &state)) {
1317                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1318                 return STTD_ERROR_INVALID_PARAMETER;
1319         }
1320
1321         /* check uid state */
1322         if (APP_STATE_READY == state) {
1323                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
1324                 return STTD_ERROR_NONE;
1325         }
1326
1327         stt_client_unset_current_recognition();
1328
1329         if (NULL != g_recording_timer) {
1330                 ecore_timer_del(g_recording_timer);
1331                 g_recording_timer = NULL;
1332         }
1333
1334         if (NULL != g_processing_timer) {
1335                 ecore_timer_del(g_processing_timer);
1336                 g_processing_timer = NULL;
1337         }
1338
1339         if (APP_STATE_RECORDING == state) {
1340                 /* Unset audio session */
1341                 int ret = sttd_recorder_unset_audio_session();
1342                 if (0 != ret) {
1343                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1344                         return STTD_ERROR_OPERATION_FAILED;
1345                 }
1346         }
1347
1348         /* change uid state */
1349         sttd_client_set_state(uid, APP_STATE_READY);
1350
1351         /* cancel engine recognition */
1352         int ret = sttd_engine_agent_recognize_cancel(uid);
1353         if (0 != ret) {
1354                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1355                 return STTD_ERROR_OPERATION_FAILED;
1356         }
1357
1358         /* Notify uid state change */
1359         sttdc_send_set_state(uid, APP_STATE_READY);
1360
1361         return STTD_ERROR_NONE;
1362 }