Delete processing timer at main thread

[platform/core/uifw/stt.git] / client / stt.c

diff --git a/client/stt.c b/client/stt.c
index df9091c..beb0d18 100644 (file)
--- a/client/stt.c
+++ b/client/stt.c
@@ -51,33 +51,43 @@ static bool g_err_callback_status = false;
 
 const char* stt_tag()
 {
+       //LCOV_EXCL_START
        return "sttc";
+       //LCOV_EXCL_STOP
 }
 
 static int __stt_get_feature_enabled()
 {
        if (0 == g_feature_enabled) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
                return STT_ERROR_NOT_SUPPORTED;
+               //LCOV_EXCL_STOP
        } else if (-1 == g_feature_enabled) {
                bool stt_supported = false;
                bool mic_supported = false;
                if (0 == system_info_get_platform_bool(STT_FEATURE_PATH, &stt_supported)) {
                        if (0 == system_info_get_platform_bool(STT_MIC_FEATURE_PATH, &mic_supported)) {
                                if (false == stt_supported || false == mic_supported) {
+                                       //LCOV_EXCL_START
                                        SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
                                        g_feature_enabled = 0;
                                        return STT_ERROR_NOT_SUPPORTED;
+                                       //LCOV_EXCL_STOP
                                }
 
                                g_feature_enabled = 1;
                        } else {
+                               //LCOV_EXCL_START
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
                                return STT_ERROR_NOT_SUPPORTED;
+                               //LCOV_EXCL_STOP
                        }
                } else {
+                       //LCOV_EXCL_START
                        SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
                        return STT_ERROR_NOT_SUPPORTED;
+                       //LCOV_EXCL_STOP
                }
        }
 
@@ -88,7 +98,7 @@ static int __check_privilege_initialize()
 {
        int ret = cynara_initialize(&p_cynara, NULL);
        if (CYNARA_API_SUCCESS != ret)
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to initialize");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to initialize"); //LCOV_EXCL_LINE
 
        return ret == CYNARA_API_SUCCESS;
 }
@@ -105,8 +115,8 @@ static bool __check_privilege(const char* uid, const char * privilege)
 
        fp = fopen(label_path, "r");
        if (fp != NULL) {
-               if (sizeof(smack_label) != fread(smack_label, 1, sizeof(smack_label), fp))
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread");
+               if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread"); //LCOV_EXCL_LINE
 
                fclose(fp);
        }
@@ -137,16 +147,16 @@ static int __stt_check_privilege()
        char uid[16];
 
        if (0 == g_privilege_allowed) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied"); //LCOV_EXCL_LINE
                return STT_ERROR_PERMISSION_DENIED;
        } else if (-1 == g_privilege_allowed) {
                if (false == __check_privilege_initialize()) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed"); //LCOV_EXCL_LINE
                        return STT_ERROR_PERMISSION_DENIED;
                }
                snprintf(uid, 16, "%d", getuid());
                if (false == __check_privilege(uid, STT_PRIVILEGE_RECORDER)) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied"); //LCOV_EXCL_LINE
                        g_privilege_allowed = 0;
                        __check_privilege_deinitialize();
                        return STT_ERROR_PERMISSION_DENIED;
@@ -163,16 +173,16 @@ static int __stt_check_privilege_for_applaunch()
        char uid[16];
 
        if (0 == g_privilege_applaunch_allowed) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission for applaunch is denied");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission for applaunch is denied"); //LCOV_EXCL_LINE
                return STT_ERROR_PERMISSION_DENIED;
        } else if (-1 == g_privilege_applaunch_allowed) {
                if (false == __check_privilege_initialize()) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed (applaunch)");
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed (applaunch)"); //LCOV_EXCL_LINE
                        return STT_ERROR_PERMISSION_DENIED;
                }
                snprintf(uid, 16, "%d", getuid());
                if (false == __check_privilege(uid, STT_PRIVILEGE_APPLAUNCH)) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied : appmanager.launch");
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied : appmanager.launch"); //LCOV_EXCL_LINE
                        g_privilege_applaunch_allowed = 0;
                        __check_privilege_deinitialize();
                        return STT_ERROR_PERMISSION_DENIED;
@@ -186,6 +196,7 @@ static int __stt_check_privilege_for_applaunch()
 
 static const char* __stt_get_error_code(stt_error_e err)
 {
+       //LCOV_EXCL_START
        switch (err) {
        case STT_ERROR_NONE:                    return "STT_ERROR_NONE";
        case STT_ERROR_OUT_OF_MEMORY:           return "STT_ERROR_OUT_OF_MEMORY";
@@ -205,10 +216,12 @@ static const char* __stt_get_error_code(stt_error_e err)
        default:
                return "Invalid error code";
        }
+       //LCOV_EXCL_STOP
 }
 
 static int __stt_convert_config_error_code(stt_config_error_e code)
 {
+       //LCOV_EXCL_START
        if (code == STT_CONFIG_ERROR_NONE)                      return STT_ERROR_NONE;
        if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY)             return STT_ERROR_OUT_OF_MEMORY;
        if (code == STT_CONFIG_ERROR_IO_ERROR)                  return STT_ERROR_IO_ERROR;
@@ -221,6 +234,7 @@ static int __stt_convert_config_error_code(stt_config_error_e code)
        if (code == STT_CONFIG_ERROR_OPERATION_FAILED)          return STT_ERROR_OPERATION_FAILED;
 
        return code;
+       //LCOV_EXCL_STOP
 }
 
 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
@@ -305,9 +319,10 @@ void __stt_config_engine_changed_cb(const char* engine_id, const char* setting,
 
        if (NULL == client->current_engine_id) {
                if (STT_STATE_RECORDING == client->current_state || STT_STATE_PROCESSING == client->current_state) {
+                       SLOG(LOG_INFO, TAG_STTC, "[INFO] stt cancel is invoked by engine_changed_cb, state(%d)", client->current_state);
                        ret = stt_cancel(stt);
                        if (0 != ret) {
-                               SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] STT client canceling...");
+                               SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] STT client cancelling...");
                        }
 
                        ecore_idler_add(__reconnect_by_engine_changed, (void*)stt);
@@ -361,7 +376,7 @@ int stt_create(stt_h* stt)
                return STT_ERROR_PERMISSION_DENIED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
+       SLOG(LOG_INFO, TAG_STTC, "===== Create STT");
 
        if (NULL == stt) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
@@ -370,19 +385,23 @@ int stt_create(stt_h* stt)
 
        if (0 == stt_client_get_size()) {
                if (0 != stt_dbus_open_connection()) {
+                       //LCOV_EXCL_START
                        SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
                        return STT_ERROR_OPERATION_FAILED;
+                       //LCOV_EXCL_STOP
                }
        }
 
        if (0 != stt_client_new(stt)) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
                return STT_ERROR_OUT_OF_MEMORY;
+               //LCOV_EXCL_STOP
        }
 
        stt_client_s* client = stt_client_get(*stt);
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client"); //LCOV_EXCL_LINE
                stt_client_destroy(*stt);
                return STT_ERROR_OPERATION_FAILED;
        }
@@ -390,7 +409,7 @@ int stt_create(stt_h* stt)
        int ret = stt_config_mgr_initialize(client->uid);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                stt_client_destroy(*stt);
                return ret;
        }
@@ -398,12 +417,12 @@ int stt_create(stt_h* stt)
        ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                stt_client_destroy(*stt);
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
+       SLOG(LOG_INFO, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
 
        SLOG(LOG_DEBUG, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
@@ -424,7 +443,7 @@ int stt_destroy(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
+       SLOG(LOG_INFO, TAG_STTC, "===== Destroy STT");
 
        /* check used callback */
        if (0 != stt_client_get_use_callback(client)) {
@@ -443,7 +462,7 @@ int stt_destroy(stt_h stt)
        case STT_STATE_READY:
                ret = stt_dbus_request_finalize(client->uid);
                if (0 != ret) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                }
        case STT_STATE_CREATED:
                if (NULL != g_connect_timer) {
@@ -461,13 +480,13 @@ int stt_destroy(stt_h stt)
 
        if (0 == stt_client_get_size()) {
                if (0 != stt_dbus_close_connection()) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection"); //LCOV_EXCL_LINE
                }
        }
 
        stt = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return STT_ERROR_NONE;
@@ -480,15 +499,17 @@ bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_
 
        stt_client_s* client = stt_client_get(stt);
        if (NULL == client) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
                return false;
+               //LCOV_EXCL_STOP
        }
 
        /* call callback function */
        if (NULL != client->supported_engine_cb) {
                return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
        } else {
-               SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
+               SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine"); //LCOV_EXCL_LINE
        }
 
        return false;
@@ -507,10 +528,10 @@ int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, v
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
+       SLOG(LOG_INFO, TAG_STTC, "===== Foreach Supported engine");
 
        if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -526,13 +547,13 @@ int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, v
        ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
        }
 
        client->supported_engine_cb = NULL;
        client->supported_engine_user_data = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -551,10 +572,10 @@ int stt_get_engine(stt_h stt, char** engine_id)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
+       SLOG(LOG_INFO, TAG_STTC, "===== Get current engine");
 
        if (NULL == engine_id) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -573,13 +594,13 @@ int stt_get_engine(stt_h stt, char** engine_id)
                ret = stt_config_mgr_get_engine(engine_id);
                ret = __stt_convert_config_error_code(ret);
                if (0 != ret) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                } else {
                        SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -594,29 +615,34 @@ int __stt_set_buxtonkey(const char* engine_id)
 
        int ret = buxton_open(&bux_cli, NULL, NULL);
        if (0 != ret) {
-               SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to open buxton client");
+               SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to open buxton client"); //LCOV_EXCL_LINE
                return STT_ERROR_OPERATION_FAILED;
        }
        SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_open: %d", ret);
        bux_layer = buxton_create_layer("system");
        if (NULL == bux_layer) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
                buxton_close(bux_cli);
                bux_cli = NULL;
                return STT_ERROR_OPERATION_FAILED;
+               //LCOV_EXCL_STOP
        }
        bux_val = buxton_value_create_string(engine_id);
        if (NULL == bux_val) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
                buxton_free_layer(bux_layer);
                buxton_close(bux_cli);
                bux_layer = NULL;
                bux_cli = NULL;
                return STT_ERROR_OPERATION_FAILED;
+               //LCOV_EXCL_STOP
        }
 
        ret = buxton_set_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_CUSTOM, bux_val);
        if (0 != ret) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to set value sync");
                buxton_value_free(bux_val);
                buxton_free_layer(bux_layer);
@@ -626,6 +652,7 @@ int __stt_set_buxtonkey(const char* engine_id)
                bux_layer = NULL;
                bux_val = NULL;
                return STT_ERROR_OPERATION_FAILED;
+               //LCOV_EXCL_STOP
        }
        SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, STT_ENGINE_DB_CUSTOM);
 
@@ -656,10 +683,10 @@ int stt_set_engine(stt_h stt, const char* engine_id)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
+       SLOG(LOG_INFO, TAG_STTC, "===== Set current engine");
 
        if (NULL == engine_id) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -674,18 +701,18 @@ int stt_set_engine(stt_h stt, const char* engine_id)
                client->current_engine_id = NULL;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== engined_id(%s)", engine_id);
+       SLOG(LOG_INFO, TAG_STTC, "===== engined_id(%s)", engine_id);
 
        client->current_engine_id = strdup(engine_id);
 
        /* Set vconfkey */
        int ret = __stt_set_buxtonkey(engine_id);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] set buxtonkey Failed!!!");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] set buxtonkey Failed!!!"); //LCOV_EXCL_LINE
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return 0;
@@ -704,7 +731,7 @@ int stt_set_credential(stt_h stt, const char* credential)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
+       SLOG(LOG_INFO, TAG_STTC, "===== Set credential");
 
        if (NULL == credential) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
@@ -713,7 +740,7 @@ int stt_set_credential(stt_h stt, const char* credential)
 
        /* check state */
        if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
@@ -723,7 +750,7 @@ int stt_set_credential(stt_h stt, const char* credential)
        }
        client->credential = strdup(credential);
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return STT_ERROR_NONE;
@@ -742,7 +769,7 @@ int stt_set_private_data(stt_h stt, const char* key, const char* data)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
+       SLOG(LOG_INFO, TAG_STTC, "===== Set private data");
 
        if (NULL == key || NULL == data) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
@@ -756,7 +783,7 @@ int stt_set_private_data(stt_h stt, const char* key, const char* data)
        }
 
        if (true != client->internal && (0 == strcmp(key, "server") || 0 == strcmp(key, "rampcode") || 0 == strcmp(key, "epd"))) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This is not an internal app");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This is not an internal app"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -765,6 +792,7 @@ int stt_set_private_data(stt_h stt, const char* key, const char* data)
        while (0 != ret) {
                ret = stt_dbus_request_set_private_data(client->uid, key, data);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
                                return ret;
@@ -777,10 +805,11 @@ int stt_set_private_data(stt_h stt, const char* key, const char* data)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, "");
 
        return STT_ERROR_NONE;
@@ -799,7 +828,7 @@ int stt_get_private_data(stt_h stt, const char* key, char** data)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
+       SLOG(LOG_INFO, TAG_STTC, "===== Get private data");
 
        if (NULL == key || NULL == data) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
@@ -817,6 +846,7 @@ int stt_get_private_data(stt_h stt, const char* key, char** data)
        while (0 != ret) {
                ret = stt_dbus_request_get_private_data(client->uid, key, data);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
                                return ret;
@@ -829,6 +859,7 @@ int stt_get_private_data(stt_h stt, const char* key, char** data)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                }
        }
 
@@ -837,12 +868,13 @@ int stt_get_private_data(stt_h stt, const char* key, char** data)
                *data = NULL;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, "");
 
        return STT_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 int stt_set_server_stt(stt_h stt, const char* key, char* user_data)
 {
        int ret = -1;
@@ -858,7 +890,7 @@ int stt_set_server_stt(stt_h stt, const char* key, char* user_data)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Set STT server");
+       SLOG(LOG_INFO, TAG_STTC, "===== Set STT server");
 
        if (NULL == key || NULL == user_data) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
@@ -899,11 +931,12 @@ int stt_set_server_stt(stt_h stt, const char* key, char* user_data)
        free(private_key);
        private_key = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "======");
+       SLOG(LOG_INFO, TAG_STTC, "======");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
 }
+//LCOV_EXCL_STOP
 
 static Eina_Bool __stt_connect_daemon(void *data)
 {
@@ -911,13 +944,13 @@ static Eina_Bool __stt_connect_daemon(void *data)
        int ret = -1;
 
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); //LCOV_EXCL_LINE
                g_connect_timer = NULL;
                return EINA_FALSE;
        }
 
        if (0 == stt_client_get_size() || NULL == stt_client_get_by_uid(client->uid)) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Client has been already destroyed");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Client has been already destroyed"); //LCOV_EXCL_LINE
                return EINA_FALSE;
        }
 
@@ -925,10 +958,12 @@ static Eina_Bool __stt_connect_daemon(void *data)
        if (1 == g_privilege_applaunch_allowed && NULL != client->current_engine_id) {
                /* Set vconfkey */
                ret = __stt_set_buxtonkey(client->current_engine_id);
+               //LCOV_EXCL_START
                if (0 != ret) {
                        SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] set buxtonkey Failed!!! (inside __stt_connect_daemon)");
                        return EINA_TRUE;
                }
+               //LCOV_EXCL_STOP
        }
 
        /* Send hello */
@@ -943,7 +978,7 @@ static Eina_Bool __stt_connect_daemon(void *data)
        }
 
        g_connect_timer = NULL;
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Connect stt-service");
+       SLOG(LOG_INFO, TAG_STTC, "===== Connect stt-service");
 
        /* request initialization */
        bool silence_supported = false;
@@ -952,7 +987,7 @@ static Eina_Bool __stt_connect_daemon(void *data)
        ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
 
        if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
 
                client->reason = STT_ERROR_ENGINE_NOT_FOUND;
                ecore_main_loop_thread_safe_call_async(__stt_notify_error, (void*)client);
@@ -960,7 +995,7 @@ static Eina_Bool __stt_connect_daemon(void *data)
                return EINA_FALSE;
 
        } else if (STT_ERROR_NONE != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
+               SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect"); //LCOV_EXCL_LINE
                return EINA_TRUE;
        } else {
                /* success to connect stt-service */
@@ -969,6 +1004,7 @@ static Eina_Bool __stt_connect_daemon(void *data)
                SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
        }
 
+//LCOV_EXCL_START
 #ifdef __UNUSED_CODES__
        if (NULL != client->current_engine_id) {
                ret = -1;
@@ -1002,7 +1038,8 @@ static Eina_Bool __stt_connect_daemon(void *data)
                }
        }
 #endif
-       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
+//LCOV_EXCL_STOP
+       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
 
        client->before_state = client->current_state;
        client->current_state = STT_STATE_READY;
@@ -1017,7 +1054,7 @@ static Eina_Bool __stt_connect_daemon(void *data)
                SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, "  ");
 
        return EINA_FALSE;
@@ -1036,15 +1073,19 @@ int stt_prepare(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "===== Prepare STT");
+
        /* check state */
        if (client->current_state != STT_STATE_CREATED) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
                return STT_ERROR_INVALID_STATE;
        }
 
-       g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
+       ecore_thread_main_loop_begin();
+       g_connect_timer = ecore_timer_add(0.02, __stt_connect_daemon, (void*)client);
+       ecore_thread_main_loop_end();
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return STT_ERROR_NONE;
@@ -1063,7 +1104,7 @@ int stt_unprepare(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
+       SLOG(LOG_INFO, TAG_STTC, "===== Unprepare STT");
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -1076,6 +1117,7 @@ int stt_unprepare(stt_h stt)
        while (0 != ret) {
                ret = stt_dbus_request_finalize(client->uid);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
                                break;
@@ -1088,6 +1130,7 @@ int stt_unprepare(stt_h stt)
                                        break;
                                }
                        }
+                       //LCOV_EXCL_STOP
                }
        }
 
@@ -1110,7 +1153,7 @@ int stt_unprepare(stt_h stt)
                g_connect_timer = NULL;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return STT_ERROR_NONE;
@@ -1122,15 +1165,17 @@ bool __stt_config_supported_language_cb(const char* engine_id, const char* langu
 
        stt_client_s* client = stt_client_get(stt);
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
+               SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid"); //LCOV_EXCL_LINE
                return false;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "===== supported language callback");
+
        /* call callback function */
        if (NULL != client->supported_lang_cb) {
                return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
        } else {
-               SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
+               SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages"); //LCOV_EXCL_LINE
        }
 
        return false;
@@ -1149,10 +1194,10 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
+       SLOG(LOG_INFO, TAG_STTC, "===== Foreach Supported Language");
 
        if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -1163,15 +1208,17 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac
                ret = stt_config_mgr_get_engine(&current_engine_id);
                ret = __stt_convert_config_error_code(ret);
                if (0 != ret) {
-                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
+                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                        return ret;
                }
        } else {
                current_engine_id = strdup(client->current_engine_id);
+               //LCOV_EXCL_START
                if (NULL == current_engine_id) {
                        SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
                        return STT_ERROR_OUT_OF_MEMORY;
                }
+               //LCOV_EXCL_STOP
        }
 
        client->supported_lang_cb = callback;
@@ -1180,7 +1227,7 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac
        ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
        }
 
        if (NULL != current_engine_id) {
@@ -1191,7 +1238,7 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac
        client->supported_lang_cb = NULL;
        client->supported_lang_user_data = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -1210,10 +1257,10 @@ int stt_get_default_language(stt_h stt, char** language)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
+       SLOG(LOG_INFO, TAG_STTC, "===== Get Default Language");
 
        if (NULL == language) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -1221,12 +1268,12 @@ int stt_get_default_language(stt_h stt, char** language)
        ret = stt_config_mgr_get_default_language(language);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
        } else {
                SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -1246,12 +1293,14 @@ int stt_get_state(stt_h stt, stt_state_e* state)
        }
 
        if (NULL == state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        *state = client->current_state;
 
+       SLOG(LOG_INFO, TAG_STTC, "===== Get state(%d)", *state);
+
        switch (*state) {
        case STT_STATE_CREATED:         SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'");        break;
        case STT_STATE_READY:           SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'");          break;
@@ -1288,13 +1337,13 @@ int stt_get_error_message(stt_h stt, char** err_msg)
 
        if (NULL != client->err_msg) {
                *err_msg = strdup(client->err_msg);
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg); //LCOV_EXCL_LINE
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Error msg (NULL)"); //LCOV_EXCL_LINE
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
-       SLOG(LOG_DEBUG, TAG_STTC, " ");
+       SLOG(LOG_INFO, TAG_STTC, "====="); //LCOV_EXCL_LINE
+       SLOG(LOG_DEBUG, TAG_STTC, " "); //LCOV_EXCL_LINE
 
        return STT_ERROR_NONE;
 }
@@ -1313,7 +1362,7 @@ int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support
        }
 
        if (NULL == type || NULL == support) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -1328,6 +1377,7 @@ int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support
        while (0 != ret) {
                ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
                                return ret;
@@ -1340,8 +1390,9 @@ int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
+                       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
                        break;
                }
        }
@@ -1368,6 +1419,8 @@ int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "===== Set silence detection, supported(%d), type(%d)", client->silence_supported, type);
+
        if (true == client->silence_supported) {
                if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
                        client->silence = type;
@@ -1395,21 +1448,21 @@ int stt_set_start_sound(stt_h stt, const char* filename)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT SET START SOUND");
 
        if (NULL == filename) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        if (0 != access(filename, F_OK)) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
@@ -1418,6 +1471,7 @@ int stt_set_start_sound(stt_h stt, const char* filename)
        while (0 != ret) {
                ret = stt_dbus_request_set_start_sound(client->uid, filename);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
                                return ret;
@@ -1430,8 +1484,9 @@ int stt_set_start_sound(stt_h stt, const char* filename)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
+                       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
                        break;
                }
        }
@@ -1452,7 +1507,7 @@ int stt_unset_start_sound(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT UNSET START SOUND");
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -1465,6 +1520,7 @@ int stt_unset_start_sound(stt_h stt)
        while (0 != ret) {
                ret = stt_dbus_request_unset_start_sound(client->uid);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
                                return ret;
@@ -1477,8 +1533,9 @@ int stt_unset_start_sound(stt_h stt)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
+                       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Unset start sound");
                        break;
                }
        }
@@ -1499,21 +1556,21 @@ int stt_set_stop_sound(stt_h stt, const char* filename)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT SET STOP SOUND");
 
        if (NULL == filename) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        if (0 != access(filename, F_OK)) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
@@ -1522,6 +1579,7 @@ int stt_set_stop_sound(stt_h stt, const char* filename)
        while (0 != ret) {
                ret = stt_dbus_request_set_stop_sound(client->uid, filename);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
                                return ret;
@@ -1534,8 +1592,9 @@ int stt_set_stop_sound(stt_h stt, const char* filename)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
+                       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
                        break;
                }
        }
@@ -1556,7 +1615,7 @@ int stt_unset_stop_sound(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT UNSET STOP SOUND");
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -1569,6 +1628,7 @@ int stt_unset_stop_sound(stt_h stt)
        while (0 != ret) {
                ret = stt_dbus_request_unset_stop_sound(client->uid);
                if (0 != ret) {
+                       //LCOV_EXCL_START
                        if (STT_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
                                return ret;
@@ -1581,8 +1641,9 @@ int stt_unset_stop_sound(stt_h stt)
                                        return ret;
                                }
                        }
+                       //LCOV_EXCL_STOP
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
+                       SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Unset stop sound");
                        break;
                }
        }
@@ -1603,7 +1664,7 @@ int stt_start(stt_h stt, const char* language, const char* type)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT START");
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -1612,7 +1673,7 @@ int stt_start(stt_h stt, const char* language, const char* type)
        }
 
        if (STT_INTERNAL_STATE_NONE != client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_RECORDING;
        }
 
@@ -1621,7 +1682,7 @@ int stt_start(stt_h stt, const char* language, const char* type)
        ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
 
        if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID"); //LCOV_EXCL_LINE
        } else {
                SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
        }
@@ -1639,7 +1700,7 @@ int stt_start(stt_h stt, const char* language, const char* type)
        }
 
        if (true == client->credential_needed && NULL == client->credential) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id); //LCOV_EXCL_LINE
                free(temp);
                temp = NULL;
                return STT_ERROR_PERMISSION_DENIED;
@@ -1648,16 +1709,16 @@ int stt_start(stt_h stt, const char* language, const char* type)
        client->internal_state = STT_INTERNAL_STATE_STARTING;
        ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                client->internal_state = STT_INTERNAL_STATE_NONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Start is successful but not done");
        }
 
        free(temp);
        temp = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -1676,32 +1737,32 @@ int stt_stop(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT STOP");
 
        /* check state */
        if (client->current_state != STT_STATE_RECORDING) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
        if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_RECORDING;
        } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_READY;
        } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
        }
 
        client->internal_state = STT_INTERNAL_STATE_STOPPING;
        int ret = stt_dbus_request_stop(client->uid);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                client->internal_state = STT_INTERNAL_STATE_NONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Stop is successful but not done");
        }
 
        SLOG(LOG_DEBUG, TAG_STTC, "=====");
@@ -1724,32 +1785,32 @@ int stt_cancel(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT CANCEL");
 
        /* check state */
        if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
        if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_RECORDING;
        } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
        } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state); //LCOV_EXCL_LINE
                return STT_ERROR_IN_PROGRESS_TO_READY;
        }
 
        client->internal_state = STT_INTERNAL_STATE_CANCELING;
        int ret = stt_dbus_request_cancel(client->uid);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
                client->internal_state = STT_INTERNAL_STATE_NONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
        }
 
        SLOG(LOG_DEBUG, TAG_STTC, "=====");
@@ -1764,17 +1825,21 @@ int __stt_cb_set_volume(int uid, float volume)
 
        client = stt_client_get_by_uid(uid);
        if (NULL == client) {
+               //LCOV_EXCL_START
                SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
                return STT_ERROR_INVALID_PARAMETER;
+               //LCOV_EXCL_STOP
        }
 
        if (STT_STATE_RECORDING != client->current_state) {
+               //LCOV_EXCL_START
                SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
                return STT_ERROR_INVALID_STATE;
+               //LCOV_EXCL_STOP
        }
 
        g_volume_db = volume;
-       SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
+       SLOG(LOG_INFO, TAG_STTC, "Set volume (%f)", g_volume_db);
 
        return 0;
 }
@@ -1793,20 +1858,23 @@ int stt_get_recording_volume(stt_h stt, float* volume)
        }
 
        if (NULL == volume) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        if (STT_STATE_RECORDING != client->current_state) {
-               SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
+               SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_STATE;
        }
 
        *volume = g_volume_db;
 
+       SLOG(LOG_INFO, TAG_STTC, "Get recording volume (%f)", *volume);
+
        return STT_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
 {
        stt_client_s* client = (stt_client_s*)user_data;
@@ -1818,7 +1886,7 @@ bool __stt_result_time_cb(int index, int event, const char* text, long start_tim
        }
 
        if (NULL != client->result_time_cb) {
-               SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
+               SLOG(LOG_INFO, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
                        index, event, text, start_time, end_time);
                client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
                        text, start_time, end_time, client->result_time_user_data);
@@ -1829,6 +1897,7 @@ bool __stt_result_time_cb(int index, int event, const char* text, long start_tim
 
        return true;
 }
+//LCOV_EXCL_STOP
 
 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
 {
@@ -1843,10 +1912,10 @@ int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* us
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
 
        if (NULL == callback) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
@@ -1857,13 +1926,13 @@ int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* us
        ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
        ret = __stt_convert_config_error_code(ret);
        if (0 != ret) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret)); //LCOV_EXCL_LINE
        }
 
        client->result_time_cb = NULL;
        client->result_time_user_data = NULL;
 
-       SLOG(LOG_DEBUG, TAG_STTC, "=====");
+       SLOG(LOG_INFO, TAG_STTC, "=====");
        SLOG(LOG_DEBUG, TAG_STTC, " ");
 
        return ret;
@@ -1877,7 +1946,7 @@ static void __stt_notify_error(void *data)
 
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid"); //LCOV_EXCL_LINE
                return;
        }
 
@@ -1892,7 +1961,7 @@ static void __stt_notify_error(void *data)
                stt_client_not_use_callback(client);
                SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
        } else {
-               SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
+               SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null"); //LCOV_EXCL_LINE
        }
 
        return;
@@ -1900,6 +1969,7 @@ static void __stt_notify_error(void *data)
 
 int __stt_cb_error(int uid, int reason, char* err_msg)
 {
+       //LCOV_EXCL_START
        if (-1 == uid) {
                GList* client_list = NULL;
                client_list = stt_client_get_client_list();
@@ -1944,10 +2014,11 @@ int __stt_cb_error(int uid, int reason, char* err_msg)
                                iter = g_list_next(iter);
                        }
                }
+               //LCOV_EXCL_STOP
        } else {
                stt_client_s* client = stt_client_get_by_uid(uid);
                if (NULL == client) {
-                       SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
+                       SLOG(LOG_ERROR, TAG_STTC, "Handle not found"); //LCOV_EXCL_LINE
                        return -1;
                }
 
@@ -1969,11 +2040,11 @@ int __stt_cb_error(int uid, int reason, char* err_msg)
                }
 
                if (STT_ERROR_SERVICE_RESET == reason) {
-                       SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
+                       SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset"); //LCOV_EXCL_LINE
 
                        client->current_state = STT_STATE_CREATED;
                        if (0 != stt_prepare(client->stt)) {
-                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
+                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare"); //LCOV_EXCL_LINE
                        }
                }
        }
@@ -1987,7 +2058,7 @@ static void __stt_notify_state_changed(void *data)
 
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid"); //LCOV_EXCL_LINE
                return;
        }
 
@@ -1997,13 +2068,13 @@ static void __stt_notify_state_changed(void *data)
 
        if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
                client->internal_state = STT_INTERNAL_STATE_NONE;
-               SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
+               SLOG(LOG_INFO, TAG_STTC, "Internal state change to NONE");
        } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
                client->internal_state = STT_INTERNAL_STATE_NONE;
-               SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
+               SLOG(LOG_INFO, TAG_STTC, "Internal state change to NONE");
        } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
                client->internal_state = STT_INTERNAL_STATE_NONE;
-               SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
+               SLOG(LOG_INFO, TAG_STTC, "Internal state change to NONE");
        }
 
        if (NULL != client->state_changed_cb) {
@@ -2011,9 +2082,9 @@ static void __stt_notify_state_changed(void *data)
                client->state_changed_cb(client->stt, client->before_state,
                        client->current_state, client->state_changed_user_data);
                stt_client_not_use_callback(client);
-               SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called, State(%d)", client->current_state);
+               SLOG(LOG_INFO, TAG_STTC, "State changed callback is called, State(%d)", client->current_state);
        } else {
-               SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null, State(%d)", client->current_state);
+               SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null, State(%d)", client->current_state); //LCOV_EXCL_LINE
        }
 
        return;
@@ -2025,7 +2096,7 @@ static Eina_Bool __stt_notify_result(void *data)
 
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid"); //LCOV_EXCL_LINE
                return EINA_FALSE;
        }
 
@@ -2038,7 +2109,7 @@ static Eina_Bool __stt_notify_result(void *data)
                client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
                        client->msg, client->recognition_result_user_data);
                stt_client_not_use_callback(client);
-               SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
+               SLOG(LOG_INFO, TAG_STTC, "client recognition result callback called");
        } else {
                SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
        }
@@ -2058,7 +2129,7 @@ static Eina_Bool __stt_notify_result(void *data)
                                free(temp[i]);
                                temp[i] = NULL;
                        } else {
-                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
+                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error"); //LCOV_EXCL_LINE
                        }
                }
                free(client->data_list);
@@ -2076,7 +2147,7 @@ static Eina_Bool __stt_notify_result(void *data)
                if (NULL != client->state_changed_cb) {
                        ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
                } else {
-                       SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
+                       SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null"); //LCOV_EXCL_LINE
                }
        }
 
@@ -2089,17 +2160,17 @@ int __stt_cb_result(int uid, int event, char** data, int data_count, const char*
 
        client = stt_client_get_by_uid(uid);
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
+               SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid"); //LCOV_EXCL_LINE
                return STT_ERROR_INVALID_PARAMETER;
        }
 
        if (NULL != msg)
-               SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
+               SECURE_SLOG(LOG_INFO, TAG_STTC, "Recognition Result Message = %s", msg);
 
        int i = 0;
        for (i = 0; i < data_count; i++) {
                if (NULL != data[i])
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
+                       SECURE_SLOG(LOG_INFO, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
        }
 
        if (NULL != client->recognition_result_cb) {
@@ -2114,7 +2185,7 @@ int __stt_cb_result(int uid, int event, char** data, int data_count, const char*
                        char **temp = NULL;
                        temp = (char**)calloc(data_count, sizeof(char*));
                        if (NULL == temp) {
-                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
+                               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
                                return STT_ERROR_OUT_OF_MEMORY;
                        }
 
@@ -2122,7 +2193,7 @@ int __stt_cb_result(int uid, int event, char** data, int data_count, const char*
                                if (NULL != data[i])
                                        temp[i] = strdup(data[i]);
                                else
-                                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
+                                       SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error"); //LCOV_EXCL_LINE
                        }
 
                        client->data_list = temp;
@@ -2140,7 +2211,7 @@ int __stt_cb_set_state(int uid, int state)
 {
        stt_client_s* client = stt_client_get_by_uid(uid);
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
+               SLOG(LOG_ERROR, TAG_STTC, "Handle not found"); //LCOV_EXCL_LINE
                return -1;
        }
 
@@ -2164,7 +2235,7 @@ static void __stt_notify_speech_status(void *data)
 
        /* check handle */
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify speech status : A handle is not valid");
+               SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify speech status : A handle is not valid"); //LCOV_EXCL_LINE
                return;
        }
 
@@ -2176,9 +2247,9 @@ static void __stt_notify_speech_status(void *data)
                stt_client_use_callback(client);
                client->speech_status_cb(client->stt, client->speech_status, client->speech_status_user_data);
                stt_client_not_use_callback(client);
-               SLOG(LOG_DEBUG, TAG_STTC, "Speech status callback is called");
+               SLOG(LOG_INFO, TAG_STTC, "Speech status callback is called"); //LCOV_EXCL_LINE
        } else {
-               SLOG(LOG_WARN, TAG_STTC, "[WARNING] Speech status callback is null");
+               SLOG(LOG_WARN, TAG_STTC, "[WARNING] Speech status callback is null"); //LCOV_EXCL_LINE
        }
 
        return;
@@ -2188,7 +2259,7 @@ int __stt_cb_speech_status(int uid, int status)
 {
        stt_client_s* client = stt_client_get_by_uid(uid);
        if (NULL == client) {
-               SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
+               SLOG(LOG_ERROR, TAG_STTC, "Handle not found"); //LCOV_EXCL_LINE
                return -1;
        }
 
@@ -2219,6 +2290,8 @@ int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback,
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set recognition result cb");
+
        client->recognition_result_cb = callback;
        client->recognition_result_user_data = user_data;
 
@@ -2243,6 +2316,8 @@ int stt_unset_recognition_result_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset recognition result cb");
+
        client->recognition_result_cb = NULL;
        client->recognition_result_user_data = NULL;
 
@@ -2270,6 +2345,8 @@ int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* use
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set state changed cb");
+
        client->state_changed_cb = callback;
        client->state_changed_user_data = user_data;
 
@@ -2294,6 +2371,8 @@ int stt_unset_state_changed_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset state changed cb");
+
        client->state_changed_cb = NULL;
        client->state_changed_user_data = NULL;
 
@@ -2321,6 +2400,8 @@ int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set error cb");
+
        client->error_cb = callback;
        client->error_user_data = user_data;
 
@@ -2345,6 +2426,8 @@ int stt_unset_error_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset error cb");
+
        client->error_cb = NULL;
        client->error_user_data = NULL;
 
@@ -2372,6 +2455,8 @@ int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set default language changed cb");
+
        client->default_lang_changed_cb = callback;
        client->default_lang_changed_user_data = user_data;
 
@@ -2396,6 +2481,8 @@ int stt_unset_default_language_changed_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset default language changed cb");
+
        client->default_lang_changed_cb = NULL;
        client->default_lang_changed_user_data = NULL;
 
@@ -2423,6 +2510,8 @@ int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* u
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set engine changed cb");
+
        client->engine_changed_cb = callback;
        client->engine_changed_user_data = user_data;
 
@@ -2447,12 +2536,15 @@ int stt_unset_engine_changed_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset engine changed cb");
+
        client->engine_changed_cb = NULL;
        client->engine_changed_user_data = NULL;
 
        return 0;
 }
 
+//LCOV_EXCL_START
 int stt_set_speech_status_cb(stt_h stt, stt_speech_status_cb callback, void* user_data)
 {
        stt_client_s* client = NULL;
@@ -2474,6 +2566,8 @@ int stt_set_speech_status_cb(stt_h stt, stt_speech_status_cb callback, void* use
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Set speech status cb");
+
        client->speech_status_cb = callback;
        client->speech_status_user_data = user_data;
 
@@ -2498,6 +2592,8 @@ int stt_unset_speech_status_cb(stt_h stt)
                return STT_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTC, "[INFO] Unset speech status cb");
+
        client->speech_status_cb = NULL;
        client->speech_status_user_data = NULL;
 
@@ -2521,7 +2617,7 @@ int stt_start_file(stt_h stt, const char* language, const char* type, const char
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT START FILE");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT START FILE");
 
        /* check state */
        if (client->current_state != STT_STATE_READY) {
@@ -2541,7 +2637,7 @@ int stt_start_file(stt_h stt, const char* language, const char* type, const char
        if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
+               SLOG(LOG_INFO, TAG_STTC, "[DEBUG] Current app id is %s", appid);
        }
 
        char* temp = NULL;
@@ -2569,7 +2665,7 @@ int stt_start_file(stt_h stt, const char* language, const char* type, const char
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start file : %s", __stt_get_error_code(ret));
                client->internal_state = STT_INTERNAL_STATE_NONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Start is successful but not done");
        }
 
        free(temp);
@@ -2594,7 +2690,7 @@ int stt_cancel_file(stt_h stt)
                return STT_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL FILE");
+       SLOG(LOG_INFO, TAG_STTC, "===== STT CANCEL FILE");
 
        /* check state */
        if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
@@ -2619,7 +2715,7 @@ int stt_cancel_file(stt_h stt)
                SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel file : %s", __stt_get_error_code(ret));
                client->internal_state = STT_INTERNAL_STATE_NONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel file is successful but not done");
+               SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] Cancel file is successful but not done");
        }
 
        SLOG(LOG_DEBUG, TAG_STTC, "=====");
@@ -2627,4 +2723,4 @@ int stt_cancel_file(stt_h stt)
 
        return ret;
 }
-
+//LCOV_EXCL_STOP