X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=client%2Fstt_file.c;h=030829f5aeb02d0584858bd81ef43e11c5347e27;hb=e576da4dfaefa2dd24ffe385aaae4b3c53fe0890;hp=d67f247786aeb2cf1d93495d587b7b2c1d4c6560;hpb=b6f36bfc2a673deeacc6b3d6527870f02567a7fb;p=platform%2Fcore%2Fuifw%2Fstt.git diff --git a/client/stt_file.c b/client/stt_file.c old mode 100644 new mode 100755 index d67f247..030829f --- a/client/stt_file.c +++ b/client/stt_file.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 @@ -45,17 +45,10 @@ typedef struct _sttengine_info { static GSList* g_engine_list; -static int g_engine_id_count = 0; - #define STT_FILE_CONFIG_HANDLE 100000 -const char* stt_tag() -{ - return TAG_STTFC; -} - static const char* __stt_file_get_error_code(stt_file_error_e err) { switch (err) { @@ -88,6 +81,7 @@ void __stt_file_engine_info_cb(const char* engine_uuid, const char* engine_name, static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** info) { +#ifdef __UNUSED_CODES__ if (NULL == filepath || NULL == info) { SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Invalid Parameter"); return STT_FILE_ERROR_INVALID_PARAMETER; @@ -104,7 +98,7 @@ static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** i return STT_FILE_ERROR_ENGINE_NOT_FOUND; } - /* link engine to daemon */ + /* link engine to stt-service */ dlsym(handle, "sttp_load_engine"); if ((error = dlerror()) != NULL) { SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error); @@ -125,7 +119,7 @@ static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** i if ((error = dlerror()) != NULL || NULL == get_engine_info) { SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error); dlclose(handle); - return -1; + return STT_FILE_ERROR_ENGINE_NOT_FOUND; } sttengine_info_s* temp; @@ -164,6 +158,7 @@ static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** i SLOG(LOG_DEBUG, TAG_STTFC, " "); *info = temp; +#endif return STT_FILE_ERROR_NONE; } @@ -192,7 +187,7 @@ static bool __stt_file_is_engine(const char* filepath) return false; } -void __stt_file_relseae_engine_info() +void __stt_file_relseae_engine_info(void) { GSList *iter = NULL; @@ -213,10 +208,10 @@ void __stt_file_relseae_engine_info() if (engine->is_loaded) { SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[Engine Agent] Unload engine id(%d)", engine->engine_id); - if (0 != stt_engine_deinitialize(engine->engine_id)) + if (0 != stt_engine_deinitialize()) SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id); - if (0 != stt_engine_unload(engine->engine_id)) + if (0 != stt_engine_unload()) SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id); engine->is_loaded = false; @@ -255,7 +250,7 @@ static sttengine_info_s* __stt_file_get_engine_by_id(int engine_id) return NULL; } -void __stt_file_result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count, +int __stt_file_result_cb(stte_result_event_e event, const char* type, const char** data, int data_count, const char* msg, void* time_info, void *user_data) { @@ -275,7 +270,7 @@ void __stt_file_result_cb(sttp_result_event_e event, const char* type, const cha /* check handle */ if (NULL == client) { SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to notify error : A handle is not valid"); - return; + return STT_FILE_ERROR_OPERATION_FAILED; } if (NULL != time_info) { @@ -293,7 +288,7 @@ void __stt_file_result_cb(sttp_result_event_e event, const char* type, const cha client->time_info = NULL; - if (STTP_RESULT_EVENT_FINAL_RESULT == event || STTP_RESULT_EVENT_ERROR == event) { + if (STTE_RESULT_EVENT_FINAL_RESULT == event || STTE_RESULT_EVENT_ERROR == event) { SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] State change : 'Ready'"); client->before_state = client->current_state; @@ -309,15 +304,23 @@ void __stt_file_result_cb(sttp_result_event_e event, const char* type, const cha } } - return; + return STT_FILE_ERROR_NONE; } -void __stt_file_silence_cb(sttp_silence_type_e type, void *user_data) +void __stt_file_speech_status_cb(stte_speech_status_e status, void *user_data) { + /* it seems to be no necessity yet */ SLOG(LOG_WARN, TAG_STTFC, "[WARNING] This callback should NOT be called."); return; } +void __stt_file_error_cb(stte_error_e error, const char* msg) +{ + /* it seems to be no necessity yet */ + SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Error callback is called"); + return; +} + static int __stt_file_load_engine(sttengine_info_s* engine) { if (NULL == engine) { @@ -325,12 +328,12 @@ static int __stt_file_load_engine(sttengine_info_s* engine) return STT_FILE_ERROR_INVALID_PARAMETER; } - if (0 != stt_engine_load(engine->engine_id, engine->engine_path)) { + if (0 != stt_engine_load(engine->engine_path, NULL)) { SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to load engine(%s)", engine->engine_path); return STT_FILE_ERROR_OPERATION_FAILED; } - int ret = stt_engine_initialize(engine->engine_id, __stt_file_result_cb, __stt_file_silence_cb); + int ret = stt_engine_initialize(true); if (0 != ret) { SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path); return STT_FILE_ERROR_OPERATION_FAILED; @@ -343,7 +346,7 @@ static int __stt_file_load_engine(sttengine_info_s* engine) return STT_FILE_ERROR_NONE; } -int stt_file_initialize() +int stt_file_initialize(void) { SLOG(LOG_DEBUG, TAG_STTFC, "===== Initialize STT FILE"); @@ -356,19 +359,17 @@ int stt_file_initialize() /* Get file name from default engine directory */ DIR *dp = NULL; int ret = -1; - struct dirent entry; struct dirent *dirp = NULL; dp = opendir(STT_DEFAULT_ENGINE); if (NULL != dp) { do { - ret = readdir_r(dp, &entry, &dirp); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_STTFC, "[File ERROR] Fail to read directory"); - break; - } + dirp = readdir(dp); if (NULL != dirp) { - sttengine_info_s* info; + if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name)) + continue; + + sttengine_info_s* info = NULL; char* filepath; int filesize; @@ -460,12 +461,17 @@ int stt_file_initialize() } } - if (NULL != engine_id) free(engine_id); + if (NULL != engine_id) { + free(engine_id); + engine_id = NULL; + } if (false == is_found) { + engine = NULL; SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Fail to find default engine"); iter = g_slist_nth(g_engine_list, 0); - engine = iter->data; + if (NULL != iter) + engine = iter->data; if (NULL == engine) { SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine"); @@ -498,7 +504,7 @@ int stt_file_initialize() return STT_FILE_ERROR_NONE; } -int stt_file_deinitialize() +int stt_file_deinitialize(void) { SLOG(LOG_DEBUG, TAG_STTFC, "===== Deinitialize STT FILE"); @@ -522,7 +528,7 @@ int stt_file_deinitialize() switch (client->current_state) { case STT_FILE_STATE_PROCESSING: /* Cancel file recognition */ - stt_engine_recognize_cancel_file(client->current_engine_id); + stt_engine_recognize_cancel_file(); case STT_FILE_STATE_READY: /* Unload engine */ @@ -563,10 +569,10 @@ int stt_file_get_state(stt_file_state_e* state) *state = client->current_state; switch (*state) { - case STT_FILE_STATE_NONE: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'NONE'"); break; - case STT_FILE_STATE_READY: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Ready'"); break; - case STT_FILE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Processing'"); break; - default: SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid value"); break; + case STT_FILE_STATE_NONE: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'NONE'"); break; + case STT_FILE_STATE_READY: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Ready'"); break; + case STT_FILE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Processing'"); break; + default: SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid value"); break; } return STT_FILE_ERROR_NONE; @@ -594,7 +600,7 @@ int stt_file_foreach_supported_engines(stt_file_supported_engine_cb callback, vo } if (client->current_state != STT_FILE_STATE_READY) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state); SLOG(LOG_DEBUG, TAG_STTFC, "====="); SLOG(LOG_DEBUG, TAG_STTFC, " "); return STT_FILE_ERROR_INVALID_STATE; @@ -646,7 +652,7 @@ int stt_file_get_engine(char** engine_id) } if (client->current_state != STT_FILE_STATE_READY) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state); SLOG(LOG_DEBUG, TAG_STTFC, "====="); SLOG(LOG_DEBUG, TAG_STTFC, " "); return STT_FILE_ERROR_INVALID_STATE; @@ -690,7 +696,7 @@ int stt_file_set_engine(const char* engine_id) /* check state */ if (client->current_state != STT_FILE_STATE_READY) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state); SLOG(LOG_DEBUG, TAG_STTFC, "====="); SLOG(LOG_DEBUG, TAG_STTFC, " "); return STT_FILE_ERROR_INVALID_STATE; @@ -737,8 +743,8 @@ int stt_file_set_engine(const char* engine_id) client->current_engine_id = engine->engine_id; if (-1 != temp_old_engine) { - stt_engine_deinitialize(temp_old_engine); - stt_engine_unload(temp_old_engine); + stt_engine_deinitialize(); + stt_engine_unload(); } SLOG(LOG_DEBUG, TAG_STTFC, "====="); @@ -811,7 +817,7 @@ int stt_file_foreach_supported_languages(stt_file_supported_language_cb callback return STT_FILE_ERROR_NONE; } -int stt_file_start(const char* language, const char* type, const char* filepath, +int stt_file_start(const char* language, const char* type, const char* filepath, stt_file_audio_type_e audio_type, int sample_rate) { SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE START"); @@ -828,7 +834,7 @@ int stt_file_start(const char* language, const char* type, const char* filepath, /* check state */ if (client->current_state != STT_FILE_STATE_READY) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not READY"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); SLOG(LOG_DEBUG, TAG_STTFC, "====="); SLOG(LOG_DEBUG, TAG_STTFC, " "); return STT_FILE_ERROR_INVALID_STATE; @@ -857,10 +863,10 @@ int stt_file_start(const char* language, const char* type, const char* filepath, } SLOG(LOG_DEBUG, TAG_STTFC, "[START Info] Engine(%d) Lang(%s) Type(%s) Filepath(%s) Audio(%d) Sample rate(%d)", - , client->current_engine_id, language, type, filepath, audio_type, sample_rate); + client->current_engine_id, language, type, filepath, audio_type, sample_rate); int ret = -1; - ret = stt_engine_recognize_start_file(client->current_engine_id, language, type, filepath, audio_type, sample_rate, NULL); + ret = stt_engine_recognize_start_file(language, type, filepath, audio_type, sample_rate, NULL); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to start file recognition"); SLOG(LOG_DEBUG, TAG_STTFC, "====="); @@ -886,7 +892,7 @@ int stt_file_start(const char* language, const char* type, const char* filepath, return STT_FILE_ERROR_NONE; } -int stt_file_cancel() +int stt_file_cancel(void) { SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE CANCEL"); @@ -902,14 +908,14 @@ int stt_file_cancel() /* check state */ if (STT_FILE_STATE_PROCESSING != client->current_state) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid state : Current state is NOT 'Processing'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid state : Current state(%d) is NOT 'Processing'", client->current_state); SLOG(LOG_DEBUG, TAG_STTFC, "====="); SLOG(LOG_DEBUG, TAG_STTFC, " "); return STT_FILE_ERROR_INVALID_STATE; } int ret = -1; - ret = stt_engine_recognize_cancel_file(client->current_engine_id); + ret = stt_engine_recognize_cancel_file(); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to cancel file recognition"); SLOG(LOG_DEBUG, TAG_STTFC, "====="); @@ -935,10 +941,10 @@ int stt_file_cancel() return STT_FILE_ERROR_NONE; } -bool __stt_file_result_time_cb(int index, sttp_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data) +bool __stt_file_result_time_cb(int index, stte_result_time_event_e event, const char* text, long start_time, long end_time, void* user_data) { SLOG(LOG_DEBUG, TAG_STTFC, "(%d) event(%d) text(%s) start(%ld) end(%ld)", - index, event, text, start_time, end_time); + index, event, text, start_time, end_time); stt_file_client_s* client = stt_file_client_get(); @@ -949,7 +955,7 @@ bool __stt_file_result_time_cb(int index, sttp_result_time_event_e event, const } if (NULL != client->result_time_cb) { - client->result_time_cb(index, (stt_file_result_time_event_e)event, + client->result_time_cb(index, (stt_file_result_time_event_e)event, text, start_time, end_time, client->result_time_user_data); } else { SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Callback is NULL"); @@ -979,7 +985,7 @@ int stt_file_foreach_detailed_result(stt_file_result_time_cb callback, void* use client->result_time_cb = callback; client->result_time_user_data = user_data; - stt_engine_foreach_result_time(client->current_engine_id, client->time_info, __stt_file_result_time_cb, NULL); + stt_engine_foreach_result_time(client->time_info, __stt_file_result_time_cb, NULL); client->result_time_cb = NULL; client->result_time_user_data = NULL; @@ -1004,17 +1010,22 @@ int stt_file_set_recognition_result_cb(stt_file_recognition_result_cb callback, } if (STT_FILE_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state); return STT_FILE_ERROR_INVALID_STATE; } + int ret = stt_engine_set_recognition_result_cb(__stt_file_result_cb, NULL); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to set recognition result cb"); + } + client->recognition_result_cb = callback; client->recognition_result_user_data = user_data; - return 0; + return ret; } -int stt_file_unset_recognition_result_cb() +int stt_file_unset_recognition_result_cb(void) { stt_file_client_s* client = stt_file_client_get(); @@ -1025,14 +1036,19 @@ int stt_file_unset_recognition_result_cb() } if (STT_FILE_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state); return STT_FILE_ERROR_INVALID_STATE; } + int ret = stt_engine_set_recognition_result_cb(NULL, NULL); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to set recognition result cb"); + } + client->recognition_result_cb = NULL; client->recognition_result_user_data = NULL; - return 0; + return ret; } int stt_file_set_state_changed_cb(stt_file_state_changed_cb callback, void* user_data) @@ -1049,7 +1065,7 @@ int stt_file_set_state_changed_cb(stt_file_state_changed_cb callback, void* user } if (STT_FILE_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state); return STT_FILE_ERROR_INVALID_STATE; } @@ -1059,7 +1075,7 @@ int stt_file_set_state_changed_cb(stt_file_state_changed_cb callback, void* user return 0; } -int stt_file_unset_state_changed_cb() +int stt_file_unset_state_changed_cb(void) { stt_file_client_s* client = stt_file_client_get(); @@ -1070,7 +1086,7 @@ int stt_file_unset_state_changed_cb() } if (STT_FILE_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'"); + SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state); return STT_FILE_ERROR_INVALID_STATE; }