Extract and simplify codes to check precondition

Change-Id: Id468feec452fc7a8883585258cb8d709a6706ec0

diff --git a/client/stt.c b/client/stt.c
index d6fbafb..f612122 100644 (file)
--- a/client/stt.c
+++ b/client/stt.c
@@ -34,6 +34,7 @@
 #include "stt_config_mgr.h"
 #include "stt_internal.h"
 #include "stt_main.h"
+#include "stt_dlog.h"
 
 
 static void __stt_notify_state_changed(void *data);
@@ -363,19 +364,13 @@ void __stt_config_engine_changed_cb(const char* engine_id, const char* setting,
 
 static int __stt_check_handle(stt_h stt, stt_client_s** client)
 {
-       if (NULL == stt) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == stt, STT_ERROR_INVALID_PARAMETER, "[ERROR] Input handle is null");
 
        stt_client_s* temp = NULL;
        temp = stt_client_get(stt);
 
        /* check handle */
-       if (NULL == temp) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == temp, STT_ERROR_INVALID_PARAMETER, "[ERROR] A handle is not available");
        *client = temp;
 
        return STT_ERROR_NONE;
@@ -383,19 +378,11 @@ static int __stt_check_handle(stt_h stt, stt_client_s** client)
 
 int stt_create(stt_h* stt)
 {
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Create STT");
-
-       if (NULL == stt) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == stt, STT_ERROR_INVALID_PARAMETER, "[ERROR] A handle is null");
 
        if (0 == stt_client_get_size()) {
                if (0 != stt_dbus_open_connection()) {
@@ -447,15 +434,9 @@ int stt_create(stt_h* stt)
 int stt_destroy(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Destroy STT");
 
@@ -532,15 +513,9 @@ static bool __stt_config_supported_engine_cb(const char* engine_id, const char*
 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Foreach Supported engine");
 
@@ -576,15 +551,9 @@ int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, v
 int stt_get_engine(stt_h stt, char** engine_id)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Get current engine");
 
@@ -735,15 +704,9 @@ int stt_set_engine(stt_h stt, const char* engine_id)
 int stt_set_credential(stt_h stt, const char* credential)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Set credential");
 
@@ -773,15 +736,9 @@ int stt_set_credential(stt_h stt, const char* credential)
 int stt_set_private_data(stt_h stt, const char* key, const char* data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Set private data");
 
@@ -832,15 +789,9 @@ int stt_set_private_data(stt_h stt, const char* key, const char* data)
 int stt_get_private_data(stt_h stt, const char* key, char** data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Get private data");
 
@@ -894,15 +845,9 @@ int stt_set_server_stt(stt_h stt, const char* key, char* user_data)
        int ret = -1;
        stt_client_s* client = NULL;
 
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Set STT server");
 
@@ -1077,15 +1022,9 @@ static Eina_Bool __stt_connect_daemon(void *data)
 int stt_prepare(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Prepare STT");
 
@@ -1108,15 +1047,9 @@ int stt_prepare(stt_h stt)
 int stt_unprepare(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Unprepare STT");
 
@@ -1198,15 +1131,9 @@ static bool __stt_config_supported_language_cb(const char* engine_id, const char
 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Foreach Supported Language");
 
@@ -1267,15 +1194,9 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac
 int stt_get_default_language(stt_h stt, char** language)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== Get Default Language");
 
@@ -1302,15 +1223,9 @@ int stt_get_default_language(stt_h stt, char** language)
 int stt_get_state(stt_h stt, stt_state_e* state)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
@@ -1335,15 +1250,9 @@ int stt_get_state(stt_h stt, stt_state_e* state)
 int stt_get_error_message(stt_h stt, char** err_msg)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == err_msg) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
@@ -1371,15 +1280,9 @@ int stt_get_error_message(stt_h stt, char** err_msg)
 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == type || NULL == support) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
@@ -1423,15 +1326,9 @@ int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support
 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -1458,15 +1355,9 @@ int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
 int stt_set_start_sound(stt_h stt, const char* filename)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT SET START SOUND");
 
@@ -1517,15 +1408,9 @@ int stt_set_start_sound(stt_h stt, const char* filename)
 int stt_unset_start_sound(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT UNSET START SOUND");
 
@@ -1566,15 +1451,9 @@ int stt_unset_start_sound(stt_h stt)
 int stt_set_stop_sound(stt_h stt, const char* filename)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT SET STOP SOUND");
 
@@ -1625,15 +1504,9 @@ int stt_set_stop_sound(stt_h stt, const char* filename)
 int stt_unset_stop_sound(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT UNSET STOP SOUND");
 
@@ -1674,15 +1547,9 @@ int stt_unset_stop_sound(stt_h stt)
 int stt_start(stt_h stt, const char* language, const char* type)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT START");
 
@@ -1747,15 +1614,9 @@ int stt_start(stt_h stt, const char* language, const char* type)
 int stt_stop(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT STOP");
 
@@ -1795,15 +1656,9 @@ int stt_stop(stt_h stt)
 int stt_cancel(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT CANCEL");
 
@@ -1867,15 +1722,9 @@ int __stt_cb_set_volume(unsigned int uid, float volume)
 int stt_get_recording_volume(stt_h stt, float* volume)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == volume) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
@@ -1922,15 +1771,9 @@ bool __stt_result_time_cb(int index, int event, const char* text, long start_tim
 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
 
@@ -2217,15 +2060,9 @@ int __stt_cb_speech_status(unsigned int uid, int status)
 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (callback == NULL)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2246,15 +2083,9 @@ int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback,
 int stt_unset_recognition_result_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2272,15 +2103,9 @@ int stt_unset_recognition_result_cb(stt_h stt)
 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == callback)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2301,15 +2126,9 @@ int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* use
 int stt_unset_state_changed_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2327,15 +2146,9 @@ int stt_unset_state_changed_cb(stt_h stt)
 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == callback)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2356,15 +2169,9 @@ int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
 int stt_unset_error_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2382,15 +2189,9 @@ int stt_unset_error_cb(stt_h stt)
 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == callback)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2411,15 +2212,9 @@ int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_
 int stt_unset_default_language_changed_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2437,15 +2232,9 @@ int stt_unset_default_language_changed_cb(stt_h stt)
 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == callback)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2466,15 +2255,9 @@ int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* u
 int stt_unset_engine_changed_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2493,15 +2276,9 @@ int stt_unset_engine_changed_cb(stt_h stt)
 int stt_set_speech_status_cb(stt_h stt, stt_speech_status_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (NULL == callback)
                return STT_ERROR_INVALID_PARAMETER;
@@ -2522,15 +2299,9 @@ int stt_set_speech_status_cb(stt_h stt, stt_speech_status_cb callback, void* use
 int stt_unset_speech_status_cb(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        if (STT_STATE_CREATED != client->current_state) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
@@ -2548,15 +2319,9 @@ int stt_unset_speech_status_cb(stt_h stt)
 int stt_start_file(stt_h stt, const char* language, const char* type, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
        if (NULL == filepath) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
                return STT_ERROR_INVALID_PARAMETER;
@@ -2625,15 +2390,9 @@ int stt_start_file(stt_h stt, const char* language, const char* type, const char
 int stt_cancel_file(stt_h stt)
 {
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        SLOG(LOG_INFO, TAG_STTC, "===== STT CANCEL FILE");
 
@@ -2798,15 +2557,9 @@ int stt_change_system_volume(stt_h stt, stt_system_volume_event_e volume_event)
        SLOG(LOG_DEBUG, TAG_STTC, "[STT] Change system volume, volume_event(%d)", volume_event);
 
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        /* check state */
        if (client->current_state != STT_STATE_READY && client->current_state != STT_STATE_CREATED) {
@@ -2872,15 +2625,9 @@ int stt_recover_system_volume(stt_h stt)
        SLOG(LOG_DEBUG, TAG_STTC, "[STT] recover system volume");
 
        stt_client_s* client = NULL;
-       if (0 != __stt_get_feature_enabled()) {
-               return STT_ERROR_NOT_SUPPORTED;
-       }
-       if (0 != __stt_check_privilege()) {
-               return STT_ERROR_PERMISSION_DENIED;
-       }
-       if (0 != __stt_check_handle(stt, &client)) {
-               return STT_ERROR_INVALID_PARAMETER;
-       }
+       RETV_IF(0 != __stt_get_feature_enabled(), STT_ERROR_NOT_SUPPORTED);
+       RETV_IF(0 != __stt_check_privilege(), STT_ERROR_PERMISSION_DENIED);
+       RETV_IF(0 != __stt_check_handle(stt, &client), STT_ERROR_INVALID_PARAMETER);
 
        /* check state */
        if (client->current_state != STT_STATE_READY && client->current_state != STT_STATE_CREATED) {

diff --git a/client/stt_main.h b/client/stt_main.h
index e38cca8..bda3a2a 100644 (file)
--- a/client/stt_main.h
+++ b/client/stt_main.h
@@ -32,6 +32,7 @@ extern "C" {
 #endif
 
 #define TAG_STTC "sttc"
+#define LOG_TAG_STT "sttc"
 
 /**
 * @brief A structure of handle for identification

diff --git a/common/stt_dlog.h b/common/stt_dlog.h
new file mode 100644 (file)
index 0000000..8ece22f
--- /dev/null
+++ b/common/stt_dlog.h
@@ -0,0 +1,69 @@
+/*
+*  Copyright (c) 2022 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
+*  http://www.apache.org/licenses/LICENSE-2.0
+*  Unless required by applicable law or agreed to in writing, software
+*  distributed under the License is distributed on an "AS IS" BASIS,
+*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*  See the License for the specific language governing permissions and
+*  limitations under the License.
+*/
+
+#ifndef __STT_DLOG_H__
+#define __STT_DLOG_H__
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG LOG_TAG_STT
+
+#define COLOR_RED       "\033[0;31m"
+#define COLOR_GREEN     "\033[0;32m"
+#define COLOR_BROWN     "\033[0;33m"
+#define COLOR_BLUE      "\033[0;34m"
+#define COLOR_PURPLE    "\033[0;35m"
+#define COLOR_CYAN      "\033[0;36m"
+#define COLOR_LIGHTBLUE "\033[0;37m"
+#define COLOR_END       "\033[0;m"
+
+#define PLOG(fmt, args...) LOGD(fmt, ##args)
+#define PINFO(fmt, args...) LOGI(COLOR_PURPLE fmt COLOR_END, ##args)
+#define PWARNING(fmt, args...) LOGW(COLOR_BLUE fmt COLOR_END, ##args)
+#define PERR(fmt, args...) LOGE(COLOR_RED fmt COLOR_END, ##args)
+#define PENTER() LOGD(COLOR_GREEN "BEGIN >>>>" COLOR_END)
+#define PLEAVE() LOGD(COLOR_GREEN "END <<<<" COLOR_END)
+
+#define RET_IF(expr) \
+do { \
+       if (expr) \
+               return; \
+} while (0)
+
+#define RETV_IF(expr, val) \
+do { \
+       if (expr) \
+               return (val); \
+} while (0)
+
+#define RETM_IF(expr, fmt, arg...) \
+do { \
+       if (expr) { \
+               PERR(fmt, ##arg); \
+               return; \
+       } \
+} while (0)
+
+#define RETVM_IF(expr, val, fmt, arg...) \
+do { \
+       if (expr) { \
+               PERR(fmt, ##arg); \
+               return (val); \
+       } \
+} while (0)
+
+#endif /* __STT_DLOG_H__ */

diff --git a/common/stt_engine.c b/common/stt_engine.c
index e55cb70..8419313 100644 (file)
--- a/common/stt_engine.c
+++ b/common/stt_engine.c
@@ -20,7 +20,11 @@
 
 #include "stt_engine.h"
 #include "stt_defs.h"
+#include "stt_dlog.h"
 
+#ifndef LOG_TAG_STT
+#define LOG_TAG_STT TAG_STTE
+#endif
 
 /** Internal data structure **/
 typedef struct {
@@ -79,10 +83,7 @@ static const char* __stt_get_engine_error_code(stte_error_e err)
 /* Register engine id */
 int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
 {
-       if (NULL == callback || NULL == filepath) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == callback || NULL == filepath, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        /* allocation memory */
        if (NULL != g_engine) {
@@ -107,10 +108,7 @@ int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
 /* Unregister engine id */
 int stt_engine_unload()
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
 
        g_engine->callback = NULL;
 
@@ -129,20 +127,9 @@ int stt_engine_unload()
 /* Initialize / Deinitialize */
 int stt_engine_initialize(bool is_from_lib)
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->initialize) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->initialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        int ret;
        ret = __stt_set_engine_from(is_from_lib);
@@ -163,20 +150,9 @@ int stt_engine_initialize(bool is_from_lib)
 
 int stt_engine_deinitialize()
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->deinitialize) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->deinitialize, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to deinitialize");
 
@@ -208,25 +184,10 @@ static bool __supported_language_cb(const char* language, void* user_data)
 /* Get option */
 int stt_engine_get_supported_langs(GSList** lang_list)
 {
-       if (NULL == lang_list) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->foreach_langs) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == lang_list, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->foreach_langs, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        int ret;
        ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
@@ -239,25 +200,10 @@ int stt_engine_get_supported_langs(GSList** lang_list)
 
 int stt_engine_is_valid_language(const char* language, bool *is_valid)
 {
-       if (NULL == language || NULL == is_valid) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->is_valid_lang) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == language || NULL == is_valid, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        int ret = STTE_ERROR_NONE;
        ret = g_engine->callback->is_valid_lang(language, is_valid);
@@ -269,10 +215,7 @@ int stt_engine_is_valid_language(const char* language, bool *is_valid)
 
 int stt_engine_set_private_data(const char* key, const char* data)
 {
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        int ret = STTE_ERROR_NONE;
        if (NULL != g_set_private_data_cb) {
@@ -287,10 +230,7 @@ int stt_engine_set_private_data(const char* key, const char* data)
 
 int stt_engine_get_private_data(const char* key, char** data)
 {
-       if (NULL == key || NULL == data) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == key || NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        int ret = STTE_ERROR_NONE;
        char* temp = NULL;
@@ -314,25 +254,10 @@ int stt_engine_get_private_data(const char* key, char** data)
 
 int stt_engine_get_first_language(char** language)
 {
-       if (NULL == language) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == language, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        GSList* lang_list = NULL;
        int ret;
@@ -382,28 +307,13 @@ int stt_engine_get_first_language(char** language)
 
 int stt_engine_support_silence(bool* support)
 {
-       if (NULL == support) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == support, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->support_silence, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support silence");
 
-       if (NULL == g_engine->callback->support_silence) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
        bool result;
        result = g_engine->callback->support_silence();
        *support = result;
@@ -413,28 +323,13 @@ int stt_engine_support_silence(bool* support)
 
 int stt_engine_need_app_credential(bool* need)
 {
-       if (NULL == need) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == need, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->need_app_credential, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to need app credential");
 
-       if (NULL == g_engine->callback->need_app_credential) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
        bool result;
        result = g_engine->callback->need_app_credential();
        *need = result;
@@ -444,25 +339,10 @@ int stt_engine_need_app_credential(bool* need)
 
 int stt_engine_support_recognition_type(const char* type, bool* support)
 {
-       if (NULL == type || NULL == support) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->support_recognition_type) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR} Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == type || NULL == support, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->support_recognition_type, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support recognition type, type(%s)", type);
 
@@ -476,25 +356,10 @@ int stt_engine_support_recognition_type(const char* type, bool* support)
 
 int stt_engine_get_audio_format(stte_audio_type_e* types, int* rate, int* channels)
 {
-       if (NULL == types || NULL == rate || NULL == channels) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->get_audio_format) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == types || NULL == rate || NULL == channels, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->get_audio_format, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to get audio format");
 
@@ -510,20 +375,9 @@ int stt_engine_get_audio_format(stte_audio_type_e* types, int* rate, int* channe
 /* Set option */
 int stt_engine_set_silence_detection(bool value)
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->set_silence_detection) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->set_silence_detection, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to set silence detection(%d)", value);
 
@@ -538,20 +392,9 @@ int stt_engine_set_silence_detection(bool value)
 
 int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
 {
-       if (NULL == is_agreed) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == is_agreed, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        if (NULL == g_engine->callback->check_app_agreed) {
                SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Not support app agreement. All app is available");
@@ -573,25 +416,10 @@ int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
 /* Recognition */
 int stt_engine_recognize_start(const char* lang, const char* recognition_type, const char* appid, const char* credential, void* user_param)
 {
-       if (NULL == lang || NULL == recognition_type) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->start) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == lang || NULL == recognition_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->start, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to start, lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
 
@@ -607,25 +435,10 @@ int stt_engine_recognize_start(const char* lang, const char* recognition_type, c
 
 int stt_engine_set_recording_data(const void* data, unsigned int length)
 {
-       if (NULL == data) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->set_recording) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == data, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->set_recording, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        int ret = g_engine->callback->set_recording(data, length);
        if (0 != ret) {
@@ -637,20 +450,9 @@ int stt_engine_set_recording_data(const void* data, unsigned int length)
 
 int stt_engine_recognize_stop()
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->stop) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->stop, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to stop");
 
@@ -664,20 +466,9 @@ int stt_engine_recognize_stop()
 
 int stt_engine_recognize_cancel()
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->cancel) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->cancel, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to cancel");
 
@@ -691,20 +482,9 @@ int stt_engine_recognize_cancel()
 
 int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback, void* user_data)
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback->foreach_result_time) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
+       RETVM_IF(NULL == g_engine->callback->foreach_result_time, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
        int ret = g_engine->callback->foreach_result_time(time_info, callback, user_data);
        if (0 != ret) {
@@ -717,20 +497,9 @@ int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback
 int stt_engine_recognize_start_file(const char* lang, const char* recognition_type,
                                     const char* filepath, stte_audio_type_e audio_type, int sample_rate, void* user_param)
 {
-       if (NULL == filepath || NULL == lang || NULL == recognition_type) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
-
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == filepath || NULL == lang || NULL == recognition_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
 #ifdef __UNUSED_CODES__
        if (NULL == g_engine->callback->start_file) {
@@ -748,15 +517,8 @@ int stt_engine_recognize_start_file(const char* lang, const char* recognition_ty
 
 int stt_engine_recognize_cancel_file()
 {
-       if (NULL == g_engine) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
-
-       if (NULL == g_engine->callback) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
-               return STTE_ERROR_OPERATION_FAILED;
-       }
+       RETVM_IF(NULL == g_engine, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] No engine");
+       RETVM_IF(NULL == g_engine->callback, STTE_ERROR_OPERATION_FAILED, "[Engine ERROR] Invalid engine");
 
 #ifdef __UNUSED_CODES__
        if (NULL == g_engine->callback->cancel_file) {
@@ -774,10 +536,7 @@ int stt_engine_recognize_cancel_file()
 
 int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* user_data)
 {
-       if (NULL == result_cb) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == result_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        g_result_cb = result_cb;
 
@@ -786,10 +545,7 @@ int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* u
 
 int stt_engine_get_recognition_result_cb(stt_engine_result_cb* result_cb)
 {
-       if (NULL == result_cb) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == result_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        if (false == __stt_get_engine_from()) {
                SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Engine is not loaded from file");
@@ -802,10 +558,7 @@ int stt_engine_get_recognition_result_cb(stt_engine_result_cb* result_cb)
 
 int stt_engine_set_private_data_set_cb(stte_private_data_set_cb private_data_set_cb, void* user_data)
 {
-       if (NULL == private_data_set_cb) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == private_data_set_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        g_set_private_data_cb = private_data_set_cb;
 
@@ -814,10 +567,7 @@ int stt_engine_set_private_data_set_cb(stte_private_data_set_cb private_data_set
 
 int stt_engine_set_private_data_requested_cb(stte_private_data_requested_cb private_data_requested_cb, void* user_data)
 {
-       if (NULL == private_data_requested_cb) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == private_data_requested_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        g_get_private_data_cb = private_data_requested_cb;
 
@@ -826,10 +576,7 @@ int stt_engine_set_private_data_requested_cb(stte_private_data_requested_cb priv
 
 int stt_engine_set_audio_type(const char* audio_type)
 {
-       if (NULL == audio_type) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == audio_type, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        SLOG(LOG_INFO, TAG_STTE, "[Engine Info] set audio type (%s)", audio_type);
 
@@ -848,10 +595,7 @@ int stt_engine_set_audio_type(const char* audio_type)
 
 int stt_engine_set_audio_type_set_cb(stte_audio_type_cb audio_type_set_cb, void* user_data)
 {
-       if (NULL == audio_type_set_cb) {
-               SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
-               return STTE_ERROR_INVALID_PARAMETER;
-       }
+       RETVM_IF(NULL == audio_type_set_cb, STTE_ERROR_INVALID_PARAMETER, "[Engine ERROR] Invalid Parameter");
 
        g_set_audio_type_cb = audio_type_set_cb;
        g_set_audio_type_user_data = user_data;

diff --git a/server/sttd_main.h b/server/sttd_main.h
index 25a10ce..06ab91b 100644 (file)
--- a/server/sttd_main.h
+++ b/server/sttd_main.h
@@ -34,6 +34,7 @@ extern "C" {
 */
 
 #define TAG_STTD "sttd"
+#define LOG_TAG_STT "sttd"
 
 /* for debug message */
 //#define CLIENT_DATA_DEBUG