/*
-* 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
if (0 != uid) {
/* 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);
}
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_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
return -1;
return;
}
-void __server_recognition_result_callback(sttp_result_event_e event, const char* type,
+void __server_recognition_result_callback(stte_result_event_e event, const char* type,
const char** data, int data_count, const char* msg, void *user_data)
{
// critical section
SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
/* send result to client */
- if (STTP_RESULT_EVENT_FINAL_RESULT == event) {
+ if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
if (APP_STATE_PROCESSING != state) {
SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
}
sttd_client_set_state(uid, APP_STATE_READY);
stt_client_unset_current_recognition();
- } else if (STTP_RESULT_EVENT_PARTIAL_RESULT == event) {
+ } else if (STTE_RESULT_EVENT_PARTIAL_RESULT == event) {
SLOG(LOG_DEBUG, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event, data_count);
sttd_config_time_save();
}
}
- } 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 */
return;
}
-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)
{
pthread_mutex_lock(&sttpe_result_time_mutex);
return true;
}
-void __server_silence_dectection_callback(sttp_silence_type_e type, void *user_param)
+void __server_speech_status_callback(stte_speech_status_e status, void *user_param)
{
- SLOG(LOG_DEBUG, TAG_STTD, "===== Silence Detection Callback");
+ SLOG(LOG_DEBUG, TAG_STTD, "===== Speech status detected Callback");
int uid = stt_client_get_current_recognition();
if (0 != uid) {
return;
}
- if (STTP_SILENCE_TYPE_NO_RECORD_TIMEOUT == type) {
- SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - No Record");
- ecore_main_loop_thread_safe_call_async(__cancel_by_no_record, NULL);
- } else if (STTP_SILENCE_TYPE_END_OF_SPEECH_DETECTED == type) {
- SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - End of Speech");
+ if (STTE_SPEECH_STATUS_BEGINNING_POINT_DETECTED == status) {
+ SLOG(LOG_DEBUG, TAG_STTD, "Begin Speech detected");
+ } 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 {
return;
}
+void __server_error_callback(stte_error_e error, const char* msg)
+{
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] Error Callback is called");
+ return;
+}
+
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) {
* Daemon function
*/
-int sttd_initialize()
+static void __sig_handler(int signo)
+{
+ /* restore signal handler */
+ signal(signo, SIG_DFL);
+
+ /* Send error signal to clients */
+ int* client_list = NULL;
+ int client_count = 0;
+ int i = 0;
+ if (0 != sttd_client_get_list(&client_list, &client_count)) {
+ if (NULL != client_list) {
+ free(client_list);
+ client_list = NULL;
+ }
+ }
+
+ if (NULL != client_list) {
+ for (i = 0; i < client_count; i++) {
+ sttdc_send_error_signal(client_list[i], STTD_ERROR_SERVICE_RESET, "Service Reset");
+ }
+
+ free(client_list);
+ client_list = NULL;
+ }
+
+ /* invoke signal again */
+ raise(signo);
+}
+
+static void __register_sig_handler()
+{
+ signal(SIGSEGV, __sig_handler);
+ signal(SIGABRT, __sig_handler);
+ signal(SIGTERM, __sig_handler);
+ signal(SIGINT, __sig_handler);
+ signal(SIGQUIT, __sig_handler);
+}
+
+int sttd_initialize(stte_request_callback_s *callback)
{
int ret = 0;
+ __register_sig_handler();
+
if (0 != pthread_mutex_init(&sttpe_result_mutex, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to initialize sttpe result mutex.");
}
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");
if (NULL != client_list) {
SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
-
+
__read_proc();
for (i = 0; i < client_count; i++) {
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;
/* 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;
- }
-
- if (0 != 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 get engine options supported");
- return STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
- if (0 != sttd_engine_agent_is_credential_needed(uid, credential)) {
+ 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 STTD_ERROR_OPERATION_FAILED;
+ 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;
}
return STTD_ERROR_NONE;
static Eina_Bool __quit_ecore_loop(void *data)
{
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] Quit");
+
+ stt_network_finalize();
+ sttd_finalize();
ecore_main_loop_quit();
+
+ SLOG(LOG_DEBUG, TAG_STTD, "");
+
return EINA_FALSE;
}
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)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to delete client");
/* unload engine, if ref count of client is 0 */
if (0 == sttd_client_get_ref_count()) {
- sttd_dbus_close_connection();
+// sttd_dbus_close_connection();
ecore_timer_add(0, __quit_ecore_loop, NULL);
}
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 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 STTD_ERROR_OPERATION_FAILED;
+ return ret;
}
return STTD_ERROR_NONE;
}
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;
/* 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) {
}
/* 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);
+ 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_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
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_DEBUG, 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 private data, key(%s), data(%s)", key, *data);
+
+ return STTD_ERROR_NONE;
+}
+
int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support)
{
/* check if uid is valid */
}
bool temp;
- int ret = sttd_engine_agent_is_recognition_type_supported(uid, type, &temp);
+ 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;
int ret = sttd_client_set_start_sound(uid, file);
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) {
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 (APP_STATE_READY == state) {
/* Cancel stt */
- 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 */
- 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;
}
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;
}
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)) {
}
/* 3. Create recorder & engine initialize */
- ret = sttd_engine_agent_recognize_start_engine(uid, lang, recognition_type, silence, credential, 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);
}
stt_client_unset_current_recognition();
sttd_recorder_unset_audio_session();
- sttd_engine_agent_recognize_cancel(uid);
+ sttd_engine_agent_recognize_cancel();
ecore_timer_del(g_recording_timer);
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;
}
/* Notify uid state change */
if (0 == uid) return EINA_FALSE;
/* 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 */
}
/* 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;
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)) {
+ 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 */
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 */
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;
}
}
sttd_client_set_state(uid, APP_STATE_READY);
/* 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 */