Remove return value for sending error

[platform/core/uifw/stt.git] / server / sttd_engine_agent.c

diff --git a/server/sttd_engine_agent.c b/server/sttd_engine_agent.c
index 3bf7095..523f0ab 100644 (file)
--- a/server/sttd_engine_agent.c
+++ b/server/sttd_engine_agent.c
@@ -603,7 +603,15 @@ int sttd_engine_agent_get_option_supported(bool* silence)
                return STTD_ERROR_OPERATION_FAILED;
        }
 
+       bool temp = false;
+       if (0 != stt_engine_support_silence(&temp)) {
+               SLOG(LOG_WARN, TAG_STTD, "[WARNING] Fail to get support silence");
+       }
+
        *silence = g_engine_info->support_silence_detection;
+       if (temp != *silence) {
+               SLOG(LOG_WARN, TAG_STTD, "[WARNING] Metadata and Engine spec are different (engine:%d) (meta:%d)", temp, *silence);
+       }
 
        return 0;
 }
@@ -772,7 +780,6 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
        if (NULL != temp)       free(temp);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
-               sttd_recorder_destroy();
                return ret;
        }
 
@@ -837,6 +844,32 @@ int sttd_engine_agent_recognize_start_recorder(int uid)
        return 0;
 }
 
+int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
+{
+       if (NULL == g_engine_info) {
+               SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
+               return STTD_ERROR_INVALID_PARAMETER;
+       }
+
+       if (false == g_engine_info->is_loaded) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
+               return STTD_ERROR_OPERATION_FAILED;
+       }
+
+       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
+
+       int ret;
+       ret = sttd_recorder_start_file(uid, filepath);
+       if (0 != ret) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to start recorder : result(%d)", ret);
+               stt_engine_recognize_cancel();
+               sttd_recorder_stop_file();
+               return ret;
+       }
+
+       return 0;
+}
+
 int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
 {
        if (false == g_agent_init) {
@@ -867,6 +900,41 @@ int sttd_engine_agent_set_recording_data(const void* data, unsigned int length)
        return ret;
 }
 
+int sttd_engine_agent_recognize_stop_file()
+{
+       if (false == g_agent_init) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
+               return STTD_ERROR_OPERATION_FAILED;
+       }
+
+       if (NULL == g_engine_info) {
+               SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
+               return STTD_ERROR_INVALID_PARAMETER;
+       }
+
+       if (false == g_engine_info->is_loaded) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not loaded engine");
+               return STTD_ERROR_OPERATION_FAILED;
+       }
+
+       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
+       int ret;
+       ret = sttd_recorder_stop_file();
+       if (0 != ret) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
+               return ret;
+       }
+
+#ifdef AUDIO_CREATE_ON_START
+       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
+       if (0 != sttd_recorder_destroy())
+               SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
+#endif
+
+       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
+       return 0;
+}
+
 int sttd_engine_agent_recognize_stop_recorder()
 {
        if (false == g_agent_init) {
@@ -1080,6 +1148,8 @@ static void __recorder_destroy_by_error_result(void *data)
 int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
                 const char* msg, void* time_info, void *user_data)
 {
+       int ret = -1;
+
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Result Callback : Not Initialized");
                return STTD_ERROR_OPERATION_FAILED;
@@ -1089,7 +1159,7 @@ int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, c
 
        if (NULL != time_info) {
                /* Get the time info */
-               int ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
+               ret = stt_engine_foreach_result_time(time_info, __result_time_cb, NULL);
                if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get time info : %d", ret);
                        return ret;
@@ -1098,7 +1168,7 @@ int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, c
 
        SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================");
 
-       g_result_cb(event, type, result, result_count, msg, user_data);
+       ret = g_result_cb(event, type, result, result_count, msg, user_data);
 
 #ifdef AUDIO_CREATE_ON_START
        if (event == STTE_RESULT_EVENT_ERROR) {
@@ -1106,7 +1176,7 @@ int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, c
        }
 #endif
 
-       return STTD_ERROR_NONE;
+       return ret;
 }
 
 int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
@@ -1114,8 +1184,13 @@ int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
        /* check uid */
        int uid = stt_client_get_current_recognition();
 
-       char* err_msg = strdup(msg);
-       int ret = STTE_ERROR_NONE;
+       char* err_msg = NULL;
+       int ret = STTD_ERROR_NONE;
+
+
+       if (NULL != msg) {
+               err_msg = strdup(msg);
+       }
 
        ret = sttdc_send_error_signal(uid, error, err_msg);
        if (0 != ret) {
@@ -1127,20 +1202,21 @@ int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
                err_msg = NULL;
        }
 
-       g_error_cb(error, msg);
+       ret = g_error_cb(error, msg);
 
        return ret;
 }
 
 int sttd_engine_agent_send_speech_status(stte_speech_status_e status, void* user_data)
 {
+       int ret = STTD_ERROR_NONE;
        if (false == g_agent_init) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Silence Callback : Not Initialized");
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       g_speech_status_cb(status, user_data);
-       return STTD_ERROR_NONE;
+       ret = g_speech_status_cb(status, user_data);
+       return ret;
 }
 
 bool __result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data)