Fix error return value properly

Change-Id: Icca72132fc9a77128a154c5ac475d64079eba6db
Signed-off-by: Wonnam Jang <wn.jang@samsung.com>

diff --git a/client/stt_dbus.c b/client/stt_dbus.c
index e6a77ec..754bd3e 100644 (file)
--- a/client/stt_dbus.c
+++ b/client/stt_dbus.c
@@ -455,6 +455,12 @@ int stt_dbus_request_hello()
 
                        SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
                } else {
+                       if (dbus_error_is_set(&err)) {
+                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
+                               dbus_error_free(&err);
+                       }
+
+                       SLOG(LOG_ERROR, TAG_STTC, "STT_ERROR_TIME_OUT");
                        result = STT_ERROR_TIMED_OUT;
                }
        } else {
@@ -1216,9 +1222,9 @@ int stt_dbus_request_start(int uid, const char* lang, const char* type, int sile
        /* create a signal & check for errors */
        msg = dbus_message_new_method_call(
                STT_SERVER_SERVICE_NAME,
-               STT_SERVER_SERVICE_OBJECT_PATH, 
-               STT_SERVER_SERVICE_INTERFACE,   
-               STT_METHOD_START);              
+               STT_SERVER_SERVICE_OBJECT_PATH,
+               STT_SERVER_SERVICE_INTERFACE,
+               STT_METHOD_START);
 
        if (NULL == msg) {
                SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
@@ -1227,6 +1233,9 @@ int stt_dbus_request_start(int uid, const char* lang, const char* type, int sile
                SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
        }
 
+       if (NULL == credential)
+               credential = strdup("NULL");
+
        dbus_message_append_args(msg,
                DBUS_TYPE_INT32, &uid,
                DBUS_TYPE_STRING, &lang,

diff --git a/common/stt_engine.c b/common/stt_engine.c
index 8fce3c9..c2a8e16 100644 (file)
--- a/common/stt_engine.c
+++ b/common/stt_engine.c
@@ -176,7 +176,7 @@ int stt_engine_load(int engine_id, const char* filepath)
                free(engine->pdfuncs);
                free(engine->engine_path);
                free(engine);
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        /* engine error check */
@@ -263,7 +263,7 @@ int stt_engine_initialize(int engine_id, sttpe_result_cb result_cb, sttpe_silenc
        ret = engine->pefuncs->initialize(result_cb, silence_cb);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -322,7 +322,7 @@ int stt_engine_get_supported_langs(int engine_id, GSList** lang_list)
        ret = engine->pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -369,7 +369,7 @@ int stt_engine_get_first_language(int engine_id, char** language)
        ret = engine->pefuncs->foreach_langs(__supported_language_cb, &lang_list);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        GSList *iter = NULL;
@@ -494,7 +494,7 @@ int stt_engine_get_audio_type(int engine_id, sttp_audio_type_e* types, int* rate
        ret = engine->pefuncs->get_audio_format(types, rate, channels);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -516,7 +516,7 @@ int stt_engine_set_silence_detection(int engine_id, bool value)
                return STTP_ERROR_NOT_SUPPORTED_FEATURE;
        } else if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set silence detection : %d", ret);
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -541,7 +541,7 @@ int stt_engine_check_app_agreed(int engine_id, const char* appid, bool* value)
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
                *value = false;
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -566,7 +566,7 @@ int stt_engine_recognize_start(int engine_id, const char* lang, const char* reco
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -589,7 +589,7 @@ int stt_engine_set_recording_data(int engine_id, const void* data, unsigned int
        int ret = engine->pefuncs->set_recording(data, length);
        if (0 != ret) {
                SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -607,7 +607,7 @@ int stt_engine_recognize_stop(int engine_id)
        int ret = engine->pefuncs->stop();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -625,7 +625,7 @@ int stt_engine_recognize_cancel(int engine_id)
        int ret = engine->pefuncs->cancel();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -643,7 +643,7 @@ int stt_engine_foreach_result_time(int engine_id, void* time_info, sttpe_result_
        int ret = engine->pefuncs->foreach_result_time(time_info, callback, user_data);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -672,7 +672,7 @@ int stt_engine_recognize_start_file(int engine_id, const char* lang, const char*
        int ret = engine->pefuncs->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -695,7 +695,7 @@ int stt_engine_recognize_cancel_file(int engine_id)
        int ret = engine->pefuncs->cancel_file();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
-               return STTP_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;

diff --git a/include/stt.h b/include/stt.h
index 219ddda..0a83898 100644 (file)
--- a/include/stt.h
+++ b/include/stt.h
@@ -38,20 +38,21 @@ extern "C"
  * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
 */
 typedef enum {
-       STT_ERROR_NONE                  = TIZEN_ERROR_NONE,             /**< Successful */
-       STT_ERROR_OUT_OF_MEMORY         = TIZEN_ERROR_OUT_OF_MEMORY,    /**< Out of Memory */
-       STT_ERROR_IO_ERROR              = TIZEN_ERROR_IO_ERROR,         /**< I/O error */
-       STT_ERROR_INVALID_PARAMETER     = TIZEN_ERROR_INVALID_PARAMETER,/**< Invalid parameter */
-       STT_ERROR_TIMED_OUT             = TIZEN_ERROR_TIMED_OUT,        /**< No answer from the daemon */
-       STT_ERROR_RECORDER_BUSY         = TIZEN_ERROR_RESOURCE_BUSY,    /**< Device or resource busy */
-       STT_ERROR_OUT_OF_NETWORK        = TIZEN_ERROR_NETWORK_DOWN,     /**< Network is down */
-       STT_ERROR_PERMISSION_DENIED     = TIZEN_ERROR_PERMISSION_DENIED,/**< Permission denied */
-       STT_ERROR_NOT_SUPPORTED         = TIZEN_ERROR_NOT_SUPPORTED,    /**< STT NOT supported */
-       STT_ERROR_INVALID_STATE         = TIZEN_ERROR_STT | 0x01,       /**< Invalid state */
-       STT_ERROR_INVALID_LANGUAGE      = TIZEN_ERROR_STT | 0x02,       /**< Invalid language */
-       STT_ERROR_ENGINE_NOT_FOUND      = TIZEN_ERROR_STT | 0x03,       /**< No available engine  */
-       STT_ERROR_OPERATION_FAILED      = TIZEN_ERROR_STT | 0x04,       /**< Operation failed  */
-       STT_ERROR_NOT_SUPPORTED_FEATURE = TIZEN_ERROR_STT | 0x05        /**< Not supported feature of current engine */
+       STT_ERROR_NONE                          = TIZEN_ERROR_NONE,             /**< Successful */
+       STT_ERROR_OUT_OF_MEMORY                 = TIZEN_ERROR_OUT_OF_MEMORY,    /**< Out of Memory */
+       STT_ERROR_IO_ERROR                      = TIZEN_ERROR_IO_ERROR,         /**< I/O error */
+       STT_ERROR_INVALID_PARAMETER             = TIZEN_ERROR_INVALID_PARAMETER,/**< Invalid parameter */
+       STT_ERROR_TIMED_OUT                     = TIZEN_ERROR_TIMED_OUT,        /**< No answer from the daemon */
+       STT_ERROR_RECORDER_BUSY                 = TIZEN_ERROR_RESOURCE_BUSY,    /**< Device or resource busy */
+       STT_ERROR_OUT_OF_NETWORK                = TIZEN_ERROR_NETWORK_DOWN,     /**< Network is down */
+       STT_ERROR_PERMISSION_DENIED             = TIZEN_ERROR_PERMISSION_DENIED,/**< Permission denied */
+       STT_ERROR_NOT_SUPPORTED                 = TIZEN_ERROR_NOT_SUPPORTED,    /**< STT NOT supported */
+       STT_ERROR_INVALID_STATE                 = TIZEN_ERROR_STT | 0x01,       /**< Invalid state */
+       STT_ERROR_INVALID_LANGUAGE              = TIZEN_ERROR_STT | 0x02,       /**< Invalid language */
+       STT_ERROR_ENGINE_NOT_FOUND              = TIZEN_ERROR_STT | 0x03,       /**< No available engine  */
+       STT_ERROR_OPERATION_FAILED              = TIZEN_ERROR_STT | 0x04,       /**< Operation failed  */
+       STT_ERROR_NOT_SUPPORTED_FEATURE         = TIZEN_ERROR_STT | 0x05,       /**< Not supported feature of current engine */
+       STT_ERROR_NO_SPEECH                     = TIZEN_ERROR_STT | 0x06        /**< No speech while recording */
 } stt_error_e;
 
 /**

diff --git a/server/sttd_client_data.c b/server/sttd_client_data.c
index 6331a08..8da0df2 100644 (file)
--- a/server/sttd_client_data.c
+++ b/server/sttd_client_data.c
@@ -103,7 +103,7 @@ int sttd_client_add(int pid, int uid)
 
        if (NULL == g_client_list) {
                SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Fail to add new client");
-               return -1;
+               return STTD_ERROR_OPERATION_FAILED;
        }
 
 #ifdef CLIENT_DATA_DEBUG

diff --git a/server/sttd_dbus.c b/server/sttd_dbus.c
index f6aa112..86dd165 100644 (file)
--- a/server/sttd_dbus.c
+++ b/server/sttd_dbus.c
@@ -512,5 +512,7 @@ int sttd_dbus_close_connection()
        g_conn_listener = NULL;
        g_conn_sender = NULL;
 
+       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Close dbus connection");
+
        return 0;
 }

diff --git a/server/sttd_engine_agent.c b/server/sttd_engine_agent.c
index 07ac6fd..74deec6 100644 (file)
--- a/server/sttd_engine_agent.c
+++ b/server/sttd_engine_agent.c
@@ -246,7 +246,7 @@ int __internal_get_engine_info(const char* filepath, sttengine_info_s** info)
        handle = dlopen(filepath, RTLD_LAZY);
 
        if (!handle) {
-               SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine : %s", filepath);
+               SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Invalid engine : %s, error(%s)", filepath, (NULL == dlerror()) ? "NULL" : dlerror());
                return STTD_ERROR_ENGINE_NOT_FOUND;
        }
 
@@ -655,13 +655,13 @@ int sttd_engine_agent_load_current_engine(int uid, const char* engine_uuid)
        ret = stt_engine_load(engine->engine_id, engine->engine_path);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to load engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        ret = stt_engine_initialize(engine->engine_id, __result_cb, __detect_silence_cb);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        ret = stt_engine_set_silence_detection(engine->engine_id, g_default_silence_detected);
@@ -682,7 +682,7 @@ int sttd_engine_agent_load_current_engine(int uid, const char* engine_uuid)
                free(tmp_lang);
        } else {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get first language from engine : %d %s", engine->engine_id, engine->engine_name);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
 #ifndef AUDIO_CREATE_ON_START
@@ -694,13 +694,13 @@ int sttd_engine_agent_load_current_engine(int uid, const char* engine_uuid)
        ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 #endif
 
@@ -875,7 +875,7 @@ int sttd_engine_agent_supported_langs(int uid, GSList** lang_list)
        int ret = stt_engine_get_supported_langs(engine->engine_id, lang_list);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] get language list error(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -908,9 +908,11 @@ int sttd_engine_agent_get_default_lang(int uid, char** lang)
 
        /* get default language */
        bool is_valid = false;
-       if (0 != stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid)) {
+       int ret = -1;
+       ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid);
+       if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        if (true == is_valid) {
@@ -982,7 +984,7 @@ int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
        ret = stt_engine_need_app_credential(engine->engine_id, &temp);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        *credential = temp;
@@ -1020,7 +1022,7 @@ int sttd_engine_agent_is_recognition_type_supported(int uid, const char* type, b
        ret = stt_engine_support_recognition_type(engine->engine_id, type, &temp);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get to support recognition type : %d", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        *support = temp;
@@ -1101,9 +1103,10 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
        char* temp = NULL;
        if (0 == strncmp(lang, "default", strlen("default"))) {
                bool is_valid = false;
-               if (0 != stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid)) {
+               ret = stt_engine_is_valid_language(engine->engine_id, g_default_language, &is_valid);
+               if (0 != ret) {
                        SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to check valid language");
-                       return STTD_ERROR_OPERATION_FAILED;
+                       return ret;
                }
 
                if (true == is_valid) {
@@ -1124,7 +1127,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Recognition start error(%d)", ret);
                sttd_recorder_destroy(engine->engine_id);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
 #ifdef AUDIO_CREATE_ON_START
@@ -1136,7 +1139,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
        ret = stt_engine_get_audio_type(engine->engine_id, &atype, &rate, &channels);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to get audio type : %d %s", engine->engine_id, engine->engine_name);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder");
@@ -1144,7 +1147,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
        ret = sttd_recorder_create(engine->engine_id, uid, atype, channels, rate);
        if (0 != ret) {
                SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to create recorder : %d %s", engine->engine_id, engine->engine_name);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 #endif
 
@@ -1224,7 +1227,7 @@ int sttd_engine_agent_set_recording_data(int uid, const void* data, unsigned int
        int ret = stt_engine_set_recording_data(engine->engine_id, data, length);
        if (0 != ret) {
                SLOG(LOG_WARN, TAG_STTD, "[Engine Agent WARNING] set recording error(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        return 0;
@@ -1255,7 +1258,7 @@ int sttd_engine_agent_recognize_stop_recorder(int uid)
        ret = sttd_recorder_stop(engine->engine_id);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
 #ifdef AUDIO_CREATE_ON_START
@@ -1294,7 +1297,7 @@ int sttd_engine_agent_recognize_stop_engine(int uid)
        ret = stt_engine_recognize_stop(engine->engine_id);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] stop recognition error(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine");
@@ -1328,7 +1331,7 @@ int sttd_engine_agent_recognize_cancel(int uid)
        ret = stt_engine_recognize_cancel(engine->engine_id);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
@@ -1336,7 +1339,7 @@ int sttd_engine_agent_recognize_cancel(int uid)
        ret = sttd_recorder_stop(engine->engine_id);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Fail to stop recorder : result(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
 #ifdef AUDIO_CREATE_ON_START
@@ -1465,7 +1468,7 @@ int sttd_engine_agent_check_app_agreed(int uid, const char* appid, bool* result)
        ret = stt_engine_check_app_agreed(engine->engine_id, appid, result);
        if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] cancel recognition error(%d)", ret);
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
 
@@ -1568,4 +1571,4 @@ int __log_enginelist()
        }
 
        return 0;
-}
\ No newline at end of file
+}

diff --git a/server/sttd_main.c b/server/sttd_main.c
index a1ac2f0..7fd2cd2 100644 (file)
--- a/server/sttd_main.c
+++ b/server/sttd_main.c
@@ -66,6 +66,8 @@ int main(int argc, char** argv)
                ecore_timer_del(g_check_client_timer);
        }
 
+       sttd_dbus_close_connection();
+
        stt_network_finalize();
 
        sttd_finalize();

diff --git a/server/sttd_main.h b/server/sttd_main.h
old mode 100755 (executable)
new mode 100644 (file)
index 0b907ef..b75ade7
--- a/server/sttd_main.h
+++ b/server/sttd_main.h
@@ -52,7 +52,8 @@ typedef enum {
        STTD_ERROR_INVALID_LANGUAGE             = TIZEN_ERROR_STT | 0x02,       /**< Invalid language */
        STTD_ERROR_ENGINE_NOT_FOUND             = TIZEN_ERROR_STT | 0x03,       /**< No available engine  */    
        STTD_ERROR_OPERATION_FAILED             = TIZEN_ERROR_STT | 0x04,       /**< Operation failed  */
-       STTD_ERROR_NOT_SUPPORTED_FEATURE        = TIZEN_ERROR_STT | 0x05        /**< Not supported feature of current engine */
+       STTD_ERROR_NOT_SUPPORTED_FEATURE        = TIZEN_ERROR_STT | 0x05,       /**< Not supported feature of current engine */
+       STTD_ERROR_NO_SPEECH                    = TIZEN_ERROR_STT | 0x06        /**< No speech while recording */
 } stt_error_e;
 
 typedef enum {

diff --git a/server/sttd_server.c b/server/sttd_server.c
index cdf7afc..b201cba 100644 (file)
--- a/server/sttd_server.c
+++ b/server/sttd_server.c
@@ -335,6 +335,9 @@ void __server_silence_dectection_callback(sttp_silence_type_e type, void *user_p
                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);
+                       if (0 != sttdc_send_error_signal(uid, STTP_ERROR_NO_SPEECH, "No speech while recording")) {
+                               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] No speech while recording");
+                       }
                } else if (STTP_SILENCE_TYPE_END_OF_SPEECH_DETECTED == type) {
                        SLOG(LOG_DEBUG, TAG_STTD, "Silence Detection type - End of Speech");
                        ecore_main_loop_thread_safe_call_async(__stop_by_silence, NULL);
@@ -441,6 +444,7 @@ int sttd_initialize()
        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 */
@@ -615,6 +619,8 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
                }
        }
 
+       int ret = STTD_ERROR_NONE;
+
        /* check if uid is valid */
        app_state_e state;
        if (0 == sttd_client_get_state(uid, &state)) {
@@ -623,25 +629,29 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
        }
 
        /* load engine */
-       if (0 != sttd_engine_agent_load_current_engine(uid, NULL)) {
+       ret = sttd_engine_agent_load_current_engine(uid, NULL);
+       if (0 != ret) {
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to load default engine");
-               return STTD_ERROR_OPERATION_FAILED;
+               return ret;
        }
 
-       if (0 != sttd_engine_agent_get_option_supported(uid, silence)) {
+       ret = sttd_engine_agent_get_option_supported(uid, 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;
@@ -696,7 +706,7 @@ int sttd_server_finalize(int uid)
 
        /* 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);
        }
 
@@ -722,7 +732,7 @@ int sttd_server_get_supported_engines(int uid, GSList** engine_list)
        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;
@@ -747,18 +757,18 @@ int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence
        ret = sttd_engine_agent_load_current_engine(uid, engine_id);
        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);
        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;
@@ -783,7 +793,7 @@ int sttd_server_get_current_engine(int uid, char** engine_id)
        ret = sttd_engine_agent_get_current_engine(uid, 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;
@@ -810,7 +820,7 @@ int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
        ret = sttd_engine_agent_check_app_agreed(uid, 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) {
@@ -837,7 +847,7 @@ int sttd_server_get_supported_languages(int uid, GSList** lang_list)
        int ret = sttd_engine_agent_supported_langs(uid, 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");
@@ -863,7 +873,7 @@ int sttd_server_get_current_langauage(int uid, char** current_lang)
        int ret = sttd_engine_agent_get_default_lang(uid, 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");
@@ -889,7 +899,7 @@ int sttd_server_is_recognition_type_supported(int uid, const char* type, int* su
        int ret = sttd_engine_agent_is_recognition_type_supported(uid, 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;
@@ -911,7 +921,7 @@ int sttd_server_set_start_sound(int uid, const char* file)
        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;
@@ -929,7 +939,7 @@ int sttd_server_set_stop_sound(int uid, const char* file)
        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;
@@ -1053,7 +1063,7 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
                ret = sttd_engine_agent_check_app_agreed(uid, 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) {
@@ -1073,9 +1083,10 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
        }
 
        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)) {
@@ -1147,7 +1158,7 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
                        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 */
@@ -1270,7 +1281,7 @@ int sttd_server_stop(int uid)
                        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 */
@@ -1296,7 +1307,7 @@ int sttd_server_stop(int uid)
                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 */
@@ -1304,7 +1315,7 @@ int sttd_server_stop(int uid)
                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 */
@@ -1355,7 +1366,7 @@ int sttd_server_cancel(int uid)
                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;
                }
        }
 
@@ -1366,7 +1377,7 @@ int sttd_server_cancel(int uid)
        int ret = sttd_engine_agent_recognize_cancel(uid);
        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 */

diff --git a/server/sttp.h b/server/sttp.h
index 9d9b0c1..c20a310 100644 (file)
--- a/server/sttp.h
+++ b/server/sttp.h
@@ -43,7 +43,8 @@ typedef enum {
        STTP_ERROR_INVALID_LANGUAGE             = TIZEN_ERROR_STT | 0x02,       /**< Invalid language */
        STTP_ERROR_ENGINE_NOT_FOUND             = TIZEN_ERROR_STT | 0x03,       /**< No available engine  */
        STTP_ERROR_OPERATION_FAILED             = TIZEN_ERROR_STT | 0x04,       /**< Operation failed  */
-       STTP_ERROR_NOT_SUPPORTED_FEATURE        = TIZEN_ERROR_STT | 0x05        /**< Not supported feature of current engine */
+       STTP_ERROR_NOT_SUPPORTED_FEATURE        = TIZEN_ERROR_STT | 0x05,       /**< Not supported feature of current engine */
+       STTP_ERROR_NO_SPEECH                    = TIZEN_ERROR_STT | 0x06        /**< No speech while recording */
 }sttp_error_e;
 
 /**