X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=common%2Fstt_engine.c;h=532381d06a98b4ce70e69b4742cc572131f2ceee;hb=e200b2e89abf72b96332db59da24acc8d4cda44f;hp=e644512c43a86bb88b2bd4018c901eedb693d025;hpb=27eadda0d8475576f474062bf24129a64fb55bff;p=platform%2Fcore%2Fuifw%2Fstt.git

diff --git a/common/stt_engine.c b/common/stt_engine.c
index e644512..532381d 100644
--- a/common/stt_engine.c
+++ b/common/stt_engine.c
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved
+*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -19,272 +19,174 @@
 #include <stdbool.h>
 
 #include "stt_engine.h"
+#include "sttd_engine_agent.h"
 
 /*
 * Internal data structure
 */
 
 typedef struct {
-	int	engine_id;
 	char*	engine_path;
-	void	*handle;
-
-	sttpe_funcs_s*	pefuncs;
-	sttpd_funcs_s*	pdfuncs;
-
-	int (*sttp_load_engine)(sttpd_funcs_s* pdfuncs, sttpe_funcs_s* pefuncs);
-	int (*sttp_unload_engine)();
+	stte_request_callback_s *callback;
 } sttengine_s;
 
 extern const char* stt_tag();
 
-/** stt engine list */
-static GSList *g_engine_list;
+/** stt engine */
+static sttengine_s *g_engine = NULL;
 
-static const char* __stt_get_engine_error_code(sttp_error_e err)
-{
-	switch (err) {
-	case STTP_ERROR_NONE:			return "STTP_ERROR_NONE";
-	case STTP_ERROR_OUT_OF_MEMORY:		return "STTP_ERROR_OUT_OF_MEMORY";
-	case STTP_ERROR_IO_ERROR:		return "STTP_ERROR_IO_ERROR";
-	case STTP_ERROR_INVALID_PARAMETER:	return "STTP_ERROR_INVALID_PARAMETER";
-	case STTP_ERROR_TIMED_OUT:		return "STTP_ERROR_TIMED_OUT";
-	case STTP_ERROR_RECORDER_BUSY:		return "STTP_ERROR_RECORDER_BUSY";
-	case STTP_ERROR_OUT_OF_NETWORK:		return "STTP_ERROR_OUT_OF_NETWORK";
-	case STTP_ERROR_PERMISSION_DENIED:	return "STTP_ERROR_PERMISSION_DENIED";
-	case STTP_ERROR_NOT_SUPPORTED:		return "STTP_ERROR_NOT_SUPPORTED";
-	case STTP_ERROR_INVALID_STATE:		return "STTP_ERROR_INVALID_STATE";
-	case STTP_ERROR_INVALID_LANGUAGE:	return "STTP_ERROR_INVALID_LANGUAGE";
-	case STTP_ERROR_ENGINE_NOT_FOUND:	return "STTP_ERROR_ENGINE_NOT_FOUND";
-	case STTP_ERROR_OPERATION_FAILED:	return "STTP_ERROR_OPERATION_FAILED";
-	case STTP_ERROR_NOT_SUPPORTED_FEATURE:	return "STTP_ERROR_NOT_SUPPORTED_FEATURE";
-	default:
-		return "Invalid error code";
-	}
-}
+static bool g_is_from_lib = false;
 
-static sttengine_s* __get_engine(int engine_id)
-{
-	/* check whether engine id is valid or not.*/
-	GSList *iter = NULL;
-	sttengine_s *engine = NULL;
+/** callback functions */
+static stt_engine_result_cb g_result_cb = NULL;
+static stte_private_data_set_cb g_set_private_data_cb = NULL;
+static stte_private_data_requested_cb g_get_private_data_cb = NULL;
+static stte_audio_type_cb g_set_audio_type_cb = NULL;
+static void* g_set_audio_type_user_data = NULL;
 
-	if (g_slist_length(g_engine_list) > 0) {
-		/*Get a first item*/
-		iter = g_slist_nth(g_engine_list, 0);
 
-		while (NULL != iter) {
-			/*Get handle data from list*/
-			engine = iter->data;
+static int __stt_set_engine_from(bool is_from_lib)
+{
+	g_is_from_lib = is_from_lib;
+	return 0;
+}
 
-			if (engine_id == engine->engine_id) {
-				return engine;
-			}
+static bool __stt_get_engine_from(void)
+{
+	return g_is_from_lib;
+}
 
-			/*Get next item*/
-			iter = g_slist_next(iter);
-		}
+static const char* __stt_get_engine_error_code(stte_error_e err)
+{
+	switch (err) {
+	case STTE_ERROR_NONE:			return "STTE_ERROR_NONE";
+	case STTE_ERROR_OUT_OF_MEMORY:		return "STTE_ERROR_OUT_OF_MEMORY";
+	case STTE_ERROR_IO_ERROR:		return "STTE_ERROR_IO_ERROR";
+	case STTE_ERROR_INVALID_PARAMETER:	return "STTE_ERROR_INVALID_PARAMETER";
+	case STTE_ERROR_NETWORK_DOWN:		return "STTE_ERROR_NETWORK_DOWN";
+	case STTE_ERROR_PERMISSION_DENIED:	return "STTE_ERROR_PERMISSION_DENIED";
+	case STTE_ERROR_NOT_SUPPORTED:		return "STTE_ERROR_NOT_SUPPORTED";
+	case STTE_ERROR_INVALID_STATE:		return "STTE_ERROR_INVALID_STATE";
+	case STTE_ERROR_INVALID_LANGUAGE:	return "STTE_ERROR_INVALID_LANGUAGE";
+	case STTE_ERROR_OPERATION_FAILED:	return "STTE_ERROR_OPERATION_FAILED";
+	case STTE_ERROR_NOT_SUPPORTED_FEATURE:	return "STTE_ERROR_NOT_SUPPORTED_FEATURE";
+	case STTE_ERROR_RECORDING_TIMED_OUT:	return "STTE_ERROR_RECORDING_TIMED_OUT";
+	default:
+		return "Invalid error code";
 	}
-
-	return NULL;
 }
 
 /* Register engine id */
-int stt_engine_load(int engine_id, const char* filepath)
+int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
 {
-	if (NULL == filepath || engine_id < 0) {
+	if (NULL == callback || NULL == filepath) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL != engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is already loaded", engine_id);
-		return 0;
-	}
-
-	SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Engine] Load engine id(%d), path(%s)", engine_id, filepath);
-
 	/* allocation memory */
-	engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
-	if (NULL == engine) {
-		SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
-		return STTP_ERROR_OUT_OF_MEMORY;
-	}
-
-	/* load engine */
-	char *error;
-
-	engine->handle = dlopen(filepath, RTLD_LAZY);
-	if (!engine->handle) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine] Invalid engine (Fail dlopen) : %s", filepath);
-		free(engine);
-		return STTP_ERROR_OPERATION_FAILED;
-	}
-
-	engine->pefuncs = (sttpe_funcs_s*)calloc(1, sizeof(sttpe_funcs_s));
-	if (NULL == engine->pefuncs) {
-		SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
-		dlclose(engine->handle);
-		free(engine);
-		return STTP_ERROR_OUT_OF_MEMORY;
-	}
-	engine->pdfuncs = (sttpd_funcs_s*)calloc(1, sizeof(sttpd_funcs_s));
-	if (NULL == engine->pdfuncs) {
-		SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
-		dlclose(engine->handle);
-		free(engine->pefuncs);
-		free(engine);
-		return STTP_ERROR_OUT_OF_MEMORY;
-	}
-
-	engine->sttp_unload_engine = NULL;
-	engine->sttp_load_engine = NULL;
-
-	engine->sttp_unload_engine = (int (*)())dlsym(engine->handle, "sttp_unload_engine");
-	if (NULL != (error = dlerror()) || NULL == engine->sttp_unload_engine) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to link daemon to sttp_unload_engine() : %s", error);
-		dlclose(engine->handle);
-		free(engine->pefuncs);
-		free(engine->pdfuncs);
-		free(engine);
-		return STTP_ERROR_OPERATION_FAILED;
-	}
-
-	engine->sttp_load_engine = (int (*)(sttpd_funcs_s*, sttpe_funcs_s*))dlsym(engine->handle, "sttp_load_engine");
-	if (NULL != (error = dlerror()) || NULL == engine->sttp_load_engine) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to link daemon to sttp_load_engine() : %s", error);
-		dlclose(engine->handle);
-		free(engine->pefuncs);
-		free(engine->pdfuncs);
-		free(engine);
-		return STTP_ERROR_OPERATION_FAILED;
-	}
-
-	engine->engine_id = engine_id;
-	engine->engine_path = strdup(filepath);
-
-	engine->pdfuncs->version = 1;
-	engine->pdfuncs->size = sizeof(sttpd_funcs_s);
-
-	int ret = engine->sttp_load_engine(engine->pdfuncs, engine->pefuncs);
-	if (0 != ret) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail sttp_load_engine() : %s", __stt_get_engine_error_code(ret));
-		dlclose(engine->handle);
-		free(engine->pefuncs);
-		free(engine->pdfuncs);
-		free(engine->engine_path);
-		free(engine);
-		return ret;
-	}
-
-	/* engine error check */
-	if (engine->pefuncs->size != sizeof(sttpe_funcs_s)) {
-		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine is not valid : function size is not matched");
-	}
-
-	if (NULL == engine->pefuncs->initialize ||
-		NULL == engine->pefuncs->deinitialize ||
-		NULL == engine->pefuncs->foreach_langs ||
-		NULL == engine->pefuncs->is_valid_lang ||
-		NULL == engine->pefuncs->support_silence ||
-		NULL == engine->pefuncs->support_recognition_type ||
-		NULL == engine->pefuncs->get_audio_format ||
-		NULL == engine->pefuncs->set_silence_detection ||
-		NULL == engine->pefuncs->start ||
-		NULL == engine->pefuncs->set_recording ||
-		NULL == engine->pefuncs->stop ||
-		NULL == engine->pefuncs->cancel ||
-		NULL == engine->pefuncs->foreach_result_time)
-		/* Current unused functions
-		NULL == engine->pefuncs->start_file_recognition ||
-		*/
-	{
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] The engine functions are NOT valid");
-		dlclose(engine->handle);
-		free(engine->pefuncs);
-		free(engine->pdfuncs);
-		free(engine->engine_path);
-		free(engine);
+	if (NULL != g_engine) {
+		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine is already loaded");
+	} else {
+		g_engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
+		if (NULL == g_engine) {
+			SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+			return STTE_ERROR_OUT_OF_MEMORY;
+		}
 
-		return STTP_ERROR_OPERATION_FAILED;
+		/* load engine */
+		g_engine->callback = callback;
+		g_engine->engine_path = strdup(filepath);
 	}
 
-	SLOG(LOG_DEBUG, stt_tag(), "[Engine Success] Load engine : version(%d), size(%d)", engine->pefuncs->version, engine->pefuncs->size);
-
-	g_engine_list = g_slist_append(g_engine_list, engine);
+	SLOG(LOG_DEBUG, stt_tag(), "[Engine Success] Load engine : version(%d)", g_engine->callback->version);
 
 	return 0;
 }
 
 /* Unregister engine id */
-int stt_engine_unload(int engine_id)
+int stt_engine_unload()
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	/* unload engine */
-	engine->sttp_unload_engine();
-	dlclose(engine->handle);
+	g_engine->callback = NULL;
 
-	if (NULL != engine->engine_path)	free(engine->engine_path);
-	if (NULL != engine->pefuncs)		free(engine->pefuncs);
-	if (NULL != engine->pdfuncs)		free(engine->pdfuncs);
-
-	g_engine_list = g_slist_remove(g_engine_list, engine);
+	if (NULL != g_engine->engine_path) {
+		free(g_engine->engine_path);
+		g_engine->engine_path = NULL;
+	}
 
-	free(engine);
+	free(g_engine);
+	g_engine = NULL;
 
 	return 0;
 }
 
 
 /* Initialize / Deinitialize */
-int stt_engine_initialize(int engine_id, sttpe_result_cb result_cb, sttpe_silence_detected_cb silence_cb)
+int stt_engine_initialize(bool is_from_lib)
 {
-	if (NULL == result_cb || NULL == silence_cb) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback->initialize) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
 	int ret;
-	ret = engine->pefuncs->initialize(result_cb, silence_cb);
+	ret = __stt_set_engine_from(is_from_lib);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set engine : %s", __stt_get_engine_error_code(ret));
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to initialize");
+
+	ret = g_engine->callback->initialize();
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_deinitialize(int engine_id)
+int stt_engine_deinitialize()
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback->deinitialize) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to deinitialize");
+
 	int ret;
-	ret = engine->pefuncs->deinitialize();
+	ret = g_engine->callback->deinitialize();
 	if (0 != ret) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
 	}
 
-	return 0;
+	return ret;
 }
 
 static bool __supported_language_cb(const char* language, void* user_data)
@@ -304,115 +206,137 @@ static bool __supported_language_cb(const char* language, void* user_data)
 }
 
 /* Get option */
-int stt_engine_get_supported_langs(int engine_id, GSList** lang_list)
+int stt_engine_get_supported_langs(GSList** lang_list)
 {
 	if (NULL == lang_list) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback->foreach_langs) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
 	int ret;
-	ret = engine->pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list);
+	ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_is_valid_language(int engine_id, const char* language, bool *is_valid)
+int stt_engine_is_valid_language(const char* language, bool *is_valid)
 {
 	if (NULL == language || NULL == is_valid) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	bool result;
-	result = engine->pefuncs->is_valid_lang(language);
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
 
-	*is_valid = result;
+	if (NULL == g_engine->callback->is_valid_lang) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
 
-	return 0;
+	int ret = STTE_ERROR_NONE;
+	ret = g_engine->callback->is_valid_lang(language, is_valid);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to check valid language(%d)", ret);
+	}
+	return ret;
 }
 
-int stt_engine_set_private_data(int engine_id, const char* key, const char* data)
+int stt_engine_set_private_data(const char* key, const char* data)
 {
 	if (NULL == key || NULL == data) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	int ret = STTE_ERROR_NONE;
+	if (NULL != g_set_private_data_cb) {
+		ret = g_set_private_data_cb(key, data);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set private data(%d)", ret);
+		}
 	}
 
-	int ret = engine->pefuncs->set_private_data(key, data);
-	if (0 != ret) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set private data(%d)", ret);
-	}
-	return STTP_ERROR_NONE;
+	return ret;
 }
 
-int stt_engine_get_private_data(int engine_id, const char* key, char** data)
+int stt_engine_get_private_data(const char* key, char** data)
 {
 	if (NULL == key || NULL == data) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
-	}
-
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
+	int ret = STTE_ERROR_NONE;
 	char* temp = NULL;
-	int ret = engine->pefuncs->get_private_data(key, &temp);
-	if (0 != ret) {
-		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set private data(%d)", ret);
+	if (NULL != g_get_private_data_cb) {
+		ret = g_get_private_data_cb(key, &temp);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get private data(%d)", ret);
+			return ret;
+		}
+	} else {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] There's no private data function)");
 	}
 
-	*data = strdup(temp);
+	if (NULL == temp)
+		*data = strdup("NULL");
+	else
+		*data = strdup(temp);
 
-	return STTP_ERROR_NONE;
+	return STTE_ERROR_NONE;
 }
 
-int stt_engine_get_first_language(int engine_id, char** language)
+int stt_engine_get_first_language(char** language)
 {
 	if (NULL == language) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[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, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
 	GSList* lang_list = NULL;
 	int ret;
-	ret = engine->pefuncs->foreach_langs(__supported_language_cb, &lang_list);
+	ret = g_engine->callback->foreach_langs(__supported_language_cb, &lang_list);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
 		return ret;
@@ -425,10 +349,12 @@ int stt_engine_get_first_language(int engine_id, char** language)
 	if (NULL != iter) {
 		data = iter->data;
 
-		if (true == engine->pefuncs->is_valid_lang(data)) {
+		bool is_valid = false;
+		ret = g_engine->callback->is_valid_lang(data, &is_valid);
+		if (0 == ret && true == is_valid) {
 			*language = strdup(data);
 		} else {
-			ret = STTP_ERROR_OPERATION_FAILED;
+			ret = STTE_ERROR_OPERATION_FAILED;
 		}
 	}
 
@@ -440,8 +366,10 @@ int stt_engine_get_first_language(int engine_id, char** language)
 		while (NULL != iter) {
 			data = iter->data;
 
-			if (NULL != data)
+			if (NULL != data) {
 				free(data);
+				data = NULL;
+			}
 
 			lang_list = g_slist_remove_link(lang_list, iter);
 
@@ -452,297 +380,504 @@ int stt_engine_get_first_language(int engine_id, char** language)
 	return ret;
 }
 
-int stt_engine_support_silence(int engine_id, bool* support)
+int stt_engine_support_silence(bool* support)
 {
 	if (NULL == support) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to support silence");
+
+	if (NULL == g_engine->callback->support_silence) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
 	bool result;
-	result = engine->pefuncs->support_silence();
+	result = g_engine->callback->support_silence();
 	*support = result;
 
-	return 0;
+	return STTE_ERROR_NONE;
 }
 
-
-int stt_engine_need_app_credential(int engine_id, bool* need)
+int stt_engine_need_app_credential(bool* need)
 {
 	if (NULL == need) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	bool result;
-	if (NULL != engine->pefuncs->need_app_credential) {
-		result = engine->pefuncs->need_app_credential();
-		*need = result;
-		return STTP_ERROR_NONE;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to need app credential");
+
+	if (NULL == g_engine->callback->need_app_credential) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	return STTP_ERROR_OPERATION_FAILED;
+	bool result;
+	result = g_engine->callback->need_app_credential();
+	*need = result;
+
+	return STTE_ERROR_NONE;
 }
 
-int stt_engine_support_recognition_type(int engine_id, const char* type, bool* support)
+int stt_engine_support_recognition_type(const char* type, bool* support)
 {
 	if (NULL == type || NULL == support) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	bool result;
-	if (NULL != engine->pefuncs->support_recognition_type) {
-		result = engine->pefuncs->support_recognition_type(type);
-		*support = result;
-		return 0;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	return STTP_ERROR_OPERATION_FAILED;
+	if (NULL == g_engine->callback->support_recognition_type) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR} Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to support recognition type, type(%s)", type);
+
+	int ret = STTE_ERROR_NONE;
+	ret = g_engine->callback->support_recognition_type(type, support);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get supporting recognition type(%d)", ret);
+	}
+	return ret;
 }
 
-int stt_engine_get_audio_type(int engine_id, sttp_audio_type_e* types, int* rate, int* channels)
+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, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
+	if (NULL == g_engine->callback->get_audio_format) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to get audio format");
+
 	int ret;
-	ret = engine->pefuncs->get_audio_format(types, rate, channels);
+	ret = g_engine->callback->get_audio_format(types, rate, channels);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
 /* Set option */
-int stt_engine_set_silence_detection(int engine_id, bool value)
+int stt_engine_set_silence_detection(bool value)
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback->set_silence_detection) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->set_silence_detection(value);
-	if (STTP_ERROR_NOT_SUPPORTED_FEATURE == ret) {
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to set silence detection(%d)", value);
+
+	int ret = g_engine->callback->set_silence_detection(value);
+	if (STTE_ERROR_NOT_SUPPORTED_FEATURE == ret) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support silence detection");
-		return STTP_ERROR_NOT_SUPPORTED_FEATURE;
 	} else if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set silence detection : %d", ret);
-		return ret;
 	}
-
-	return 0;
+	return ret;
 }
 
-int stt_engine_check_app_agreed(int engine_id, const char* appid, bool* value)
+int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == is_agreed) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	if (NULL == engine->pefuncs->check_app_agreed) {
+	if (NULL == g_engine->callback->check_app_agreed) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support app agreement. All app is available");
-		*value = true;
+		*is_agreed = true;
 		return 0;
 	}
 
-	int ret = engine->pefuncs->check_app_agreed(appid, value);
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to app agreed, appid(%s), is_agreed(%d)", appid, *is_agreed);
+
+	int ret = g_engine->callback->check_app_agreed(appid, is_agreed);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
-		*value = false;
-		return ret;
+		*is_agreed = false;
 	}
 
-	return 0;
+	return ret;
 }
 
 /* Recognition */
-int stt_engine_recognize_start(int engine_id, const char* lang, const char* recognition_type, const char* credential, void* user_param)
+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, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine->callback->start) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->start(lang, recognition_type, credential, user_param);
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to start, lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
+
+	int ret = g_engine->callback->start(lang, recognition_type, appid, credential, user_param);
+
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_set_recording_data(int engine_id, const void* data, unsigned int length)
+int stt_engine_set_recording_data(const void* data, unsigned int length)
 {
 	if (NULL == data) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->set_recording(data, length);
+	if (NULL == g_engine->callback->set_recording) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	int ret = g_engine->callback->set_recording(data, length);
 	if (0 != ret) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_recognize_stop(int engine_id)
+int stt_engine_recognize_stop()
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->stop();
+	if (NULL == g_engine->callback->stop) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to stop");
+
+	int ret = g_engine->callback->stop();
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_recognize_cancel(int engine_id)
+int stt_engine_recognize_cancel()
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->cancel();
+	if (NULL == g_engine->callback->cancel) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to cancel");
+
+	int ret = g_engine->callback->cancel();
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_foreach_result_time(int engine_id, void* time_info, sttpe_result_time_cb callback, void* user_data)
+int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback, void* user_data)
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	int ret = engine->pefuncs->foreach_result_time(time_info, callback, user_data);
+	if (NULL == g_engine->callback->foreach_result_time) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	int ret = g_engine->callback->foreach_result_time(time_info, callback, user_data);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
 
-	return 0;
+	return ret;
 }
 
-int stt_engine_recognize_start_file(int engine_id, const char* lang, const char* recognition_type, 
-				     const char* filepath, sttp_audio_type_e audio_type, int sample_rate, void* user_param)
+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, stt_tag(), "[Engine ERROR] Invalid Parameter");
-		return STTP_ERROR_INVALID_PARAMETER;
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	if (NULL == engine->pefuncs->start_file) {
+#ifdef __UNUSED_CODES__
+	if (NULL == g_engine->callback->start_file) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
-		return STTP_ERROR_NOT_SUPPORTED_FEATURE;
+		return STTE_ERROR_NOT_SUPPORTED_FEATURE;
 	}
 
-	int ret = engine->pefuncs->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
+	int ret = g_engine->callback->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
-		return ret;
 	}
-
+#endif
 	return 0;
 }
 
-int stt_engine_recognize_cancel_file(int engine_id)
+int stt_engine_recognize_cancel_file()
 {
-	sttengine_s* engine = NULL;
-	engine = __get_engine(engine_id);
-	if (NULL == engine) {
-		SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
-		return STTP_ERROR_INVALID_PARAMETER;
+	if (NULL == g_engine) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] No engine");
+		return STTE_ERROR_OPERATION_FAILED;
+	}
+
+	if (NULL == g_engine->callback) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
+		return STTE_ERROR_OPERATION_FAILED;
 	}
 
-	if (NULL == engine->pefuncs->cancel_file) {
+#ifdef __UNUSED_CODES__
+	if (NULL == g_engine->callback->cancel_file) {
 		SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
-		return STTP_ERROR_NOT_SUPPORTED_FEATURE;
+		return STTE_ERROR_NOT_SUPPORTED_FEATURE;
 	}
 
-	int ret = engine->pefuncs->cancel_file();
+	int ret = g_engine->callback->cancel_file();
 	if (0 != ret) {
 		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
-		return ret;
+	}
+#endif
+	return 0;
+}
+
+int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* user_data)
+{
+	if (NULL == result_cb) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
 	}
 
+	g_result_cb = result_cb;
+
 	return 0;
 }
+
+int stt_engine_send_result(stte_result_event_e event, const char* type, const char** result, int result_count,
+				const char* msg, void* time_info, void* user_data)
+{
+	if (NULL == type || NULL == result) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
+	}
+
+	int ret = STTE_ERROR_NONE;
+	if (false == __stt_get_engine_from()) {
+		ret = sttd_engine_agent_send_result(event, type, result, result_count, msg, time_info, user_data);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send result");
+		}
+	} else {
+		ret = g_result_cb(event, type, result, result_count, msg, time_info, user_data);
+	}
+	return ret;
+}
+
+int stt_engine_send_error(stte_error_e error, const char* msg)
+{
+	int ret = STTE_ERROR_NONE;
+	ret = sttd_engine_agent_send_error(error, msg);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send error info");
+	}
+	return ret;
+}
+
+int stt_engine_send_speech_status(stte_speech_status_e status, void* user_data)
+{
+	int ret = STTE_ERROR_NONE;
+	ret = sttd_engine_agent_send_speech_status(status, user_data);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to send speech status");
+	}
+	return ret;
+}
+
+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, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	g_set_private_data_cb = private_data_set_cb;
+
+	return 0;
+}
+
+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, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	g_get_private_data_cb = private_data_requested_cb;
+
+	return 0;
+}
+
+int stt_engine_set_audio_type(const char* audio_type)
+{
+	if (NULL == audio_type) {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	SLOG(LOG_INFO, stt_tag(), "[Engine Info] set audio type (%s)", audio_type);
+
+	int ret = STTE_ERROR_NONE;
+	if (NULL != g_set_audio_type_cb) {
+		ret = g_set_audio_type_cb(audio_type, g_set_audio_type_user_data);
+		if (0 != ret) {
+			SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set audio type, ret(%d)", ret);
+		}
+	} else {
+		SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] There's no set audio function)");
+	}
+
+	return ret;
+}
+
+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, stt_tag(), "[Engine ERROR] Invalid parameter");
+		return STTE_ERROR_INVALID_PARAMETER;
+	}
+
+	g_set_audio_type_cb = audio_type_set_cb;
+	g_set_audio_type_user_data = user_data;
+
+	return 0;
+}
\ No newline at end of file