/*
-* 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
#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)
}
/* 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;
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;
}
}
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);
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
projects / platform / core / uifw / stt.git / blobdiff