/*
-* Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved
+* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* limitations under the License.
*/
+#include <pthread.h>
#include <sound_manager.h>
#include <wav_player.h>
#include "sttd_server.h"
+#define CLIENT_CLEAN_UP_TIME 500
+
+
+static pthread_mutex_t stte_result_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t stte_result_time_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+
/*
* STT Server static variable
*/
static double g_recording_timeout = 60;
+static Ecore_Timer* g_check_client_timer = NULL;
Ecore_Timer* g_recording_timer = NULL;
Ecore_Timer* g_processing_timer = NULL;
-static Eina_Bool g_stt_daemon_exist = EINA_TRUE;
-
static int g_recording_log_count = 0;
+static GList *g_proc_list = NULL;
+
/*
* STT Server Callback Functions
*/
-
-Eina_Bool sttd_get_daemon_exist()
+void __stop_by_silence(void *data)
{
- return g_stt_daemon_exist;
-}
-
-Eina_Bool __stop_by_silence(void *data)
-{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by silence detection");
+ SLOG(LOG_INFO, TAG_STTD, "===== Stop by silence detection");
int uid = 0;
int ret;
if (0 != uid) {
- ret = sttd_server_stop(uid);
+ ret = sttd_server_stop(uid);
if (0 > ret) {
- return EINA_FALSE;
+ return;
}
-
+
if (STTD_RESULT_STATE_DONE == ret) {
ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
if (0 != ret) {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
}
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
- return EINA_FALSE;
+ return;
}
static void __cancel_recognition_internal()
g_recording_timer = NULL;
}
+ int ret = 0;
int uid = 0;
uid = stt_client_get_current_recognition();
- if (0 != uid) {
- /* cancel engine recognition */
- int ret = sttd_engine_agent_recognize_cancel(uid);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
- }
+ app_state_e state = 0;
+ ret = sttd_client_get_state(uid, &state);
- /* change uid state */
- sttd_client_set_state(uid, APP_STATE_READY);
- stt_client_unset_current_recognition();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return;
+ }
- ret = sttdc_send_set_state(uid, (int)APP_STATE_READY);
+ if (0 != uid && (APP_STATE_PROCESSING == state || APP_STATE_RECORDING == state)) {
+ SLOG(LOG_INFO, TAG_STTD, "===== cancel by internal");
+ /* cancel engine recognition */
+ ret = sttd_server_cancel(uid);
if (0 != ret) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send state change : result(%d)", ret);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
}
} else {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
}
}
-Eina_Bool __cancel_by_error(void *data)
+static void __cancel_by_error(void *data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by error");
+ SLOG(LOG_INFO, TAG_STTD, "===== Cancel by error");
__cancel_recognition_internal();
SLOG(LOG_DEBUG, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
- return EINA_FALSE;
+ return;
}
int __server_audio_recorder_callback(const void* data, const unsigned int length)
if (NULL == data || 0 == length) {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Recording data is not valid");
- ecore_timer_add(0, __cancel_by_error, NULL);
+ ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
return -1;
}
uid = stt_client_get_current_recognition();
if (0 != uid) {
- ret = sttd_engine_agent_set_recording_data(uid, data, length);
+ ret = sttd_engine_agent_set_recording_data(data, length);
if (ret < 0) {
- ecore_timer_add(0, __cancel_by_error, NULL);
- return -1;
+ ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
+ return -1;
}
g_recording_log_count++;
if (200 <= g_recording_log_count) {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "=== Set recording data ===");
+ SLOG(LOG_DEBUG, TAG_STTD, "=== Set recording data ===");
g_recording_log_count = 0;
}
} else {
void __server_audio_interrupt_callback()
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by sound interrupt");
+ SLOG(LOG_INFO, TAG_STTD, "===== Cancel by sound interrupt");
__cancel_recognition_internal();
SLOG(LOG_DEBUG, TAG_STTD, " ");
}
-Eina_Bool __cancel_by_no_record(void *data)
+void __cancel_by_no_record(void *data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by no record");
+ SLOG(LOG_INFO, TAG_STTD, "===== Cancel by no record");
__cancel_recognition_internal();
SLOG(LOG_DEBUG, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
-
- return EINA_FALSE;
+
+ return;
}
-void __server_recognition_result_callback(sttp_result_event_e event, const char* type,
+int __server_recognition_result_callback(stte_result_event_e event, const char* type,
const char** data, int data_count, const char* msg, void *user_data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Recognition Result Callback");
+ // critical section
+ pthread_mutex_lock(&stte_result_mutex);
+
+ SLOG(LOG_INFO, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
/* check uid */
int uid = stt_client_get_current_recognition();
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
SLOG(LOG_DEBUG, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
- return;
+ pthread_mutex_unlock(&stte_result_mutex);
+ return STTD_ERROR_OPERATION_FAILED;
}
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
/* send result to client */
- if (STTP_RESULT_EVENT_FINAL_RESULT == event) {
- if (APP_STATE_PROCESSING != state ) {
+ if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
+ if (APP_STATE_PROCESSING != state) {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
}
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
/* Delete timer for processing time out */
if (NULL != g_processing_timer) {
+ ecore_thread_main_loop_begin();
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
ecore_timer_del(g_processing_timer);
g_processing_timer = NULL;
+ ecore_thread_main_loop_end();
}
sttd_config_time_save();
sttd_config_time_reset();
+ sttd_recorder_clear();
+
+ sttd_client_set_state(uid, APP_STATE_READY);
+ stt_client_unset_current_recognition();
+
if (NULL == data || 0 == data_count) {
if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
int reason = (int)STTD_ERROR_OPERATION_FAILED;
if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
}
} else {
if (0 != sttdc_send_result(uid, event, data, data_count, msg)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result");
int reason = (int)STTD_ERROR_OPERATION_FAILED;
if (0 != sttdc_send_error_signal(uid, reason, "Fail to send recognition result")) {
}
/* change state of uid */
- sttd_client_set_state(uid, APP_STATE_READY);
- stt_client_unset_current_recognition();
+// sttd_client_set_state(uid, APP_STATE_READY);
+// stt_client_unset_current_recognition();
- } else if (STTP_RESULT_EVENT_PARTIAL_RESULT == event) {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event, data_count);
+ } else if (STTE_RESULT_EVENT_PARTIAL_RESULT == event) {
+ SLOG(LOG_INFO, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event, data_count);
sttd_config_time_save();
sttd_config_time_reset();
}
}
- } else if (STTP_RESULT_EVENT_ERROR == event) {
+ } else if (STTE_RESULT_EVENT_ERROR == event) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The event of recognition result is ERROR");
/* Delete timer for processing time out */
if (NULL != g_processing_timer) {
+ ecore_thread_main_loop_begin();
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
ecore_timer_del(g_processing_timer);
g_processing_timer = NULL;
+ ecore_thread_main_loop_end();
}
sttd_config_time_reset();
+ int ret = 0;
+ if (APP_STATE_RECORDING == state) {
+ ret = sttd_engine_agent_recognize_cancel();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel: result(%d)", ret);
+ }
+ }
+
+ sttd_client_set_state(uid, APP_STATE_READY);
+ stt_client_unset_current_recognition();
+
if (0 != sttdc_send_result(uid, event, NULL, 0, msg)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
/* send error msg */
- int reason = (int)STTD_ERROR_INVALID_STATE;
+ int reason = (int)STTD_ERROR_INVALID_STATE;
if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
}
}
/* change state of uid */
- sttd_client_set_state(uid, APP_STATE_READY);
- stt_client_unset_current_recognition();
+// sttd_client_set_state(uid, APP_STATE_READY);
+// stt_client_unset_current_recognition();
} else {
/* nothing */
}
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
+ pthread_mutex_unlock(&stte_result_mutex);
- return;
+ return STTD_ERROR_NONE;
}
-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)
+bool __server_result_time_callback(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
+ pthread_mutex_lock(&stte_result_time_mutex);
+
+ SECURE_SLOG(LOG_INFO, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
index, event, text, start_time, end_time);
- if (0 == index) {
- int ret;
- ret = sttd_config_time_add(index, (int)event, text, start_time, end_time);
- if (0 != ret) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add time info");
- return false;
- }
- } else {
+ int ret;
+ ret = sttd_config_time_add(index, (int)event, text, start_time, end_time);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add time info");
+ pthread_mutex_unlock(&stte_result_time_mutex);
return false;
}
+ pthread_mutex_unlock(&stte_result_time_mutex);
+
return true;
}
-void __server_silence_dectection_callback(sttp_silence_type_e type, void *user_param)
+int __server_speech_status_callback(stte_speech_status_e status, void *user_param)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Silence Detection Callback");
+ SLOG(LOG_INFO, TAG_STTD, "===== Speech status detected Callback");
int uid = stt_client_get_current_recognition();
if (0 != uid) {
app_state_e state;
if (0 != sttd_client_get_state(uid, &state)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is not valid ");
- return;
+ return STTD_ERROR_OPERATION_FAILED;
}
- if (APP_STATE_RECORDING != state) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording");
- return;
+ if (APP_STATE_RECORDING != state && APP_STATE_PROCESSING != state) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current state is not recording, state(%d), status(%d)", state, status);
+ return STTD_ERROR_INVALID_STATE;
}
- if (STTP_SILENCE_TYPE_NO_RECORD_TIMEOUT == type) {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - No Record");
- ecore_timer_add(0, __cancel_by_no_record, NULL);
- } else if (STTP_SILENCE_TYPE_END_OF_SPEECH_DETECTED == type) {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - End of Speech");
- ecore_timer_add(0, __stop_by_silence, NULL);
+ if (STTE_SPEECH_STATUS_BEGINNING_POINT_DETECTED == status) {
+ SLOG(LOG_DEBUG, TAG_STTD, "Begin Speech detected");
+ sttdc_send_speech_status(uid, status);
+ } else if (STTE_SPEECH_STATUS_END_POINT_DETECTED == status) {
+ SLOG(LOG_DEBUG, TAG_STTD, "End Speech detected");
+ ecore_main_loop_thread_safe_call_async(__stop_by_silence, NULL);
}
} else {
- SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recogntion uid is not valid ");
+ SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recognition uid is not valid ");
}
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
- return;
+ return STTD_ERROR_NONE;
+}
+
+int __server_error_callback(stte_error_e error, const char* msg)
+{
+ SLOG(LOG_INFO, TAG_STTD, "[Server] Error Callback is called");
+ ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
+
+ return STTD_ERROR_NONE;
}
-void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, void* user_data)
+void __sttd_server_engine_changed_cb(const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data)
{
if (NULL == engine_id) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
return;
} else {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] New default engine : %s", engine_id);
}
+#if 0
/* need to change state of app to ready */
int uid;
uid = stt_client_get_current_recognition();
if (0 != uid) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
sttd_server_cancel(uid);
sttdc_send_set_state(uid, (int)APP_STATE_READY);
if (0 != ret)
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set default lang : result(%d)", ret);
}
-
+
ret = sttd_engine_agent_set_silence_detection(support_silence);
if (0 != ret)
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to Result(%d)", ret);
+#endif
return;
}
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
return;
} else {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] Get language changed : %s", language);
}
int ret = sttd_engine_agent_set_default_language(language);
void __sttd_server_silence_changed_cb(bool value, void* user_data)
{
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
+ SLOG(LOG_INFO, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
int ret = 0;
ret = sttd_engine_agent_set_silence_detection(value);
/*
* Daemon function
*/
-
-int sttd_initialize()
+int sttd_initialize(stte_request_callback_s *callback)
{
int ret = 0;
- if (sttd_config_initialize(__sttd_server_engine_changed_cb, __sttd_server_language_changed_cb,
+ if (0 != pthread_mutex_init(&stte_result_mutex, NULL)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize stte result mutex.");
+ }
+
+ if (0 != pthread_mutex_init(&stte_result_time_mutex, NULL)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize stte stte_result_time_mutex.");
+ }
+
+ if (sttd_config_initialize(__sttd_server_engine_changed_cb, __sttd_server_language_changed_cb,
__sttd_server_silence_changed_cb, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize config.");
}
ret = sttd_recorder_initialize(__server_audio_recorder_callback, __server_audio_interrupt_callback);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize recorder : result(%d)", ret);
+ return ret;
}
/* Engine Agent initialize */
ret = sttd_engine_agent_init(__server_recognition_result_callback, __server_result_time_callback,
- __server_silence_dectection_callback);
+ __server_speech_status_callback, __server_error_callback);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine agent initialize : result(%d)", ret);
return ret;
}
-
- /* Update engine list */
- ret = sttd_engine_agent_initialize_engine_list();
+
+ /* load engine */
+ ret = sttd_engine_agent_load_current_engine(callback);
if (0 != ret) {
- if (STTD_ERROR_ENGINE_NOT_FOUND == ret) {
- SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] There is no stt engine");
- } else {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to update engine list : %d", ret);
- return ret;
- }
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
+ return ret;
}
- SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
+ g_check_client_timer = ecore_timer_add(CLIENT_CLEAN_UP_TIME, sttd_cleanup_client, NULL);
+ if (NULL == g_check_client_timer) {
+ SLOG(LOG_WARN, TAG_STTD, "[Main Warning] Fail to create timer of client check");
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] initialize");
return 0;
}
int sttd_finalize()
{
+ if (0 != pthread_mutex_destroy(&stte_result_mutex)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stte result mutex.");
+ }
+
+ if (0 != pthread_mutex_destroy(&stte_result_time_mutex)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stte_result_time_mutex.");
+ }
+
+ GList *iter = NULL;
+ if (0 < g_list_length(g_proc_list)) {
+ iter = g_list_first(g_proc_list);
+ while (NULL != iter) {
+ g_proc_list = g_list_remove_link(g_proc_list, iter);
+ iter = g_list_first(g_proc_list);
+ }
+ }
+
sttd_recorder_deinitialize();
sttd_config_finalize();
sttd_engine_agent_release();
+ if (NULL != g_check_client_timer) {
+ ecore_timer_del(g_check_client_timer);
+ g_check_client_timer = NULL;
+
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete ecore timer handle");
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] finalize");
+
return STTD_ERROR_NONE;
}
+static void __read_proc()
+{
+ DIR *dp = NULL;
+ struct dirent *dirp = NULL;
+ int tmp;
+
+ GList *iter = NULL;
+ if (0 < g_list_length(g_proc_list)) {
+ iter = g_list_first(g_proc_list);
+ while (NULL != iter) {
+ g_proc_list = g_list_remove_link(g_proc_list, iter);
+ iter = g_list_first(g_proc_list);
+ }
+ }
+
+ dp = opendir("/proc");
+ if (NULL == dp) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to open proc");
+ } else {
+ do {
+ dirp = readdir(dp);
+
+ if (NULL != dirp) {
+ tmp = atoi(dirp->d_name);
+ if (0 >= tmp) continue;
+ g_proc_list = g_list_append(g_proc_list, GINT_TO_POINTER(tmp));
+ }
+ } while (NULL != dirp);
+ closedir(dp);
+ }
+ return;
+}
+
Eina_Bool sttd_cleanup_client(void *data)
{
int* client_list = NULL;
int client_count = 0;
- int result;
int i = 0;
+ int j = 0;
+ bool exist = false;
if (0 != sttd_client_get_list(&client_list, &client_count)) {
if (NULL != client_list)
}
if (NULL != client_list) {
- SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
+ SLOG(LOG_INFO, TAG_STTD, "===== Clean up client ");
- for (i = 0;i < client_count;i++) {
+ __read_proc();
+
+ for (i = 0; i < client_count; i++) {
+ int pid = sttd_client_get_pid(client_list[i]);
+ if (0 > pid) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Invalid pid");
+ continue;
+ }
+
+ exist = false;
+ GList *iter = NULL;
+ for (j = 0; j < g_list_length(g_proc_list); j++) {
+ iter = g_list_nth(g_proc_list, j);
+ if (NULL != iter) {
+ if (pid == GPOINTER_TO_INT(iter->data)) {
+ SLOG(LOG_DEBUG, TAG_STTD, "uid (%d) is running", client_list[i]);
+ exist = true;
+ break;
+ }
+ }
+ }
+
+ if (false == exist) {
+ SLOG(LOG_ERROR, TAG_STTD, "uid (%d) should be removed", client_list[i]);
+ sttd_server_finalize(client_list[i]);
+ }
+#if 0
result = sttdc_send_hello(client_list[i]);
if (0 == result) {
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", client_list[i]);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", client_list[i]);
sttd_server_finalize(client_list[i]);
} else if (-1 == result) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Hello result has error");
}
+#endif
}
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
free(client_list);
* STT Server Functions for Client
*/
-int sttd_server_initialize(int pid, int uid, bool* silence)
+int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
{
- if (false == sttd_engine_agent_is_default_engine()) {
- /* Update installed engine */
- sttd_engine_agent_initialize_engine_list();
-
- if (false == sttd_engine_agent_is_default_engine()) {
- SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] No stt-engine");
- return STTD_ERROR_ENGINE_NOT_FOUND;
- }
- }
+ int ret = STTD_ERROR_NONE;
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server] server initialize");
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
- /* load engine */
- if (0 != sttd_engine_agent_load_current_engine(uid, NULL)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
- return STTD_ERROR_OPERATION_FAILED;
+ ret = sttd_engine_agent_get_option_supported(silence);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
+ return ret;
}
- if (0 != sttd_engine_agent_get_option_supported(uid, silence)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine options supported");
- return STTD_ERROR_OPERATION_FAILED;
+ ret = sttd_engine_agent_is_credential_needed(uid, credential);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
+ return ret;
}
/* Add client information to client manager */
- if (0 != sttd_client_add(pid, uid)) {
+ ret = sttd_client_add(pid, uid);
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to add client info");
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server Success] server initialize");
+
return STTD_ERROR_NONE;
}
static Eina_Bool __quit_ecore_loop(void *data)
{
+ SLOG(LOG_INFO, TAG_STTD, "[Server] Quit");
+
+ stt_network_finalize();
+ sttd_finalize();
+ sttd_dbus_close_connection();
ecore_main_loop_quit();
+
+ SLOG(LOG_INFO, TAG_STTD, "");
+
return EINA_FALSE;
}
int sttd_server_finalize(int uid)
{
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter Finalize");
+
/* check if uid is valid */
app_state_e state;
if (0 != sttd_client_get_state(uid, &state)) {
if (APP_STATE_PROCESSING == state) {
if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
ecore_timer_del(g_processing_timer);
g_processing_timer = NULL;
}
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] stt_cancel is invoked while state is (%d)", state);
+
if (0 != sttd_engine_agent_recognize_cancel(uid)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
}
stt_client_unset_current_recognition();
}
-
- if (0 != sttd_engine_agent_unload_current_engine(uid)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unload engine");
- }
/* Remove client information */
if (0 != sttd_client_delete(uid)) {
/* unload engine, if ref count of client is 0 */
if (0 == sttd_client_get_ref_count()) {
- g_stt_daemon_exist = EINA_FALSE;
+// sttd_dbus_close_connection();
ecore_timer_add(0, __quit_ecore_loop, NULL);
}
-
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End Finalize");
+
return STTD_ERROR_NONE;
}
/* Check state of uid */
if (APP_STATE_READY != state) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported egnines");
+
int ret;
ret = sttd_engine_agent_get_engine_list(engine_list);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine list");
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
return STTD_ERROR_NONE;
}
-int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence)
+int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence, bool* credential)
{
/* Check if uid is valid */
app_state_e state;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%d), engine_id(%s)", uid, engine_id);
+
int ret;
- ret = sttd_engine_agent_load_current_engine(uid, engine_id);
+ ret = sttd_engine_agent_load_current_engine(NULL);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set engine : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
- ret = sttd_engine_agent_get_option_supported(uid, silence);
+ ret = sttd_engine_agent_get_option_supported(silence);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to engine options : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
+ }
+
+ if (0 != sttd_engine_agent_is_credential_needed(uid, credential)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get credential necessity");
+ return ret;
}
return STTD_ERROR_NONE;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
-
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%d)", uid);
+
int ret;
- ret = sttd_engine_agent_get_current_engine(uid, engine_id);
+ ret = sttd_engine_agent_get_current_engine(engine_id);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
return STTD_ERROR_NONE;
}
-int sttd_server_check_agg_agreed(int uid, const char* appid, bool* available)
+int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
{
/* Check if uid is valid */
app_state_e state;
if (0 != sttd_client_get_state(uid, &state)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
return STTD_ERROR_INVALID_PARAMETER;
}
/* Check state of uid */
if (APP_STATE_READY != state) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] check app agreed");
+
/* Ask engine available */
int ret;
bool temp = false;
- ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
+ ret = sttd_engine_agent_check_app_agreed(appid, &temp);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
if (true == temp) {
return STTD_ERROR_INVALID_PARAMETER;
}
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported languages");
+
/* get language list from engine */
- int ret = sttd_engine_agent_supported_langs(uid, lang_list);
+ int ret = sttd_engine_agent_supported_langs(lang_list);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get supported languages");
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] sttd_server_get_supported_languages");
}
/*get current language from engine */
- int ret = sttd_engine_agent_get_default_lang(uid, current_lang);
- if (0 != ret) {
+ int ret = sttd_engine_agent_get_default_lang(current_lang);
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get default language :result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get default language, current_lang(%s)", *current_lang);
+
+ return STTD_ERROR_NONE;
+}
+
+int sttd_server_set_private_data(int uid, const char* key, const char* data)
+{
+ /* check if uid is valid */
+ app_state_e state;
+ if (0 != sttd_client_get_state(uid, &state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ if (NULL == key || NULL == data) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ /* set private data to engine */
+ int ret = -1;
+ ret = sttd_engine_agent_set_private_data(key, data);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set private data :result(%d)", ret);
+ return ret;
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Set private data");
+
+ return STTD_ERROR_NONE;
+}
+
+int sttd_server_get_private_data(int uid, const char* key, char** data)
+{
+ /* check if uid is valid */
+ app_state_e state;
+ if (0 != sttd_client_get_state(uid, &state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ if (NULL == key || NULL == data) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ /* get private data to engine */
+ int ret = -1;
+ ret = sttd_engine_agent_get_private_data(key, data);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get private data :result(%d)", ret);
+ return ret;
}
- SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
return STTD_ERROR_NONE;
}
}
bool temp;
- int ret = sttd_engine_agent_is_recognition_type_supported(uid, type, &temp);
- if (0 != ret) {
+ int ret = sttd_engine_agent_is_recognition_type_supported(type, &temp);
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get recognition type supported : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
-
+
*support = (int)temp;
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
return STTD_ERROR_NONE;
}
}
int ret = sttd_client_set_start_sound(uid, file);
- if (0 != ret) {
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
return 0;
}
int ret = sttd_client_set_stop_sound(uid, file);
- if (0 != ret) {
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set start sound file : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
return 0;
}
+#if 0
Eina_Bool __check_recording_state(void *data)
-{
+{
/* current uid */
int uid = stt_client_get_current_recognition();
if (0 == uid)
app_state_e state;
if (0 != sttdc_send_get_state(uid, (int*)&state)) {
/* client is removed */
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
sttd_server_finalize(uid);
return EINA_FALSE;
}
if (APP_STATE_READY == state) {
/* Cancel stt */
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The daemon should cancel recording", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The STT service should cancel recording", uid);
sttd_server_cancel(uid);
} else if (APP_STATE_PROCESSING == state) {
/* Cancel stt and send change state */
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The daemon should cancel recording", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The STT service should cancel recording", uid);
sttd_server_cancel(uid);
sttdc_send_set_state(uid, (int)APP_STATE_READY);
} else {
/* Normal state */
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] The states of daemon and client are identical");
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] The states of STT service and client are identical");
return EINA_TRUE;
}
return EINA_FALSE;
}
+#endif
Eina_Bool __stop_by_recording_timeout(void *data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
+ SLOG(LOG_INFO, TAG_STTD, "===== Stop by timeout");
- g_recording_timer = NULL;
+ if (NULL != g_recording_timer) {
+ ecore_timer_del(g_recording_timer);
+ g_recording_timer = NULL;
+ }
int uid = 0;
uid = stt_client_get_current_recognition();
}
}
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return EINA_FALSE;
}
-void __sttd_server_recorder_start(int uid)
+void __sttd_server_recorder_start(void* data)
{
+ intptr_t puid = (intptr_t)data;
+ int uid = (int)puid;
int current_uid = stt_client_get_current_recognition();
if (uid != current_uid) {
return;
}
- /* Notify uid state change */
- sttdc_send_set_state(uid, APP_STATE_RECORDING);
-
- SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+ app_state_e temp_app_state;
+ if (0 != sttd_client_get_state(uid, &temp_app_state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return;
+ }
+ if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
+ /* Notify uid state change */
+ sttdc_send_set_state(uid, APP_STATE_RECORDING);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+ }
}
void __sttd_start_sound_completed_cb(int id, void *user_data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
+ SLOG(LOG_INFO, TAG_STTD, "===== Start sound completed");
- int uid = (int)user_data;
- /* 4. after wav play callback, recorder start */
- __sttd_server_recorder_start(uid);
+ /* After wav play callback, recorder start */
+ ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
- SLOG(LOG_DEBUG, TAG_STTD, "=====");
+ SLOG(LOG_INFO, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
return;
}
-int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid)
+int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential)
{
if (NULL == lang || NULL == recognition_type) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
int ret = 0;
if (false == stt_client_get_app_agreed(uid)) {
bool temp = false;
- ret = sttd_engine_agent_check_app_agreed(uid, appid, &temp);
+ ret = sttd_engine_agent_check_app_agreed(appid, &temp);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
if (false == temp) {
}
/* check if engine use network */
- if (true == sttd_engine_agent_need_network(uid)) {
+ if (true == sttd_engine_agent_need_network()) {
if (false == stt_network_is_connected()) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
return STTD_ERROR_OUT_OF_NETWORK;
}
}
+ if (NULL != g_recording_timer) {
+ ecore_timer_del(g_recording_timer);
+ g_recording_timer = NULL;
+ }
+
+ if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+ ecore_timer_del(g_processing_timer);
+ g_processing_timer = NULL;
+ }
+
char* sound = NULL;
- if (0 != sttd_client_get_start_sound(uid, &sound)) {
+ ret = sttd_client_get_start_sound(uid, &sound);
+ if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
if (0 != stt_client_set_current_recognition(uid)) {
}
/* engine start recognition */
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
+ SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
uid, lang, recognition_type);
if (NULL != sound)
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
/* 1. Set audio session */
ret = sttd_recorder_set_audio_session();
/* 2. Request wav play */
if (NULL != sound) {
int id = 0;
- ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_start_sound_completed_cb, (void*)uid, &id);
- if (WAV_PLAYER_ERROR_NONE != ret) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+ intptr_t puid = (intptr_t)uid;
+ sound_stream_info_h wav_stream_info_h;
+ if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
is_sound_done = true;
+ } else {
+ ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_start_sound_completed_cb, (void*)puid, &id);
+ if (WAV_PLAYER_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+ is_sound_done = true;
+ }
+
+ if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
+ }
}
free(sound);
sound = NULL;
}
/* 3. Create recorder & engine initialize */
- ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, NULL);
+ ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, appid, credential, NULL);
if (0 != ret) {
stt_client_unset_current_recognition();
sttd_recorder_unset_audio_session();
return ret;
}
- if (0 != strcmp(STTP_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
+ if (0 != strcmp(STTE_RECOGNITION_TYPE_FREE_PARTIAL, recognition_type)) {
g_recording_timer = ecore_timer_add(g_recording_timeout, __stop_by_recording_timeout, NULL);
}
g_recording_log_count = 0;
+ app_state_e temp_app_state;
+
if (true == is_sound_done) {
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+ SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
ret = sttd_engine_agent_recognize_start_recorder(uid);
if (0 != ret) {
stt_client_unset_current_recognition();
sttd_recorder_unset_audio_session();
- sttd_engine_agent_recognize_cancel(uid);
- ecore_timer_del(g_recording_timer);
+ sttd_engine_agent_recognize_cancel();
+ if (NULL != g_recording_timer) {
+ ecore_timer_del(g_recording_timer);
+ g_recording_timer = NULL;
+ }
sttd_client_set_state(uid, APP_STATE_READY);
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
- SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+ if (0 != sttd_client_get_state(uid, &temp_app_state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+ if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
+ /* Notify uid state change */
+ sttdc_send_set_state(uid, APP_STATE_RECORDING);
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Start recognition");
return STTD_RESULT_STATE_DONE;
}
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
+ SLOG(LOG_INFO, TAG_STTD, "[Server] Wait sound finish");
return STTD_RESULT_STATE_NOT_DONE;
}
Eina_Bool __time_out_for_processing(void *data)
{
- g_processing_timer = NULL;
+ if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+ ecore_timer_del(g_processing_timer);
+ g_processing_timer = NULL;
+ }
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter __time_out_for_processing");
/* current uid */
int uid = stt_client_get_current_recognition();
if (0 == uid) return EINA_FALSE;
+ SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by timeout for processing");
+
/* Cancel engine */
- int ret = sttd_engine_agent_recognize_cancel(uid);
+ int ret = sttd_engine_agent_recognize_cancel();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
}
- if (0 != sttdc_send_result(uid, STTP_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
+ if (0 != sttdc_send_result(uid, STTE_RESULT_EVENT_FINAL_RESULT, NULL, 0, "Time out not to receive recognition result.")) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send result ");
/* send error msg */
- int reason = (int)STTD_ERROR_TIMED_OUT;
+ int reason = (int)STTD_ERROR_TIMED_OUT;
if (0 != sttdc_send_error_signal(uid, reason, "[ERROR] Fail to send recognition result")) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to send error info ");
}
stt_client_unset_current_recognition();
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End __time_out_for_processing");
+
return EINA_FALSE;
}
-void __sttd_server_engine_stop(int uid)
+void __sttd_server_engine_stop(void* data)
{
+ intptr_t puid = (intptr_t)data;
+ int uid = (int)puid;
/* change uid state */
sttd_client_set_state(uid, APP_STATE_PROCESSING);
}
/* Stop engine */
- ret = sttd_engine_agent_recognize_stop_engine(uid);
+ ret = sttd_engine_agent_recognize_stop_engine();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
return;
void __sttd_stop_sound_completed_cb(int id, void *user_data)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
+ SLOG(LOG_INFO, TAG_STTD, "===== Stop sound completed");
- int uid = (int)user_data;
/* After wav play callback, engine stop */
- __sttd_server_engine_stop(uid);
+ ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
SLOG(LOG_DEBUG, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
g_recording_timer = NULL;
}
+ if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+ ecore_timer_del(g_processing_timer);
+ g_processing_timer = NULL;
+ }
+
char* sound = NULL;
if (0 != sttd_client_get_stop_sound(uid, &sound)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
return STTD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] stop sound path : %s", sound);
int ret;
/* 1. Stop recorder */
- ret = sttd_engine_agent_recognize_stop_recorder(uid);
+ ret = sttd_engine_agent_recognize_stop_recorder();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
- if (0 != sttd_engine_agent_recognize_cancel(uid)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
+ if (0 != sttd_engine_agent_recognize_cancel()) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognize");
}
if (NULL != sound) free(sound);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
/* 2. Request wav play */
if (NULL != sound) {
int id = 0;
- ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_stop_sound_completed_cb, (void*)uid, &id);
- if (WAV_PLAYER_ERROR_NONE != ret) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+ intptr_t puid = (intptr_t)uid;
+ sound_stream_info_h wav_stream_info_h;
+ if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
- }
+ ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_stop_sound_completed_cb, (void*)puid, &id);
+ if (WAV_PLAYER_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
+ }
+ if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
+ }
+ }
free(sound);
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
return STTD_RESULT_STATE_NOT_DONE;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+ SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
/* Unset audio session */
ret = sttd_recorder_unset_audio_session();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
/* Stop engine */
- ret = sttd_engine_agent_recognize_stop_engine(uid);
+ ret = sttd_engine_agent_recognize_stop_engine();
if (0 != ret) {
stt_client_unset_current_recognition();
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
/* change uid state */
sttd_client_set_state(uid, APP_STATE_PROCESSING);
- SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
-
+ /* Notify uid state change */
+ sttdc_send_set_state(uid, APP_STATE_PROCESSING);
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Stop recognition");
+
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
return STTD_RESULT_STATE_DONE;
int sttd_server_cancel(int uid)
{
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter sttd_server_cancel");
+
/* check if uid is valid */
app_state_e state;
if (0 != sttd_client_get_state(uid, &state)) {
return STTD_ERROR_INVALID_PARAMETER;
}
- /* check uid state */
+ /* check uid state */
if (APP_STATE_READY == state) {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
return STTD_ERROR_NONE;
}
if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
ecore_timer_del(g_processing_timer);
g_processing_timer = NULL;
}
int ret = sttd_recorder_unset_audio_session();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
- return STTD_ERROR_OPERATION_FAILED;
- }
+ return ret;
+ }
}
/* change uid state */
sttd_client_set_state(uid, APP_STATE_READY);
+ SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by app's request");
+
/* cancel engine recognition */
- int ret = sttd_engine_agent_recognize_cancel(uid);
+ int ret = sttd_engine_agent_recognize_cancel();
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
+ /* Notify uid state change */
+ sttdc_send_set_state(uid, APP_STATE_READY);
+
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End sttd_server_cancel");
+
return STTD_ERROR_NONE;
}
+
+int sttd_server_start_file(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential,
+ const char* filepath, stte_audio_type_e audio_type, int sample_rate)
+{
+ if (NULL == lang || NULL == recognition_type || NULL == filepath) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ /* check if uid is valid */
+ app_state_e state;
+ if (0 != sttd_client_get_state(uid, &state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ /* check uid state */
+ if (APP_STATE_READY != state) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] sttd_server_start : current state is not ready");
+ return STTD_ERROR_INVALID_STATE;
+ }
+
+ int ret = 0;
+ if (false == stt_client_get_app_agreed(uid)) {
+ bool temp = false;
+ ret = sttd_engine_agent_check_app_agreed(appid, &temp);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get engine available : %d", ret);
+ return ret;
+ }
+
+ if (false == temp) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server] App(%s) NOT confirmed that engine is available", appid);
+ return STTD_ERROR_PERMISSION_DENIED;
+ }
+
+ stt_client_set_app_agreed(uid);
+ }
+
+ /* check if engine use network */
+ if (true == sttd_engine_agent_need_network()) {
+ if (false == stt_network_is_connected()) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Disconnect network. Current engine needs to network connection.");
+ return STTD_ERROR_OUT_OF_NETWORK;
+ }
+ }
+
+ if (0 != stt_client_set_current_recognition(uid)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Current STT is busy because of recording or processing");
+ return STTD_ERROR_RECORDER_BUSY;
+ }
+
+ /* engine start recognition */
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s), appid(%s), file(%s), audio_type(%d), sample_rate(%d)", uid, lang, recognition_type, appid, filepath, audio_type, sample_rate);
+
+ /* 1. Set audio session */
+ ret = sttd_recorder_set_audio_session();
+ if (0 != ret) {
+ stt_client_unset_current_recognition();
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to set session : %d", ret);
+ return ret;
+ }
+
+ /* 2. Start engine to recognize */
+ ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, appid, credential, NULL);
+ if (0 != ret) {
+ stt_client_unset_current_recognition();
+ sttd_recorder_unset_audio_session();
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start engine : result(%d)", ret);
+ return ret;
+ }
+
+ sttd_client_set_state(uid, APP_STATE_RECORDING);
+ sttdc_send_set_state(uid, APP_STATE_RECORDING);
+
+ /* 3. Start to send pcm from file to engine */
+ ret = sttd_engine_agent_recognize_start_file(uid, filepath);
+ if (0 != ret) {
+ stt_client_unset_current_recognition();
+ sttd_recorder_unset_audio_session();
+ sttd_engine_agent_recognize_cancel();
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start file : result(%d)", ret);
+ return ret;
+ }
+
+ /* 4. Stop to send pcm from file */
+ ret = sttd_engine_agent_recognize_stop_file();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop recorder : result(%d)", ret);
+ stt_client_unset_current_recognition();
+ sttd_recorder_unset_audio_session();
+ sttd_engine_agent_recognize_cancel();
+ return ret;
+ }
+
+ /* 5. change & notify uid state */
+ sttd_client_set_state(uid, APP_STATE_PROCESSING);
+ sttdc_send_set_state(uid, APP_STATE_PROCESSING);
+
+ /* 6. Unset audio session */
+ ret = sttd_recorder_unset_audio_session();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
+ stt_client_unset_current_recognition();
+ return ret;
+ }
+
+ /* 7. Stop engine */
+ ret = sttd_engine_agent_recognize_stop_engine();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to stop engine : result(%d)", ret);
+ stt_client_unset_current_recognition();
+ return ret;
+ }
+
+ return STTD_ERROR_NONE;
+}
+
+int sttd_server_cancel_file(int uid)
+{
+ /* check if uid is valid */
+ app_state_e state;
+ if (0 != sttd_client_get_state(uid, &state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ return STTD_ERROR_INVALID_PARAMETER;
+ }
+
+ /* check uid state */
+ if (APP_STATE_READY == state) {
+ SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is ready");
+ return STTD_ERROR_NONE;
+ }
+
+ stt_client_unset_current_recognition();
+
+ if (NULL != g_recording_timer) {
+ ecore_timer_del(g_recording_timer);
+ g_recording_timer = NULL;
+ }
+
+ if (NULL != g_processing_timer) {
+ SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+ ecore_timer_del(g_processing_timer);
+ g_processing_timer = NULL;
+ }
+
+ if (APP_STATE_RECORDING == state) {
+ /* Unset audio session */
+ int ret = sttd_recorder_unset_audio_session();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to unset session : %d", ret);
+ return ret;
+ }
+ }
+
+ /* change uid state */
+ sttd_client_set_state(uid, APP_STATE_READY);
+
+ /* cancel engine recognition */
+ int ret = sttd_engine_agent_recognize_cancel();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel : result(%d)", ret);
+ return ret;
+ }
+
+ /* Notify uid state change */
+ sttdc_send_set_state(uid, APP_STATE_READY);
+
+ return STTD_ERROR_NONE;
+}
+
projects / platform / core / uifw / stt.git / blobdiff