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                         if (0 != sttdc_send_error_signal(uid, STTP_ERROR_NO_SPEECH, "No speech while recording")) {
 339                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] No speech while recording");
 340                         }
 341                 } else if (STTP_SILENCE_TYPE_END_OF_SPEECH_DETECTED == type) {
 342                         SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - End of Speech");
 343                         ecore_main_loop_thread_safe_call_async(__stop_by_silence, NULL);
 344                 }
 345         } else {
 346                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recogntion uid is not valid ");
 347         }
 348
 349         SLOG(LOG_DEBUG, TAG_STTD, "=====");
 350         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 351
 352         return;
 353 }
 354
 355 void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data)
 356 {
 357         if (NULL == engine_id) {
 358                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
 359                 return;
 360         } else {
 361                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
 362         }
 363
 364         /* need to change state of app to ready */
 365         int uid;
 366         uid = stt_client_get_current_recognition();
 367
 368         if (0 != uid) {
 369                 SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
 370
 371                 sttd_server_cancel(uid);
 372                 sttdc_send_set_state(uid, (int)APP_STATE_READY);
 373
 374                 stt_client_unset_current_recognition();
 375         }
 376
 377         /* set engine */
 378         int ret = sttd_engine_agent_set_default_engine(engine_id);
 379         if (0 != ret)
 380                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : result(%d)", ret);
 381
 382         if (NULL != language) {
 383                 ret = sttd_engine_agent_set_default_language(language);
 384                 if (0 != ret)
 385                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
 386         }
 387
 388         ret = sttd_engine_agent_set_silence_detection(support_silence);
 389         if (0 != ret)
 390                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
 391
 392         return;
 393 }
 394
 395 void __sttd_server_language_changed_cb(const char* language, void* user_data)
 396 {
 397         if (NULL == language) {
 398                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
 399                 return;
 400         } else {
 401                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
 402         }
 403
 404         int ret = sttd_engine_agent_set_default_language(language);
 405         if (0 != ret)
 406                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
 407
 408         return;
 409 }
 410
 411 void __sttd_server_silence_changed_cb(bool value, void* user_data)
 412 {
 413         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
 414
 415         int ret = 0;
 416         ret = sttd_engine_agent_set_silence_detection(value);
 417         if (0 != ret)
 418                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
 419
 420         return;
 421 }
 422
 423 /*
 424 * Daemon function
 425 */
 426
 427 int sttd_initialize()
 428 {
 429         int ret = 0;
 430
 431         if (0 != pthread_mutex_init(&sttpe_result_mutex, NULL)) {
 432                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe result mutex.");
 433         }
 434
 435         if (0 != pthread_mutex_init(&sttpe_result_time_mutex, NULL)) {
 436                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe sttpe_result_time_mutex.");
 437         }
 438
 439         if (sttd_config_initialize(__sttd_server_engine_changed_cb, __sttd_server_language_changed_cb,
 440                 __sttd_server_silence_changed_cb, NULL)) {
 441                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize config.");
 442         }
 443
 444         ret = sttd_recorder_initialize(__server_audio_recorder_callback, __server_audio_interrupt_callback);
 445         if (0 != ret) {
 446                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize recorder : result(%d)", ret);
 447                 return ret;
 448         }
 449
 450         /* Engine Agent initialize */
 451         ret = sttd_engine_agent_init(__server_recognition_result_callback, __server_result_time_callback,
 452                 __server_silence_dectection_callback);
 453         if (0 != ret) {
 454                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
 455                 return ret;
 456         }
 457
 458         /* Update engine list */
 459         ret = sttd_engine_agent_initialize_engine_list();
 460         if (0 != ret) {
 461                 if (STTD_ERROR_ENGINE_NOT_FOUND == ret) {
 462                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no stt engine");
 463                 } else {
 464                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to update engine list : %d", ret);
 465                         return ret;
 466                 }
 467         }
 468
 469         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
 470
 471         return 0;
 472 }
 473
 474 int sttd_finalize()
 475 {
 476         if (0 != pthread_mutex_destroy(&sttpe_result_mutex)) {
 477                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy sttpe result mutex.");
 478         }
 479
 480         if (0 != pthread_mutex_destroy(&sttpe_result_time_mutex)) {
 481                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy sttpe_result_time_mutex.");
 482         }
 483
 484         GList *iter = NULL;
 485         if (0 < g_list_length(g_proc_list)) {
 486                 iter = g_list_first(g_proc_list);
 487                 while (NULL != iter) {
 488                         g_proc_list = g_list_remove_link(g_proc_list, iter);
 489                         iter = g_list_first(g_proc_list);
 490                 }
 491         }
 492
 493         sttd_recorder_deinitialize();
 494
 495         sttd_config_finalize();
 496
 497         sttd_engine_agent_release();
 498
 499         return STTD_ERROR_NONE;
 500 }
 501
 502 static void __read_proc()
 503 {
 504         DIR *dp = NULL;
 505         struct dirent entry;
 506         struct dirent *dirp = NULL;
 507         int ret = -1;
 508         int tmp;
 509
 510         GList *iter = NULL;
 511         if (0 < g_list_length(g_proc_list)) {
 512                 iter = g_list_first(g_proc_list);
 513                 while (NULL != iter) {
 514                         g_proc_list = g_list_remove_link(g_proc_list, iter);
 515                         iter = g_list_first(g_proc_list);
 516                 }
 517         }
 518
 519         dp = opendir("/proc");
 520         if (NULL == dp) {
 521                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to open proc");
 522         } else {
 523                 do {
 524                         ret = readdir_r(dp, &entry, &dirp);
 525                         if (0 != ret) {
 526                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to readdir");
 527                                 break;
 528                         }
 529
 530                         if (NULL != dirp) {
 531                                 tmp = atoi(dirp->d_name);
 532                                 if (0 >= tmp)   continue;
 533                                 g_proc_list = g_list_append(g_proc_list, GINT_TO_POINTER(tmp));
 534                         }
 535                 } while (NULL != dirp);
 536                 closedir(dp);
 537         }
 538         return;
 539 }
 540
 541 Eina_Bool sttd_cleanup_client(void *data)
 542 {
 543         int* client_list = NULL;
 544         int client_count = 0;
 545         int i = 0;
 546         int j = 0;
 547         bool exist = false;
 548
 549         if (0 != sttd_client_get_list(&client_list, &client_count)) {
 550                 if (NULL != client_list)
 551                         free(client_list);
 552
 553                 return EINA_TRUE;
 554         }
 555
 556         if (NULL != client_list) {
 557                 SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
 558
 559                 __read_proc();
 560
 561                 for (i = 0; i < client_count; i++) {
 562                         int pid = sttd_client_get_pid(client_list[i]);
 563                         if (0 > pid) {
 564                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Invalid pid");
 565                                 continue;
 566                         }
 567
 568                         exist = false;
 569                         GList *iter = NULL;
 570                         for (j = 0; j < g_list_length(g_proc_list); j++) {
 571                                 iter = g_list_nth(g_proc_list, j);
 572                                 if (NULL != iter) {
 573                                         if (pid == GPOINTER_TO_INT(iter->data)) {
 574                                                 SLOG(LOG_DEBUG, TAG_STTD, "uid (%d) is running", client_list[i]);
 575                                                 exist = true;
 576                                                 break;
 577                                         }
 578                                 }
 579                         }
 580
 581                         if (false == exist) {
 582                                 SLOG(LOG_ERROR, TAG_STTD, "uid (%d) should be removed", client_list[i]);
 583                                 sttd_server_finalize(client_list[i]);
 584                         }
 585 #if 0
 586                         result = sttdc_send_hello(client_list[i]);
 587
 588                         if (0 == result) {
 589                                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", client_list[i]);
 590                                 sttd_server_finalize(client_list[i]);
 591                         } else if (-1 == result) {
 592                                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Hello result has error");
 593                         }
 594 #endif
 595                 }
 596
 597                 SLOG(LOG_DEBUG, TAG_STTD, "=====");
 598                 SLOG(LOG_DEBUG, TAG_STTD, "  ");
 599
 600                 free(client_list);
 601         }
 602
 603         return EINA_TRUE;
 604 }
 605
 606 /*
 607 * STT Server Functions for Client
 608 */
 609
 610 int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
 611 {
 612         if (false == sttd_engine_agent_is_default_engine()) {
 613                 /* Update installed engine */
 614                 sttd_engine_agent_initialize_engine_list();
 615
 616                 if (false == sttd_engine_agent_is_default_engine()) {
 617                         SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] No stt-engine");
 618                         return STTD_ERROR_ENGINE_NOT_FOUND;
 619                 }
 620         }
 621
 622         int ret = STTD_ERROR_NONE;
 623
 624         /* check if uid is valid */
 625         app_state_e state;
 626         if (0 == sttd_client_get_state(uid, &state)) {
 627                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid has already been registered");
 628                 return STTD_ERROR_NONE;
 629         }
 630
 631         /* load engine */
 632         ret = sttd_engine_agent_load_current_engine(uid, NULL);
 633         if (0 != ret) {
 634                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
 635                 return ret;
 636         }
 637
 638         ret = sttd_engine_agent_get_option_supported(uid, silence);
 639         if (0 != ret) {
 640                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
 641                 return ret;
 642         }
 643
 644         ret = sttd_engine_agent_is_credential_needed(uid, credential);
 645         if (0 != ret) {
 646                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
 647                 return ret;
 648         }
 649
 650         /* Add client information to client manager */
 651         ret = sttd_client_add(pid, uid);
 652         if (0 != ret) {
 653                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add client info");
 654                 return ret;
 655         }
 656
 657         return STTD_ERROR_NONE;
 658 }
 659
 660 static Eina_Bool __quit_ecore_loop(void *data)
 661 {
 662         ecore_main_loop_quit();
 663         return EINA_FALSE;
 664 }
 665
 666 int sttd_server_finalize(int uid)
 667 {
 668         /* check if uid is valid */
 669         app_state_e state;
 670         if (0 != sttd_client_get_state(uid, &state)) {
 671                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 672                 return STTD_ERROR_INVALID_PARAMETER;
 673         }
 674
 675         /* release recorder */
 676         if (APP_STATE_RECORDING == state || APP_STATE_PROCESSING == state) {
 677                 if (APP_STATE_RECORDING == state) {
 678                         if (NULL != g_recording_timer)  {
 679                                 ecore_timer_del(g_recording_timer);
 680                                 g_recording_timer = NULL;
 681                         }
 682                 }
 683
 684                 if (APP_STATE_PROCESSING == state) {
 685                         if (NULL != g_processing_timer) {
 686                                 ecore_timer_del(g_processing_timer);
 687                                 g_processing_timer = NULL;
 688                         }
 689                 }
 690
 691                 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
 692                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
 693                 }
 694
 695                 stt_client_unset_current_recognition();
 696         }
 697
 698         if (0 != sttd_engine_agent_unload_current_engine(uid)) {
 699                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unload engine");
 700         }
 701
 702         /* Remove client information */
 703         if (0 != sttd_client_delete(uid)) {
 704                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to delete client");
 705         }
 706
 707         /* unload engine, if ref count of client is 0 */
 708         if (0 == sttd_client_get_ref_count()) {
 709 //              sttd_dbus_close_connection();
 710                 ecore_timer_add(0, __quit_ecore_loop, NULL);
 711         }
 712
 713         return STTD_ERROR_NONE;
 714 }
 715
 716 int sttd_server_get_supported_engines(int uid, GSList** engine_list)
 717 {
 718         /* Check if uid is valid */
 719         app_state_e state;
 720         if (0 != sttd_client_get_state(uid, &state)) {
 721                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 722                 return STTD_ERROR_INVALID_PARAMETER;
 723         }
 724
 725         /* Check state of uid */
 726         if (APP_STATE_READY != state) {
 727                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 728                 return STTD_ERROR_INVALID_STATE;
 729         }
 730
 731         int ret;
 732         ret = sttd_engine_agent_get_engine_list(engine_list);
 733         if (0 != ret) {
 734                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine list");
 735                 return ret;
 736         }
 737
 738         return STTD_ERROR_NONE;
 739 }
 740
 741 int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence, bool* credential)
 742 {
 743         /* Check if uid is valid */
 744         app_state_e state;
 745         if (0 != sttd_client_get_state(uid, &state)) {
 746                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 747                 return STTD_ERROR_INVALID_PARAMETER;
 748         }
 749
 750         /* Check state of uid */
 751         if (APP_STATE_READY != state) {
 752                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 753                 return STTD_ERROR_INVALID_STATE;
 754         }
 755
 756         int ret;
 757         ret = sttd_engine_agent_load_current_engine(uid, engine_id);
 758         if (0 != ret) {
 759                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : %d", ret);
 760                 return ret;
 761         }
 762
 763         ret = sttd_engine_agent_get_option_supported(uid, silence);
 764         if (0 != ret) {
 765                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine options : %d", ret);
 766                 return ret;
 767         }
 768
 769         if (0 != sttd_engine_agent_is_credential_needed(uid, credential)) {
 770                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
 771                 return ret;
 772         }
 773
 774         return STTD_ERROR_NONE;
 775 }
 776
 777 int sttd_server_get_current_engine(int uid, char** engine_id)
 778 {
 779         /* Check if uid is valid */
 780         app_state_e state;
 781         if (0 != sttd_client_get_state(uid, &state)) {
 782                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 783                 return STTD_ERROR_INVALID_PARAMETER;
 784         }
 785
 786         /* Check state of uid */
 787         if (APP_STATE_READY != state) {
 788                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 789                 return STTD_ERROR_INVALID_STATE;
 790         }
 791
 792         int ret;
 793         ret = sttd_engine_agent_get_current_engine(uid, engine_id);
 794         if (0 != ret) {
 795                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine : %d", ret);
 796                 return ret;
 797         }
 798
 799         return STTD_ERROR_NONE;
 800 }
 801
 802 int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
 803 {
 804         /* Check if uid is valid */
 805         app_state_e state;
 806         if (0 != sttd_client_get_state(uid, &state)) {
 807                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 808                 return STTD_ERROR_INVALID_PARAMETER;
 809         }
 810
 811         /* Check state of uid */
 812         if (APP_STATE_READY != state) {
 813                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
 814                 return STTD_ERROR_INVALID_STATE;
 815         }
 816
 817         /* Ask engine available */
 818         int ret;
 819         bool temp = false;
 820         ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
 821         if (0 != ret) {
 822                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
 823                 return ret;
 824         }
 825
 826         if (true == temp) {
 827                 stt_client_set_app_agreed(uid);
 828                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] App(%s) confirmed that engine is available", appid);
 829         }
 830
 831         *available = temp;
 832
 833         return STTD_ERROR_NONE;
 834 }
 835
 836
 837 int sttd_server_get_supported_languages(int uid, GSList** lang_list)
 838 {
 839         /* check if uid is valid */
 840         app_state_e state;
 841         if (0 != sttd_client_get_state(uid, &state)) {
 842                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 843                 return STTD_ERROR_INVALID_PARAMETER;
 844         }
 845
 846         /* get language list from engine */
 847         int ret = sttd_engine_agent_supported_langs(uid, lang_list);
 848         if (0 != ret) {
 849                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get supported languages");
 850                 return ret;
 851         }
 852
 853         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] sttd_server_get_supported_languages");
 854
 855         return STTD_ERROR_NONE;
 856 }
 857
 858 int sttd_server_get_current_langauage(int uid, char** current_lang)
 859 {
 860         /* check if uid is valid */
 861         app_state_e state;
 862         if (0 != sttd_client_get_state(uid, &state)) {
 863                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 864                 return STTD_ERROR_INVALID_PARAMETER;
 865         }
 866
 867         if (NULL == current_lang) {
 868                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 869                 return STTD_ERROR_INVALID_PARAMETER;
 870         }
 871
 872         /*get current language from engine */
 873         int ret = sttd_engine_agent_get_default_lang(uid, current_lang);
 874         if (0 != ret) {
 875                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get default language :result(%d)", ret);
 876                 return ret;
 877         }
 878
 879         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
 880
 881         return STTD_ERROR_NONE;
 882 }
 883
 884 int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support)
 885 {
 886         /* check if uid is valid */
 887         app_state_e state;
 888         if (0 != sttd_client_get_state(uid, &state)) {
 889                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 890                 return STTD_ERROR_INVALID_PARAMETER;
 891         }
 892
 893         if (NULL == type || NULL == support) {
 894                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
 895                 return STTD_ERROR_INVALID_PARAMETER;
 896         }
 897
 898         bool temp;
 899         int ret = sttd_engine_agent_is_recognition_type_supported(uid, type, &temp);
 900         if (0 != ret) {
 901                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
 902                 return ret;
 903         }
 904
 905         *support = (int)temp;
 906
 907         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
 908
 909         return STTD_ERROR_NONE;
 910 }
 911
 912 int sttd_server_set_start_sound(int uid, const char* file)
 913 {
 914         /* check if uid is valid */
 915         app_state_e state;
 916         if (0 != sttd_client_get_state(uid, &state)) {
 917                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 918                 return STTD_ERROR_INVALID_PARAMETER;
 919         }
 920
 921         int ret = sttd_client_set_start_sound(uid, file);
 922         if (0 != ret) {
 923                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
 924                 return ret;
 925         }
 926
 927         return 0;
 928 }
 929
 930 int sttd_server_set_stop_sound(int uid, const char* file)
 931 {
 932         /* check if uid is valid */
 933         app_state_e state;
 934         if (0 != sttd_client_get_state(uid, &state)) {
 935                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
 936                 return STTD_ERROR_INVALID_PARAMETER;
 937         }
 938
 939         int ret = sttd_client_set_stop_sound(uid, file);
 940         if (0 != ret) {
 941                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
 942                 return ret;
 943         }
 944
 945         return 0;
 946 }
 947
 948 #if 0
 949 Eina_Bool __check_recording_state(void *data)
 950 {
 951         /* current uid */
 952         int uid = stt_client_get_current_recognition();
 953         if (0 == uid)
 954                 return EINA_FALSE;
 955
 956         app_state_e state;
 957         if (0 != sttdc_send_get_state(uid, (int*)&state)) {
 958                 /* client is removed */
 959                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
 960                 sttd_server_finalize(uid);
 961                 return EINA_FALSE;
 962         }
 963
 964         if (APP_STATE_READY == state) {
 965                 /* Cancel stt */
 966                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The daemon should cancel recording", uid);
 967                 sttd_server_cancel(uid);
 968         } else if (APP_STATE_PROCESSING == state) {
 969                 /* Cancel stt and send change state */
 970                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The daemon should cancel recording", uid);
 971                 sttd_server_cancel(uid);
 972                 sttdc_send_set_state(uid, (int)APP_STATE_READY);
 973         } else {
 974                 /* Normal state */
 975                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The states of daemon and client are identical");
 976                 return EINA_TRUE;
 977         }
 978
 979         return EINA_FALSE;
 980 }
 981 #endif
 982
 983 Eina_Bool __stop_by_recording_timeout(void *data)
 984 {
 985         SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
 986
 987         g_recording_timer = NULL;
 988
 989         int uid = 0;
 990         uid = stt_client_get_current_recognition();
 991         if (0 != uid) {
 992                 /* cancel engine recognition */
 993                 int ret = sttd_server_stop(uid);
 994                 if (0 != ret) {
 995                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop : result(%d)", ret);
 996                 }
 997         }
 998
 999         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1000         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1001
1002         return EINA_FALSE;
1003 }
1004
1005 void __sttd_server_recorder_start(void* data)
1006 {
1007         intptr_t puid = (intptr_t)data;
1008         int uid = (int)puid;
1009         int current_uid = stt_client_get_current_recognition();
1010
1011         if (uid != current_uid) {
1012                 stt_client_unset_current_recognition();
1013                 return;
1014         }
1015
1016         int ret = sttd_engine_agent_recognize_start_recorder(uid);
1017         if (0 != ret) {
1018                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1019                 return;
1020         }
1021
1022         /* Notify uid state change */
1023         sttdc_send_set_state(uid, APP_STATE_RECORDING);
1024
1025         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1026 }
1027
1028 void __sttd_start_sound_completed_cb(int id, void *user_data)
1029 {
1030         SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
1031
1032         /* After wav play callback, recorder start */
1033         ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
1034
1035         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1036         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1037         return;
1038 }
1039
1040 int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential)
1041 {
1042         if (NULL == lang || NULL == recognition_type) {
1043                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1044                 return STTD_ERROR_INVALID_PARAMETER;
1045         }
1046
1047         /* check if uid is valid */
1048         app_state_e state;
1049         if (0 != sttd_client_get_state(uid, &state)) {
1050                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1051                 return STTD_ERROR_INVALID_PARAMETER;
1052         }
1053
1054         /* check uid state */
1055         if (APP_STATE_READY != state) {
1056                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] sttd_server_start : current state is not ready");
1057                 return STTD_ERROR_INVALID_STATE;
1058         }
1059
1060         int ret = 0;
1061         if (false == stt_client_get_app_agreed(uid)) {
1062                 bool temp = false;
1063                 ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
1064                 if (0 != ret) {
1065                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
1066                         return ret;
1067                 }
1068
1069                 if (false == temp) {
1070                         SLOG(LOG_ERROR, TAG_STTD, "[Server] App(%s) NOT confirmed that engine is available", appid);
1071                         return STTD_ERROR_PERMISSION_DENIED;
1072                 }
1073
1074                 stt_client_set_app_agreed(uid);
1075         }
1076
1077         /* check if engine use network */
1078         if (true == sttd_engine_agent_need_network(uid)) {
1079                 if (false == stt_network_is_connected()) {
1080                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
1081                         return STTD_ERROR_OUT_OF_NETWORK;
1082                 }
1083         }
1084
1085         char* sound = NULL;
1086         ret = sttd_client_get_start_sound(uid, &sound);
1087         if (0 != ret) {
1088                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1089                 return ret;
1090         }
1091
1092         if (0 != stt_client_set_current_recognition(uid)) {
1093                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1094                 if (NULL != sound)      free(sound);
1095                 return STTD_ERROR_RECORDER_BUSY;
1096         }
1097
1098         /* engine start recognition */
1099         SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
1100                         uid, lang, recognition_type);
1101         if (NULL != sound)
1102                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
1103
1104         /* 1. Set audio session */
1105         ret = sttd_recorder_set_audio_session();
1106         if (0 != ret) {
1107                 stt_client_unset_current_recognition();
1108                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
1109                 if (NULL != sound)      free(sound);
1110                 return ret;
1111         }
1112
1113         bool is_sound_done = false;
1114
1115         /* 2. Request wav play */
1116         if (NULL != sound) {
1117                 int id = 0;
1118                 intptr_t puid = (intptr_t)uid;
1119                 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_start_sound_completed_cb, (void*)puid, &id);
1120                 if (WAV_PLAYER_ERROR_NONE != ret) {
1121                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1122                         is_sound_done = true;
1123                 }
1124                 free(sound);
1125                 sound = NULL;
1126         } else {
1127                 is_sound_done = true;
1128         }
1129
1130         /* 3. Create recorder & engine initialize */
1131         ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, credential, NULL);
1132         if (0 != ret) {
1133                 stt_client_unset_current_recognition();
1134                 sttd_recorder_unset_audio_session();
1135                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1136                 return ret;
1137         }
1138
1139         if (0 != strcmp(STTP_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
1140                 g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
1141         }
1142
1143         /* change uid state */
1144         sttd_client_set_state(uid, APP_STATE_RECORDING);
1145
1146         g_recording_log_count = 0;
1147
1148         if (true == is_sound_done) {
1149                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1150
1151                 ret = sttd_engine_agent_recognize_start_recorder(uid);
1152                 if (0 != ret) {
1153                         stt_client_unset_current_recognition();
1154                         sttd_recorder_unset_audio_session();
1155
1156                         sttd_engine_agent_recognize_cancel(uid);
1157                         ecore_timer_del(g_recording_timer);
1158                         sttd_client_set_state(uid, APP_STATE_READY);
1159
1160                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
1161                         return ret;
1162                 }
1163
1164                 /* Notify uid state change */
1165                 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1166
1167                 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1168                 return STTD_RESULT_STATE_DONE;
1169         }
1170
1171         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
1172
1173         return STTD_RESULT_STATE_NOT_DONE;
1174 }
1175
1176 Eina_Bool __time_out_for_processing(void *data)
1177 {
1178         g_processing_timer = NULL;
1179
1180         /* current uid */
1181         int uid = stt_client_get_current_recognition();
1182         if (0 == uid)   return EINA_FALSE;
1183
1184         /* Cancel engine */
1185         int ret = sttd_engine_agent_recognize_cancel(uid);
1186         if (0 != ret) {
1187                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1188         }
1189
1190         if (0 != sttdc_send_result(uid, STTP_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
1191                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
1192
1193                 /* send error msg */
1194                 int reason = (int)STTD_ERROR_TIMED_OUT;
1195                 if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
1196                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
1197                 }
1198         }
1199
1200         /* Change uid state */
1201         sttd_client_set_state(uid, APP_STATE_READY);
1202
1203         stt_client_unset_current_recognition();
1204
1205         return EINA_FALSE;
1206 }
1207
1208 void __sttd_server_engine_stop(void* data)
1209 {
1210         intptr_t puid = (intptr_t)data;
1211         int uid = (int)puid;
1212         /* change uid state */
1213         sttd_client_set_state(uid, APP_STATE_PROCESSING);
1214
1215         /* Notify uid state change */
1216         sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1217
1218         /* Unset audio session */
1219         int ret = sttd_recorder_unset_audio_session();
1220         if (0 != ret) {
1221                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1222                 return;
1223         }
1224
1225         /* Stop engine */
1226         ret = sttd_engine_agent_recognize_stop_engine(uid);
1227         if (0 != ret) {
1228                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1229                 return;
1230         }
1231
1232         SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1233 }
1234
1235 void __sttd_stop_sound_completed_cb(int id, void *user_data)
1236 {
1237         SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
1238
1239         /* After wav play callback, engine stop */
1240         ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
1241
1242         SLOG(LOG_DEBUG, TAG_STTD, "=====");
1243         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1244         return;
1245 }
1246
1247 int sttd_server_stop(int uid)
1248 {
1249         /* check if uid is valid */
1250         app_state_e state;
1251         if (0 != sttd_client_get_state(uid, &state)) {
1252                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1253                 return STTD_ERROR_INVALID_PARAMETER;
1254         }
1255
1256         /* check uid state */
1257         if (APP_STATE_RECORDING != state) {
1258                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1259                 return STTD_ERROR_INVALID_STATE;
1260         }
1261
1262         if (NULL != g_recording_timer)  {
1263                 ecore_timer_del(g_recording_timer);
1264                 g_recording_timer = NULL;
1265         }
1266
1267         char* sound = NULL;
1268         if (0 != sttd_client_get_stop_sound(uid, &sound)) {
1269                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1270                 return STTD_ERROR_OPERATION_FAILED;
1271         }
1272
1273         SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
1274
1275         int ret;
1276         /* 1. Stop recorder */
1277         ret = sttd_engine_agent_recognize_stop_recorder(uid);
1278         if (0 != ret) {
1279                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
1280                 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
1281                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
1282                 }
1283                 if (NULL != sound)      free(sound);
1284                 return ret;
1285         }
1286
1287         /* 2. Request wav play */
1288         if (NULL != sound) {
1289                 int id = 0;
1290                 intptr_t puid = (intptr_t)uid;
1291                 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_stop_sound_completed_cb, (void*)puid, &id);
1292                 if (WAV_PLAYER_ERROR_NONE != ret) {
1293                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1294                 } else {
1295                         SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
1296                 }
1297
1298                 free(sound);
1299
1300                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1301
1302                 return STTD_RESULT_STATE_NOT_DONE;
1303         } else {
1304                 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1305
1306                 /* Unset audio session */
1307                 ret = sttd_recorder_unset_audio_session();
1308                 if (0 != ret) {
1309                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1310                         return ret;
1311                 }
1312
1313                 /* Stop engine */
1314                 ret = sttd_engine_agent_recognize_stop_engine(uid);
1315                 if (0 != ret) {
1316                         stt_client_unset_current_recognition();
1317                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1318                         return ret;
1319                 }
1320
1321                 /* change uid state */
1322                 sttd_client_set_state(uid, APP_STATE_PROCESSING);
1323
1324                 /* Notify uid state change */
1325                 sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1326
1327                 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1328
1329                 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1330
1331                 return STTD_RESULT_STATE_DONE;
1332         }
1333
1334         return STTD_ERROR_NONE;
1335 }
1336
1337 int sttd_server_cancel(int uid)
1338 {
1339         /* check if uid is valid */
1340         app_state_e state;
1341         if (0 != sttd_client_get_state(uid, &state)) {
1342                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1343                 return STTD_ERROR_INVALID_PARAMETER;
1344         }
1345
1346         /* check uid state */
1347         if (APP_STATE_READY == state) {
1348                 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
1349                 return STTD_ERROR_NONE;
1350         }
1351
1352         stt_client_unset_current_recognition();
1353
1354         if (NULL != g_recording_timer) {
1355                 ecore_timer_del(g_recording_timer);
1356                 g_recording_timer = NULL;
1357         }
1358
1359         if (NULL != g_processing_timer) {
1360                 ecore_timer_del(g_processing_timer);
1361                 g_processing_timer = NULL;
1362         }
1363
1364         if (APP_STATE_RECORDING == state) {
1365                 /* Unset audio session */
1366                 int ret = sttd_recorder_unset_audio_session();
1367                 if (0 != ret) {
1368                         SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1369                         return ret;
1370                 }
1371         }
1372
1373         /* change uid state */
1374         sttd_client_set_state(uid, APP_STATE_READY);
1375
1376         /* cancel engine recognition */
1377         int ret = sttd_engine_agent_recognize_cancel(uid);
1378         if (0 != ret) {
1379                 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1380                 return ret;
1381         }
1382
1383         /* Notify uid state change */
1384         sttdc_send_set_state(uid, APP_STATE_READY);
1385
1386         return STTD_ERROR_NONE;
1387 }