2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
15 #include <sound_manager.h>
16 #include <wav_player.h>
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"
27 static pthread_mutex_t sttpe_result_mutex = PTHREAD_MUTEX_INITIALIZER;
28 static pthread_mutex_t sttpe_result_time_mutex = PTHREAD_MUTEX_INITIALIZER;
32 * STT Server static variable
34 static double g_processing_timeout = 30;
36 static double g_recording_timeout = 60;
38 Ecore_Timer* g_recording_timer = NULL;
39 Ecore_Timer* g_processing_timer = NULL;
41 static int g_recording_log_count = 0;
43 static GList *g_proc_list = NULL;
46 * STT Server Callback Functions
48 void __stop_by_silence(void *data)
50 SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by silence detection");
54 uid = stt_client_get_current_recognition();
58 ret = sttd_server_stop(uid);
63 if (STTD_RESULT_STATE_DONE == ret) {
64 ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
66 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send state : result(%d)", ret);
69 sttd_server_finalize(uid);
70 stt_client_unset_current_recognition();
74 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
77 SLOG(LOG_DEBUG, TAG_STTD, "=====");
78 SLOG(LOG_DEBUG, TAG_STTD, " ");
83 static void __cancel_recognition_internal()
85 if (NULL != g_recording_timer) {
86 ecore_timer_del(g_recording_timer);
87 g_recording_timer = NULL;
91 uid = stt_client_get_current_recognition();
94 /* cancel engine recognition */
95 int ret = sttd_engine_agent_recognize_cancel(uid);
97 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
100 /* change uid state */
101 sttd_client_set_state(uid, APP_STATE_READY);
102 stt_client_unset_current_recognition();
104 ret = sttdc_send_set_state(uid, (int)APP_STATE_READY);
106 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send state change : result(%d)", ret);
109 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
113 static void __cancel_by_error(void *data)
115 SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by error");
117 __cancel_recognition_internal();
119 SLOG(LOG_DEBUG, TAG_STTD, "=====");
120 SLOG(LOG_DEBUG, TAG_STTD, " ");
125 int __server_audio_recorder_callback(const void* data, const unsigned int length)
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);
136 uid = stt_client_get_current_recognition();
138 ret = sttd_engine_agent_set_recording_data(uid, data, length);
140 ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
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;
149 if (NULL != g_recording_timer) {
150 ecore_timer_del(g_recording_timer);
151 g_recording_timer = NULL;
153 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current uid in recording is is not valid");
160 void __server_audio_interrupt_callback()
162 SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by sound interrupt");
164 __cancel_recognition_internal();
166 SLOG(LOG_DEBUG, TAG_STTD, "=====");
167 SLOG(LOG_DEBUG, TAG_STTD, " ");
170 void __cancel_by_no_record(void *data)
172 SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by no record");
174 __cancel_recognition_internal();
176 SLOG(LOG_DEBUG, TAG_STTD, "=====");
177 SLOG(LOG_DEBUG, TAG_STTD, " ");
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)
186 pthread_mutex_lock(&sttpe_result_mutex);
188 SLOG(LOG_DEBUG, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
191 int uid = stt_client_get_current_recognition();
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);
202 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
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'.");
209 SLOG(LOG_DEBUG, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
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;
217 sttd_config_time_save();
218 sttd_config_time_reset();
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;
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");
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;
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");
240 /* change state of uid */
241 sttd_client_set_state(uid, APP_STATE_READY);
242 stt_client_unset_current_recognition();
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);
247 sttd_config_time_save();
248 sttd_config_time_reset();
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;
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");
259 } else if (STTP_RESULT_EVENT_ERROR == event) {
260 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The event of recognition result is ERROR");
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;
267 sttd_config_time_reset();
269 if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
270 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
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 ");
279 /* change state of uid */
280 sttd_client_set_state(uid, APP_STATE_READY);
281 stt_client_unset_current_recognition();
286 SLOG(LOG_DEBUG, TAG_STTD, "=====");
287 SLOG(LOG_DEBUG, TAG_STTD, " ");
288 pthread_mutex_unlock(&sttpe_result_mutex);
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)
295 pthread_mutex_lock(&sttpe_result_time_mutex);
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);
302 ret = sttd_config_time_add(index, (int)event, text, start_time, end_time);
304 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add time info");
305 pthread_mutex_unlock(&sttpe_result_time_mutex);
309 pthread_mutex_unlock(&sttpe_result_time_mutex);
313 pthread_mutex_unlock(&sttpe_result_time_mutex);
318 void __server_silence_dectection_callback(sttp_silence_type_e type, void *user_param)
320 SLOG(LOG_DEBUG, TAG_STTD, "===== Silence Detection Callback");
322 int uid = stt_client_get_current_recognition();
325 if (0 != sttd_client_get_state(uid, &state)) {
326 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is not valid ");
330 if (APP_STATE_RECORDING != state) {
331 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
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");
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);
346 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recogntion uid is not valid ");
349 SLOG(LOG_DEBUG, TAG_STTD, "=====");
350 SLOG(LOG_DEBUG, TAG_STTD, " ");
355 void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data)
357 if (NULL == engine_id) {
358 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
361 SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
364 /* need to change state of app to ready */
366 uid = stt_client_get_current_recognition();
369 SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
371 sttd_server_cancel(uid);
372 sttdc_send_set_state(uid, (int)APP_STATE_READY);
374 stt_client_unset_current_recognition();
378 int ret = sttd_engine_agent_set_default_engine(engine_id);
380 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : result(%d)", ret);
382 if (NULL != language) {
383 ret = sttd_engine_agent_set_default_language(language);
385 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
388 ret = sttd_engine_agent_set_silence_detection(support_silence);
390 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
395 void __sttd_server_language_changed_cb(const char* language, void* user_data)
397 if (NULL == language) {
398 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
401 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
404 int ret = sttd_engine_agent_set_default_language(language);
406 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
411 void __sttd_server_silence_changed_cb(bool value, void* user_data)
413 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
416 ret = sttd_engine_agent_set_silence_detection(value);
418 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
427 int sttd_initialize()
431 if (0 != pthread_mutex_init(&sttpe_result_mutex, NULL)) {
432 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe result mutex.");
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.");
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.");
444 ret = sttd_recorder_initialize(__server_audio_recorder_callback, __server_audio_interrupt_callback);
446 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize recorder : result(%d)", ret);
450 /* Engine Agent initialize */
451 ret = sttd_engine_agent_init(__server_recognition_result_callback, __server_result_time_callback,
452 __server_silence_dectection_callback);
454 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
458 /* Update engine list */
459 ret = sttd_engine_agent_initialize_engine_list();
461 if (STTD_ERROR_ENGINE_NOT_FOUND == ret) {
462 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no stt engine");
464 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to update engine list : %d", ret);
469 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
476 if (0 != pthread_mutex_destroy(&sttpe_result_mutex)) {
477 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy sttpe result mutex.");
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.");
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);
493 sttd_recorder_deinitialize();
495 sttd_config_finalize();
497 sttd_engine_agent_release();
499 return STTD_ERROR_NONE;
502 static void __read_proc()
506 struct dirent *dirp = 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);
519 dp = opendir("/proc");
521 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to open proc");
524 ret = readdir_r(dp, &entry, &dirp);
526 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to readdir");
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));
535 } while (NULL != dirp);
541 Eina_Bool sttd_cleanup_client(void *data)
543 int* client_list = NULL;
544 int client_count = 0;
549 if (0 != sttd_client_get_list(&client_list, &client_count)) {
550 if (NULL != client_list)
556 if (NULL != client_list) {
557 SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
561 for (i = 0; i < client_count; i++) {
562 int pid = sttd_client_get_pid(client_list[i]);
564 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Invalid pid");
570 for (j = 0; j < g_list_length(g_proc_list); j++) {
571 iter = g_list_nth(g_proc_list, j);
573 if (pid == GPOINTER_TO_INT(iter->data)) {
574 SLOG(LOG_DEBUG, TAG_STTD, "uid (%d) is running", client_list[i]);
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]);
586 result = sttdc_send_hello(client_list[i]);
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");
597 SLOG(LOG_DEBUG, TAG_STTD, "=====");
598 SLOG(LOG_DEBUG, TAG_STTD, " ");
607 * STT Server Functions for Client
610 int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
612 if (false == sttd_engine_agent_is_default_engine()) {
613 /* Update installed engine */
614 sttd_engine_agent_initialize_engine_list();
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;
622 int ret = STTD_ERROR_NONE;
624 /* check if uid is valid */
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;
632 ret = sttd_engine_agent_load_current_engine(uid, NULL);
634 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
638 ret = sttd_engine_agent_get_option_supported(uid, silence);
640 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
644 ret = sttd_engine_agent_is_credential_needed(uid, credential);
646 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
650 /* Add client information to client manager */
651 ret = sttd_client_add(pid, uid);
653 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add client info");
657 return STTD_ERROR_NONE;
660 static Eina_Bool __quit_ecore_loop(void *data)
662 ecore_main_loop_quit();
666 int sttd_server_finalize(int uid)
668 /* check if uid is valid */
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;
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;
684 if (APP_STATE_PROCESSING == state) {
685 if (NULL != g_processing_timer) {
686 ecore_timer_del(g_processing_timer);
687 g_processing_timer = NULL;
691 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
692 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
695 stt_client_unset_current_recognition();
698 if (0 != sttd_engine_agent_unload_current_engine(uid)) {
699 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unload engine");
702 /* Remove client information */
703 if (0 != sttd_client_delete(uid)) {
704 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to delete client");
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);
713 return STTD_ERROR_NONE;
716 int sttd_server_get_supported_engines(int uid, GSList** engine_list)
718 /* Check if uid is valid */
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;
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;
732 ret = sttd_engine_agent_get_engine_list(engine_list);
734 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine list");
738 return STTD_ERROR_NONE;
741 int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence, bool* credential)
743 /* Check if uid is valid */
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;
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;
757 ret = sttd_engine_agent_load_current_engine(uid, engine_id);
759 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : %d", ret);
763 ret = sttd_engine_agent_get_option_supported(uid, silence);
765 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine options : %d", ret);
769 if (0 != sttd_engine_agent_is_credential_needed(uid, credential)) {
770 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
774 return STTD_ERROR_NONE;
777 int sttd_server_get_current_engine(int uid, char** engine_id)
779 /* Check if uid is valid */
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;
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;
793 ret = sttd_engine_agent_get_current_engine(uid, engine_id);
795 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine : %d", ret);
799 return STTD_ERROR_NONE;
802 int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
804 /* Check if uid is valid */
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;
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;
817 /* Ask engine available */
820 ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
822 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
827 stt_client_set_app_agreed(uid);
828 SLOG(LOG_DEBUG, TAG_STTD, "[Server] App(%s) confirmed that engine is available", appid);
833 return STTD_ERROR_NONE;
837 int sttd_server_get_supported_languages(int uid, GSList** lang_list)
839 /* check if uid is valid */
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;
846 /* get language list from engine */
847 int ret = sttd_engine_agent_supported_langs(uid, lang_list);
849 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get supported languages");
853 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] sttd_server_get_supported_languages");
855 return STTD_ERROR_NONE;
858 int sttd_server_get_current_langauage(int uid, char** current_lang)
860 /* check if uid is valid */
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;
867 if (NULL == current_lang) {
868 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
869 return STTD_ERROR_INVALID_PARAMETER;
872 /*get current language from engine */
873 int ret = sttd_engine_agent_get_default_lang(uid, current_lang);
875 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get default language :result(%d)", ret);
879 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
881 return STTD_ERROR_NONE;
884 int sttd_server_set_private_data(int uid, const char* key, const char* data)
886 /* check if uid is valid */
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;
893 if (NULL == key || NULL == data) {
894 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
895 return STTD_ERROR_INVALID_PARAMETER;
898 /* set private data to engine */
900 ret = sttd_engine_agent_set_private_data(uid, key, data);
902 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set private data :result(%d)", ret);
906 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Set private data");
908 return STTD_ERROR_NONE;
911 int sttd_server_get_private_data(int uid, const char* key, char** data)
913 /* check if uid is valid */
915 if (0 != sttd_client_get_state(uid, &state)) {
916 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
917 return STTD_ERROR_INVALID_PARAMETER;
920 if (NULL == key || NULL == data) {
921 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
922 return STTD_ERROR_INVALID_PARAMETER;
925 /* get private data to engine */
927 ret = sttd_engine_agent_get_private_data(uid, key, data);
929 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get private data :result(%d)", ret);
933 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get private data");
935 return STTD_ERROR_NONE;
938 int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support)
940 /* check if uid is valid */
942 if (0 != sttd_client_get_state(uid, &state)) {
943 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
944 return STTD_ERROR_INVALID_PARAMETER;
947 if (NULL == type || NULL == support) {
948 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
949 return STTD_ERROR_INVALID_PARAMETER;
953 int ret = sttd_engine_agent_is_recognition_type_supported(uid, type, &temp);
955 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
959 *support = (int)temp;
961 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
963 return STTD_ERROR_NONE;
966 int sttd_server_set_start_sound(int uid, const char* file)
968 /* check if uid is valid */
970 if (0 != sttd_client_get_state(uid, &state)) {
971 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
972 return STTD_ERROR_INVALID_PARAMETER;
975 int ret = sttd_client_set_start_sound(uid, file);
977 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
984 int sttd_server_set_stop_sound(int uid, const char* file)
986 /* check if uid is valid */
988 if (0 != sttd_client_get_state(uid, &state)) {
989 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
990 return STTD_ERROR_INVALID_PARAMETER;
993 int ret = sttd_client_set_stop_sound(uid, file);
995 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
1003 Eina_Bool __check_recording_state(void *data)
1006 int uid = stt_client_get_current_recognition();
1011 if (0 != sttdc_send_get_state(uid, (int*)&state)) {
1012 /* client is removed */
1013 SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
1014 sttd_server_finalize(uid);
1018 if (APP_STATE_READY == state) {
1020 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The daemon should cancel recording", uid);
1021 sttd_server_cancel(uid);
1022 } else if (APP_STATE_PROCESSING == state) {
1023 /* Cancel stt and send change state */
1024 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The daemon should cancel recording", uid);
1025 sttd_server_cancel(uid);
1026 sttdc_send_set_state(uid, (int)APP_STATE_READY);
1029 SLOG(LOG_DEBUG, TAG_STTD, "[Server] The states of daemon and client are identical");
1037 Eina_Bool __stop_by_recording_timeout(void *data)
1039 SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
1041 g_recording_timer = NULL;
1044 uid = stt_client_get_current_recognition();
1046 /* cancel engine recognition */
1047 int ret = sttd_server_stop(uid);
1049 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop : result(%d)", ret);
1053 SLOG(LOG_DEBUG, TAG_STTD, "=====");
1054 SLOG(LOG_DEBUG, TAG_STTD, " ");
1059 void __sttd_server_recorder_start(void* data)
1061 intptr_t puid = (intptr_t)data;
1062 int uid = (int)puid;
1063 int current_uid = stt_client_get_current_recognition();
1065 if (uid != current_uid) {
1066 stt_client_unset_current_recognition();
1070 int ret = sttd_engine_agent_recognize_start_recorder(uid);
1072 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1076 /* Notify uid state change */
1077 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1079 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1082 void __sttd_start_sound_completed_cb(int id, void *user_data)
1084 SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
1086 /* After wav play callback, recorder start */
1087 ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
1089 SLOG(LOG_DEBUG, TAG_STTD, "=====");
1090 SLOG(LOG_DEBUG, TAG_STTD, " ");
1094 int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential)
1096 if (NULL == lang || NULL == recognition_type) {
1097 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
1098 return STTD_ERROR_INVALID_PARAMETER;
1101 /* check if uid is valid */
1103 if (0 != sttd_client_get_state(uid, &state)) {
1104 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1105 return STTD_ERROR_INVALID_PARAMETER;
1108 /* check uid state */
1109 if (APP_STATE_READY != state) {
1110 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] sttd_server_start : current state is not ready");
1111 return STTD_ERROR_INVALID_STATE;
1115 if (false == stt_client_get_app_agreed(uid)) {
1117 ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
1119 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
1123 if (false == temp) {
1124 SLOG(LOG_ERROR, TAG_STTD, "[Server] App(%s) NOT confirmed that engine is available", appid);
1125 return STTD_ERROR_PERMISSION_DENIED;
1128 stt_client_set_app_agreed(uid);
1131 /* check if engine use network */
1132 if (true == sttd_engine_agent_need_network(uid)) {
1133 if (false == stt_network_is_connected()) {
1134 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
1135 return STTD_ERROR_OUT_OF_NETWORK;
1140 ret = sttd_client_get_start_sound(uid, &sound);
1142 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1146 if (0 != stt_client_set_current_recognition(uid)) {
1147 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
1148 if (NULL != sound) free(sound);
1149 return STTD_ERROR_RECORDER_BUSY;
1152 /* engine start recognition */
1153 SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
1154 uid, lang, recognition_type);
1156 SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
1158 /* 1. Set audio session */
1159 ret = sttd_recorder_set_audio_session();
1161 stt_client_unset_current_recognition();
1162 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
1163 if (NULL != sound) free(sound);
1167 bool is_sound_done = false;
1169 /* 2. Request wav play */
1170 if (NULL != sound) {
1172 intptr_t puid = (intptr_t)uid;
1173 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_start_sound_completed_cb, (void*)puid, &id);
1174 if (WAV_PLAYER_ERROR_NONE != ret) {
1175 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1176 is_sound_done = true;
1181 is_sound_done = true;
1184 /* 3. Create recorder & engine initialize */
1185 ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, credential, NULL);
1187 stt_client_unset_current_recognition();
1188 sttd_recorder_unset_audio_session();
1189 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recognition : result(%d)", ret);
1193 if (0 != strcmp(STTP_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
1194 g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
1197 /* change uid state */
1198 sttd_client_set_state(uid, APP_STATE_RECORDING);
1200 g_recording_log_count = 0;
1202 if (true == is_sound_done) {
1203 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1205 ret = sttd_engine_agent_recognize_start_recorder(uid);
1207 stt_client_unset_current_recognition();
1208 sttd_recorder_unset_audio_session();
1210 sttd_engine_agent_recognize_cancel(uid);
1211 ecore_timer_del(g_recording_timer);
1212 sttd_client_set_state(uid, APP_STATE_READY);
1214 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
1218 /* Notify uid state change */
1219 sttdc_send_set_state(uid, APP_STATE_RECORDING);
1221 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
1222 return STTD_RESULT_STATE_DONE;
1225 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
1227 return STTD_RESULT_STATE_NOT_DONE;
1230 Eina_Bool __time_out_for_processing(void *data)
1232 g_processing_timer = NULL;
1235 int uid = stt_client_get_current_recognition();
1236 if (0 == uid) return EINA_FALSE;
1239 int ret = sttd_engine_agent_recognize_cancel(uid);
1241 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1244 if (0 != sttdc_send_result(uid, STTP_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
1245 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
1247 /* send error msg */
1248 int reason = (int)STTD_ERROR_TIMED_OUT;
1249 if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
1250 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
1254 /* Change uid state */
1255 sttd_client_set_state(uid, APP_STATE_READY);
1257 stt_client_unset_current_recognition();
1262 void __sttd_server_engine_stop(void* data)
1264 intptr_t puid = (intptr_t)data;
1265 int uid = (int)puid;
1266 /* change uid state */
1267 sttd_client_set_state(uid, APP_STATE_PROCESSING);
1269 /* Notify uid state change */
1270 sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1272 /* Unset audio session */
1273 int ret = sttd_recorder_unset_audio_session();
1275 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1280 ret = sttd_engine_agent_recognize_stop_engine(uid);
1282 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1286 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1289 void __sttd_stop_sound_completed_cb(int id, void *user_data)
1291 SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
1293 /* After wav play callback, engine stop */
1294 ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
1296 SLOG(LOG_DEBUG, TAG_STTD, "=====");
1297 SLOG(LOG_DEBUG, TAG_STTD, " ");
1301 int sttd_server_stop(int uid)
1303 /* check if uid is valid */
1305 if (0 != sttd_client_get_state(uid, &state)) {
1306 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1307 return STTD_ERROR_INVALID_PARAMETER;
1310 /* check uid state */
1311 if (APP_STATE_RECORDING != state) {
1312 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
1313 return STTD_ERROR_INVALID_STATE;
1316 if (NULL != g_recording_timer) {
1317 ecore_timer_del(g_recording_timer);
1318 g_recording_timer = NULL;
1322 if (0 != sttd_client_get_stop_sound(uid, &sound)) {
1323 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
1324 return STTD_ERROR_OPERATION_FAILED;
1327 SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
1330 /* 1. Stop recorder */
1331 ret = sttd_engine_agent_recognize_stop_recorder(uid);
1333 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
1334 if (0 != sttd_engine_agent_recognize_cancel(uid)) {
1335 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
1337 if (NULL != sound) free(sound);
1341 /* 2. Request wav play */
1342 if (NULL != sound) {
1344 intptr_t puid = (intptr_t)uid;
1345 ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_stop_sound_completed_cb, (void*)puid, &id);
1346 if (WAV_PLAYER_ERROR_NONE != ret) {
1347 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
1349 SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
1354 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1356 return STTD_RESULT_STATE_NOT_DONE;
1358 SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
1360 /* Unset audio session */
1361 ret = sttd_recorder_unset_audio_session();
1363 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1368 ret = sttd_engine_agent_recognize_stop_engine(uid);
1370 stt_client_unset_current_recognition();
1371 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
1375 /* change uid state */
1376 sttd_client_set_state(uid, APP_STATE_PROCESSING);
1378 /* Notify uid state change */
1379 sttdc_send_set_state(uid, APP_STATE_PROCESSING);
1381 SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
1383 g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
1385 return STTD_RESULT_STATE_DONE;
1388 return STTD_ERROR_NONE;
1391 int sttd_server_cancel(int uid)
1393 /* check if uid is valid */
1395 if (0 != sttd_client_get_state(uid, &state)) {
1396 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
1397 return STTD_ERROR_INVALID_PARAMETER;
1400 /* check uid state */
1401 if (APP_STATE_READY == state) {
1402 SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
1403 return STTD_ERROR_NONE;
1406 stt_client_unset_current_recognition();
1408 if (NULL != g_recording_timer) {
1409 ecore_timer_del(g_recording_timer);
1410 g_recording_timer = NULL;
1413 if (NULL != g_processing_timer) {
1414 ecore_timer_del(g_processing_timer);
1415 g_processing_timer = NULL;
1418 if (APP_STATE_RECORDING == state) {
1419 /* Unset audio session */
1420 int ret = sttd_recorder_unset_audio_session();
1422 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
1427 /* change uid state */
1428 sttd_client_set_state(uid, APP_STATE_READY);
1430 /* cancel engine recognition */
1431 int ret = sttd_engine_agent_recognize_cancel(uid);
1433 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
1437 /* Notify uid state change */
1438 sttdc_send_set_state(uid, APP_STATE_READY);
1440 return STTD_ERROR_NONE;