/*
-* 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
int (*sttp_load_engine)(sttpd_funcs_s* pdfuncs, sttpe_funcs_s* pefuncs);
int (*sttp_unload_engine)();
-}sttengine_s;
+} sttengine_s;
extern const char* stt_tag();
static const char* __stt_get_engine_error_code(sttp_error_e err)
{
- switch(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:
int stt_engine_load(int engine_id, const char* filepath)
{
if (NULL == filepath || engine_id < 0) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
/* 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->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;
return STTP_ERROR_OPERATION_FAILED;
}
- engine->sttp_load_engine = (int (*)(sttpd_funcs_s*, sttpe_funcs_s*) )dlsym(engine->handle, "sttp_load_engine");
+ 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);
engine->pdfuncs->version = 1;
engine->pdfuncs->size = sizeof(sttpd_funcs_s);
-
- int ret = engine->sttp_load_engine(engine->pdfuncs, engine->pefuncs);
+
+ 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->pdfuncs);
free(engine->engine_path);
free(engine);
- return STTP_ERROR_OPERATION_FAILED;
+ return ret;
}
/* engine error check */
free(engine->engine_path);
free(engine);
- return STTP_ERROR_OPERATION_FAILED;
+ return STTP_ERROR_OPERATION_FAILED;
}
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Engine Success] Load engine : version(%d), size(%d)",engine->pefuncs->version, engine->pefuncs->size);
+ 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);
/* unload engine */
engine->sttp_unload_engine();
dlclose(engine->handle);
-
+
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);
free(engine);
-
+
return 0;
}
int stt_engine_initialize(int engine_id, sttpe_result_cb result_cb, sttpe_silence_detected_cb silence_cb)
{
if (NULL == result_cb || NULL == silence_cb) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
ret = engine->pefuncs->initialize(result_cb, silence_cb);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_deinitialize(int engine_id)
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)
int stt_engine_get_supported_langs(int engine_id, GSList** lang_list)
{
if (NULL == lang_list) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
ret = engine->pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_is_valid_language(int engine_id, const char* language, bool *is_valid)
{
if (NULL == language || NULL == is_valid) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
return STTP_ERROR_INVALID_PARAMETER;
}
-
+
bool result;
result = engine->pefuncs->is_valid_lang(language);
return 0;
}
+int stt_engine_set_private_data(int engine_id, 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;
+ }
+
+ 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 = 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 ret;
+}
+
+int stt_engine_get_private_data(int engine_id, 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;
+ }
+
+ char* temp = NULL;
+ int ret = engine->pefuncs->get_private_data(key, &temp);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get private data(%d)", ret);
+ return ret;
+ }
+
+ *data = strdup(temp);
+
+ return STTP_ERROR_NONE;
+}
+
int stt_engine_get_first_language(int engine_id, char** language)
{
if (NULL == language) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
ret = engine->pefuncs->foreach_langs(__supported_language_cb, &lang_list);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
+ return ret;
}
GSList *iter = NULL;
int stt_engine_support_silence(int engine_id, bool* support)
{
if (NULL == support) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
return 0;
}
+
+int stt_engine_need_app_credential(int engine_id, bool* need)
+{
+ if (NULL == need) {
+ 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;
+ }
+
+ bool result;
+ if (NULL != engine->pefuncs->need_app_credential) {
+ result = engine->pefuncs->need_app_credential();
+ *need = result;
+ return STTP_ERROR_NONE;
+ }
+
+ return STTP_ERROR_OPERATION_FAILED;
+}
+
int stt_engine_support_recognition_type(int engine_id, const char* type, bool* support)
{
if (NULL == type || NULL == support) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
int stt_engine_get_audio_type(int engine_id, sttp_audio_type_e* types, int* rate, int* channels)
{
if (NULL == types || NULL == rate || NULL == channels) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
ret = engine->pefuncs->get_audio_format(types, rate, channels);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
/* Set option */
int ret = engine->pefuncs->set_silence_detection(value);
if (STTP_ERROR_NOT_SUPPORTED_FEATURE == ret) {
- SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support silence detection");
+ 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 STTP_ERROR_OPERATION_FAILED;
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set silence detection : %d", ret);
}
-
- return 0;
+
+ return ret;
}
int stt_engine_check_app_agreed(int engine_id, const char* appid, bool* value)
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
*value = false;
- return STTP_ERROR_OPERATION_FAILED;
}
-
- return 0;
+
+ return ret;
}
/* Recognition */
-int stt_engine_recognize_start(int engine_id, const char* lang, const char* recognition_type, void* user_param)
+int stt_engine_recognize_start(int engine_id, const char* lang, const char* recognition_type, const char* credential, void* user_param)
{
if (NULL == lang || NULL == recognition_type) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
return STTP_ERROR_INVALID_PARAMETER;
}
- int ret = engine->pefuncs->start(lang, recognition_type, user_param);
+ int ret = engine->pefuncs->start(lang, recognition_type, credential, user_param);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
}
- return 0;
+ return ret;
}
int stt_engine_set_recording_data(int engine_id, const void* data, unsigned int length)
{
if (NULL == data) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
int ret = engine->pefuncs->set_recording(data, length);
if (0 != ret) {
SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_recognize_stop(int engine_id)
int ret = engine->pefuncs->stop();
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_recognize_cancel(int engine_id)
int ret = engine->pefuncs->cancel();
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_foreach_result_time(int engine_id, void* time_info, sttpe_result_time_cb callback, void* user_data)
int ret = engine->pefuncs->foreach_result_time(time_info, callback, user_data);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
-
- return 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)
{
if (NULL == filepath || NULL == lang || NULL == recognition_type) {
- SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
+ SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
return STTP_ERROR_INVALID_PARAMETER;
}
int ret = engine->pefuncs->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
+ return ret;
}
int stt_engine_recognize_cancel_file(int engine_id)
int ret = engine->pefuncs->cancel_file();
if (0 != ret) {
SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
- return STTP_ERROR_OPERATION_FAILED;
}
- return 0;
-}
\ No newline at end of file
+ return ret;
+}
projects / platform / core / uifw / stt.git / blobdiff