2 * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
26 #include "stt_config_mgr.h"
28 #include "stt_engine.h"
30 #include "stt_file_client.h"
31 #include "stt_network.h"
34 typedef struct _sttengine_info {
40 char* engine_setting_path;
46 static GSList* g_engine_list;
48 static int g_engine_id_count = 0;
51 #define STT_FILE_CONFIG_HANDLE 100000
59 static const char* __stt_file_get_error_code(stt_file_error_e err)
62 case STT_FILE_ERROR_NONE: return "STT_FILE_ERROR_NONE";
63 case STT_FILE_ERROR_OUT_OF_MEMORY: return "STT_FILE_ERROR_OUT_OF_MEMORY";
64 case STT_FILE_ERROR_IO_ERROR: return "STT_FILE_ERROR_IO_ERROR";
65 case STT_FILE_ERROR_INVALID_PARAMETER: return "STT_FILE_ERROR_INVALID_PARAMETER";
66 case STT_FILE_ERROR_OUT_OF_NETWORK: return "STT_FILE_ERROR_OUT_OF_NETWORK";
67 case STT_FILE_ERROR_INVALID_STATE: return "STT_FILE_ERROR_INVALID_STATE";
68 case STT_FILE_ERROR_INVALID_LANGUAGE: return "STT_FILE_ERROR_INVALID_LANGUAGE";
69 case STT_FILE_ERROR_ENGINE_NOT_FOUND: return "STT_FILE_ERROR_ENGINE_NOT_FOUND";
70 case STT_FILE_ERROR_OPERATION_FAILED: return "STT_FILE_ERROR_OPERATION_FAILED";
71 case STT_FILE_ERROR_NOT_SUPPORTED_FEATURE: return "STT_FILE_ERROR_NOT_SUPPORTED_FEATURE";
72 case STT_FILE_ERROR_NOT_AGREE_SERVICE: return "STT_FILE_ERROR_NOT_AGREE_SERVICE";
74 return "Invalid error code";
78 void __stt_file_engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
79 bool use_network, void* user_data)
81 sttengine_info_s* temp = (sttengine_info_s*)user_data;
83 temp->engine_uuid = g_strdup(engine_uuid);
84 temp->engine_name = g_strdup(engine_name);
85 temp->engine_setting_path = g_strdup(setting_ug_name);
86 temp->use_network = use_network;
89 static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** info)
91 if (NULL == filepath || NULL == info) {
92 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Invalid Parameter");
93 return STT_FILE_ERROR_INVALID_PARAMETER;
100 handle = dlopen(filepath, RTLD_LAZY);
103 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine : %s", filepath);
104 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
107 /* link engine to daemon */
108 dlsym(handle, "sttp_load_engine");
109 if ((error = dlerror()) != NULL) {
110 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error);
112 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
115 dlsym(handle, "sttp_unload_engine");
116 if ((error = dlerror()) != NULL) {
117 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine. Fail to open sttp_unload_engine : %s", error);
119 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
122 int (*get_engine_info)(sttpe_engine_info_cb callback, void* user_data);
124 get_engine_info = (int (*)(sttpe_engine_info_cb, void*))dlsym(handle, "sttp_get_engine_info");
125 if ((error = dlerror()) != NULL || NULL == get_engine_info) {
126 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error);
131 sttengine_info_s* temp;
132 temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s));
134 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to allocate memory");
136 return STT_FILE_ERROR_OUT_OF_MEMORY;
139 /* get engine info */
140 if (0 != get_engine_info(__stt_file_engine_info_cb, (void*)temp)) {
141 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to get engine info from engine");
144 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
150 temp->engine_id = g_engine_id_count;
153 temp->engine_path = g_strdup(filepath);
154 temp->is_loaded = false;
156 SLOG(LOG_DEBUG, TAG_STTFC, "----- Valid Engine");
157 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine id : %d", temp->engine_id);
158 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine uuid : %s", temp->engine_uuid);
159 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine name : %s", temp->engine_name);
160 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine path : %s", temp->engine_path);
161 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine setting path : %s", temp->engine_setting_path);
162 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Use network : %s", temp->use_network ? "true" : "false");
163 SLOG(LOG_DEBUG, TAG_STTFC, "-----");
164 SLOG(LOG_DEBUG, TAG_STTFC, " ");
168 return STT_FILE_ERROR_NONE;
171 static bool __stt_file_is_engine(const char* filepath)
174 sttengine_info_s *engine = NULL;
176 if (0 < g_slist_length(g_engine_list)) {
177 /* Get a first item */
178 iter = g_slist_nth(g_engine_list, 0);
180 while (NULL != iter) {
181 /* Get handle data from list */
184 if (0 == strcmp(engine->engine_path, filepath)) {
188 iter = g_slist_next(iter);
195 void __stt_file_relseae_engine_info()
199 /* Release engine list */
200 sttengine_info_s *engine = NULL;
202 if (0 < g_slist_length(g_engine_list)) {
203 /* Get a first item */
204 iter = g_slist_nth(g_engine_list, 0);
206 while (NULL != iter) {
207 /* Get handle data from list */
209 g_engine_list = g_slist_remove_link(g_engine_list, iter);
211 /* Check engine unload */
212 if (NULL != engine) {
213 if (engine->is_loaded) {
214 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[Engine Agent] Unload engine id(%d)", engine->engine_id);
216 if (0 != stt_engine_deinitialize(engine->engine_id))
217 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id);
219 if (0 != stt_engine_unload(engine->engine_id))
220 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id);
222 engine->is_loaded = false;
225 if (NULL != engine->engine_uuid) free(engine->engine_uuid);
226 if (NULL != engine->engine_path) free(engine->engine_path);
227 if (NULL != engine->engine_name) free(engine->engine_name);
228 if (NULL != engine->engine_setting_path)free(engine->engine_setting_path);
233 iter = g_slist_nth(g_engine_list, 0);
238 static sttengine_info_s* __stt_file_get_engine_by_id(int engine_id)
241 sttengine_info_s *data = NULL;
243 iter = g_slist_nth(g_engine_list, 0);
245 while (NULL != iter) {
249 if (data->engine_id == engine_id)
252 iter = g_slist_next(iter);
258 void __stt_file_result_cb(sttp_result_event_e event, const char* type, const char** data, int data_count,
259 const char* msg, void* time_info, void *user_data)
262 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Result event(%d) type(%s) msg(%s)", event, type, msg);
266 for (i = 0; i < data_count; i++) {
267 if (NULL != data[i]) {
268 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] [%d] %s", i, data[i]);
273 stt_file_client_s* client = stt_file_client_get();
276 if (NULL == client) {
277 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to notify error : A handle is not valid");
281 if (NULL != time_info) {
282 client->time_info = time_info;
285 if (NULL != client->recognition_result_cb) {
286 stt_file_client_use_callback(client);
287 client->recognition_result_cb(event, data, data_count, msg, client->recognition_result_user_data);
288 stt_file_client_not_use_callback(client);
289 SLOG(LOG_DEBUG, TAG_STTFC, "client recognition result callback called");
291 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] User recognition result callback is NULL");
294 client->time_info = NULL;
296 if (STTP_RESULT_EVENT_FINAL_RESULT == event || STTP_RESULT_EVENT_ERROR == event) {
297 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] State change : 'Ready'");
299 client->before_state = client->current_state;
300 client->current_state = STT_FILE_STATE_READY;
302 if (NULL != client->state_changed_cb) {
303 stt_file_client_use_callback(client);
304 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
305 stt_file_client_not_use_callback(client);
306 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
308 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
315 void __stt_file_silence_cb(sttp_silence_type_e type, void *user_data)
317 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] This callback should NOT be called.");
321 static int __stt_file_load_engine(sttengine_info_s* engine)
323 if (NULL == engine) {
324 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Input engine is NULL");
325 return STT_FILE_ERROR_INVALID_PARAMETER;
328 if (0 != stt_engine_load(engine->engine_id, engine->engine_path)) {
329 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to load engine(%s)", engine->engine_path);
330 return STT_FILE_ERROR_OPERATION_FAILED;
333 int ret = stt_engine_initialize(engine->engine_id, __stt_file_result_cb, __stt_file_silence_cb);
335 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
336 return STT_FILE_ERROR_OPERATION_FAILED;
339 engine->is_loaded = true;
341 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE Success] Load engine id(%d) path(%s)", engine->engine_id, engine->engine_path);
343 return STT_FILE_ERROR_NONE;
346 int stt_file_initialize()
348 SLOG(LOG_DEBUG, TAG_STTFC, "===== Initialize STT FILE");
350 stt_file_client_s* client = stt_file_client_get();
351 if (NULL != client) {
352 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Already initialized");
353 return STT_FILE_ERROR_INVALID_STATE;
356 /* Get file name from default engine directory */
360 struct dirent *dirp = NULL;
361 dp = opendir(STT_DEFAULT_ENGINE);
364 ret = readdir_r(dp, &entry, &dirp);
366 SLOG(LOG_ERROR, TAG_STTFC, "[File ERROR] Fail to read directory");
371 sttengine_info_s* info;
375 filesize = strlen(STT_DEFAULT_ENGINE) + strlen(dirp->d_name) + 5;
376 filepath = (char*)calloc(filesize, sizeof(char));
379 if (NULL != filepath) {
380 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE, dirp->d_name);
382 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Memory not enough!!");
386 if (false == __stt_file_is_engine(filepath)) {
387 /* get its and update engine list */
388 if (0 == __stt_file_get_engine_info(filepath, &info)) {
389 /* add engine info to g_engine_list */
390 g_engine_list = g_slist_append(g_engine_list, info);
394 if (NULL != filepath)
397 } while (NULL != dirp);
401 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent WARNING] Fail to open default directory");
404 if (0 >= g_slist_length(g_engine_list)) {
405 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Not found engine");
406 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
409 ret = stt_file_client_new();
411 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to create client : %s", __stt_file_get_error_code(ret));
412 return STT_FILE_ERROR_OPERATION_FAILED;
415 client = stt_file_client_get();
416 if (NULL == client) {
417 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Not initialized");
418 return STT_FILE_ERROR_OPERATION_FAILED;
421 ret = stt_config_mgr_initialize(getpid() + STT_FILE_CONFIG_HANDLE);
423 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to init config manager : %s", __stt_file_get_error_code(ret));
424 stt_file_client_destroy();
425 return STT_FILE_ERROR_OPERATION_FAILED;
429 char* engine_id = NULL;
430 ret = stt_config_mgr_get_engine(&engine_id);
432 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to get engine id : %s", __stt_file_get_error_code(ret));
433 stt_file_client_destroy();
434 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
435 __stt_file_relseae_engine_info();
436 return STT_FILE_ERROR_OPERATION_FAILED;
439 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Get engine id : %s", engine_id);
441 bool is_found = false;
443 sttengine_info_s* engine = NULL;
446 if (0 < g_slist_length(g_engine_list)) {
447 /* Get a first item */
448 iter = g_slist_nth(g_engine_list, 0);
450 while (NULL != iter) {
451 /* Get handle data from list */
454 if (0 == strcmp(engine->engine_uuid, engine_id)) {
459 iter = g_slist_next(iter);
463 if (NULL != engine_id) free(engine_id);
465 if (false == is_found) {
466 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Fail to find default engine");
467 iter = g_slist_nth(g_engine_list, 0);
470 if (NULL == engine) {
471 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
472 stt_file_client_destroy();
473 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
474 __stt_file_relseae_engine_info();
475 return STT_FILE_ERROR_OPERATION_FAILED;
477 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Set default engine (%s)", engine->engine_name);
480 ret = __stt_file_load_engine(engine);
482 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
483 stt_file_client_destroy();
484 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
485 __stt_file_relseae_engine_info();
486 return STT_FILE_ERROR_OPERATION_FAILED;
489 client->current_engine_id = engine->engine_id;
491 stt_network_initialize();
493 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE Success] Initialize : pid(%d)", getpid());
495 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
496 SLOG(LOG_DEBUG, TAG_STTFC, " ");
498 return STT_FILE_ERROR_NONE;
501 int stt_file_deinitialize()
503 SLOG(LOG_DEBUG, TAG_STTFC, "===== Deinitialize STT FILE");
505 stt_file_client_s* client = stt_file_client_get();
506 if (NULL == client) {
507 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Not initialized");
508 return STT_FILE_ERROR_INVALID_STATE;
511 /* check used callback */
512 if (0 != stt_file_client_get_use_callback(client)) {
513 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Client should NOT deinitialize STT FILE in callback function");
514 return STT_FILE_ERROR_OPERATION_FAILED;
517 stt_network_finalize();
519 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
522 switch (client->current_state) {
523 case STT_FILE_STATE_PROCESSING:
524 /* Cancel file recognition */
525 stt_engine_recognize_cancel_file(client->current_engine_id);
527 case STT_FILE_STATE_READY:
529 __stt_file_relseae_engine_info();
532 stt_file_client_destroy();
535 case STT_FILE_STATE_NONE:
536 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] NOT initialized");
542 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
543 SLOG(LOG_DEBUG, TAG_STTFC, " ");
545 return STT_FILE_ERROR_NONE;
548 int stt_file_get_state(stt_file_state_e* state)
551 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
552 return STT_FILE_ERROR_INVALID_PARAMETER;
555 stt_file_client_s* client = stt_file_client_get();
557 if (NULL == client) {
558 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Not initialized");
559 *state = STT_FILE_STATE_NONE;
560 return STT_FILE_ERROR_NONE;
563 *state = client->current_state;
566 case STT_FILE_STATE_NONE: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'NONE'"); break;
567 case STT_FILE_STATE_READY: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Ready'"); break;
568 case STT_FILE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Processing'"); break;
569 default: SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid value"); break;
572 return STT_FILE_ERROR_NONE;
575 int stt_file_foreach_supported_engines(stt_file_supported_engine_cb callback, void* user_data)
577 SLOG(LOG_DEBUG, TAG_STTFC, "===== Foreach Supported engine");
579 if (NULL == callback) {
580 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
581 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
582 SLOG(LOG_DEBUG, TAG_STTFC, " ");
583 return STT_FILE_ERROR_INVALID_PARAMETER;
586 stt_file_client_s* client = stt_file_client_get();
589 if (NULL == client) {
590 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
591 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
592 SLOG(LOG_DEBUG, TAG_STTFC, " ");
593 return STT_FILE_ERROR_INVALID_PARAMETER;
596 if (client->current_state != STT_FILE_STATE_READY) {
597 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'");
598 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
599 SLOG(LOG_DEBUG, TAG_STTFC, " ");
600 return STT_FILE_ERROR_INVALID_STATE;
604 sttengine_info_s *engine = NULL;
606 /* Get a first item */
607 iter = g_slist_nth(g_engine_list, 0);
609 while (NULL != iter) {
610 /* Get handle data from list */
613 if (NULL != engine) {
614 if (false == callback(engine->engine_uuid, engine->engine_name, user_data)) {
618 iter = g_slist_next(iter);
621 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
622 SLOG(LOG_DEBUG, TAG_STTFC, " ");
624 return STT_FILE_ERROR_NONE;
627 int stt_file_get_engine(char** engine_id)
629 SLOG(LOG_DEBUG, TAG_STTFC, "===== Get current engine");
631 if (NULL == engine_id) {
632 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
633 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
634 SLOG(LOG_DEBUG, TAG_STTFC, " ");
635 return STT_FILE_ERROR_INVALID_PARAMETER;
638 stt_file_client_s* client = stt_file_client_get();
641 if (NULL == client) {
642 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
643 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
644 SLOG(LOG_DEBUG, TAG_STTFC, " ");
645 return STT_FILE_ERROR_INVALID_PARAMETER;
648 if (client->current_state != STT_FILE_STATE_READY) {
649 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'");
650 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
651 SLOG(LOG_DEBUG, TAG_STTFC, " ");
652 return STT_FILE_ERROR_INVALID_STATE;
655 sttengine_info_s* engine = NULL;
656 engine = __stt_file_get_engine_by_id(client->current_engine_id);
657 if (NULL == engine) {
658 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
659 return STT_FILE_ERROR_OPERATION_FAILED;
662 *engine_id = strdup(engine->engine_uuid);
664 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
665 SLOG(LOG_DEBUG, TAG_STTFC, " ");
667 return STT_FILE_ERROR_NONE;
670 int stt_file_set_engine(const char* engine_id)
672 SLOG(LOG_DEBUG, TAG_STTFC, "===== Set current engine");
674 if (NULL == engine_id) {
675 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
676 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
677 SLOG(LOG_DEBUG, TAG_STTFC, " ");
678 return STT_FILE_ERROR_INVALID_PARAMETER;
681 stt_file_client_s* client = stt_file_client_get();
684 if (NULL == client) {
685 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
686 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
687 SLOG(LOG_DEBUG, TAG_STTFC, " ");
688 return STT_FILE_ERROR_INVALID_PARAMETER;
692 if (client->current_state != STT_FILE_STATE_READY) {
693 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not 'Ready'");
694 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
695 SLOG(LOG_DEBUG, TAG_STTFC, " ");
696 return STT_FILE_ERROR_INVALID_STATE;
700 sttengine_info_s *engine = NULL;
702 int temp_old_engine = -1;
704 /* Get a first item */
705 iter = g_slist_nth(g_engine_list, 0);
707 while (NULL != iter) {
708 /* Get handle data from list */
711 if (0 == strcmp(engine->engine_uuid, engine_id)) {
712 if (client->current_engine_id != engine->engine_id) {
713 temp_old_engine = client->current_engine_id;
715 SLOG(LOG_DEBUG, TAG_STTFC, "Already loaded engine : %s", engine_id);
722 iter = g_slist_next(iter);
726 if (NULL == engine) {
727 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Engine id is NOT valid");
728 return STT_FILE_ERROR_INVALID_PARAMETER;
731 int ret = __stt_file_load_engine(engine);
733 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
734 return STT_FILE_ERROR_OPERATION_FAILED;
737 client->current_engine_id = engine->engine_id;
739 if (-1 != temp_old_engine) {
740 stt_engine_deinitialize(temp_old_engine);
741 stt_engine_unload(temp_old_engine);
744 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
745 SLOG(LOG_DEBUG, TAG_STTFC, " ");
750 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
752 stt_file_client_s* client = stt_file_client_get();
753 if (NULL == client) {
754 SLOG(LOG_ERROR, TAG_STTFC, "[WARNING] A handle is not valid");
758 /* call callback function */
759 if (NULL != client->supported_lang_cb) {
760 return client->supported_lang_cb(language, client->supported_lang_user_data);
762 SLOG(LOG_WARN, TAG_STTFC, "No registered callback function of supported languages");
768 int stt_file_foreach_supported_languages(stt_file_supported_language_cb callback, void* user_data)
770 SLOG(LOG_DEBUG, TAG_STTFC, "===== Foreach Supported Language");
772 if (NULL == callback) {
773 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
774 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
775 SLOG(LOG_DEBUG, TAG_STTFC, " ");
776 return STT_FILE_ERROR_INVALID_PARAMETER;
779 stt_file_client_s* client = stt_file_client_get();
782 if (NULL == client) {
783 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
784 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
785 SLOG(LOG_DEBUG, TAG_STTFC, " ");
786 return STT_FILE_ERROR_INVALID_PARAMETER;
789 sttengine_info_s* engine = NULL;
790 engine = __stt_file_get_engine_by_id(client->current_engine_id);
791 if (NULL == engine) {
792 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
793 return STT_FILE_ERROR_OPERATION_FAILED;
796 client->supported_lang_cb = callback;
797 client->supported_lang_user_data = user_data;
800 ret = stt_config_mgr_get_language_list(engine->engine_uuid, __stt_config_supported_language_cb, NULL);
802 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get languages");
805 client->supported_lang_cb = NULL;
806 client->supported_lang_user_data = NULL;
808 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
809 SLOG(LOG_DEBUG, TAG_STTFC, " ");
811 return STT_FILE_ERROR_NONE;
814 int stt_file_start(const char* language, const char* type, const char* filepath,
815 stt_file_audio_type_e audio_type, int sample_rate)
817 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE START");
819 stt_file_client_s* client = stt_file_client_get();
822 if (NULL == client) {
823 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
824 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
825 SLOG(LOG_DEBUG, TAG_STTFC, " ");
826 return STT_FILE_ERROR_INVALID_STATE;
830 if (client->current_state != STT_FILE_STATE_READY) {
831 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state is not READY");
832 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
833 SLOG(LOG_DEBUG, TAG_STTFC, " ");
834 return STT_FILE_ERROR_INVALID_STATE;
837 if (NULL == language || NULL == filepath) {
838 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
839 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
840 SLOG(LOG_DEBUG, TAG_STTFC, " ");
841 return STT_FILE_ERROR_INVALID_PARAMETER;
844 /* check if engine use network */
845 sttengine_info_s* engine = NULL;
846 engine = __stt_file_get_engine_by_id(client->current_engine_id);
847 if (NULL == engine) {
848 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
849 return STT_FILE_ERROR_OPERATION_FAILED;
852 if (true == engine->use_network) {
853 if (false == stt_network_is_connected()) {
854 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Disconnect network. Current engine needs to network connection.");
855 return STT_FILE_ERROR_OUT_OF_NETWORK;
859 SLOG(LOG_DEBUG, TAG_STTFC, "[START Info] Engine(%d) Lang(%s) Type(%s) Filepath(%s) Audio(%d) Sample rate(%d)",
860 client->current_engine_id, language, type, filepath, audio_type, sample_rate);
863 ret = stt_engine_recognize_start_file(client->current_engine_id, language, type, filepath, audio_type, sample_rate, NULL);
865 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to start file recognition");
866 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
867 SLOG(LOG_DEBUG, TAG_STTFC, " ");
868 return STT_FILE_ERROR_OPERATION_FAILED;
871 client->before_state = client->current_state;
872 client->current_state = STT_FILE_STATE_PROCESSING;
874 if (NULL != client->state_changed_cb) {
875 stt_file_client_use_callback(client);
876 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
877 stt_file_client_not_use_callback(client);
878 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
880 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
883 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
884 SLOG(LOG_DEBUG, TAG_STTFC, " ");
886 return STT_FILE_ERROR_NONE;
889 int stt_file_cancel()
891 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE CANCEL");
893 stt_file_client_s* client = stt_file_client_get();
896 if (NULL == client) {
897 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
898 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
899 SLOG(LOG_DEBUG, TAG_STTFC, " ");
900 return STT_FILE_ERROR_INVALID_PARAMETER;
904 if (STT_FILE_STATE_PROCESSING != client->current_state) {
905 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid state : Current state is NOT 'Processing'");
906 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
907 SLOG(LOG_DEBUG, TAG_STTFC, " ");
908 return STT_FILE_ERROR_INVALID_STATE;
912 ret = stt_engine_recognize_cancel_file(client->current_engine_id);
914 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to cancel file recognition");
915 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
916 SLOG(LOG_DEBUG, TAG_STTFC, " ");
917 return STT_FILE_ERROR_OPERATION_FAILED;
920 client->before_state = client->current_state;
921 client->current_state = STT_FILE_STATE_READY;
923 if (NULL != client->state_changed_cb) {
924 stt_file_client_use_callback(client);
925 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
926 stt_file_client_not_use_callback(client);
927 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
929 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
932 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
933 SLOG(LOG_DEBUG, TAG_STTFC, " ");
935 return STT_FILE_ERROR_NONE;
938 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)
940 SLOG(LOG_DEBUG, TAG_STTFC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
941 index, event, text, start_time, end_time);
943 stt_file_client_s* client = stt_file_client_get();
946 if (NULL == client) {
947 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to notify error : A handle is not valid");
951 if (NULL != client->result_time_cb) {
952 client->result_time_cb(index, (stt_file_result_time_event_e)event,
953 text, start_time, end_time, client->result_time_user_data);
955 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Callback is NULL");
962 int stt_file_foreach_detailed_result(stt_file_result_time_cb callback, void* user_data)
964 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE FOREACH DETAILED RESULT");
966 if (NULL == callback) {
967 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
968 return STT_FILE_ERROR_INVALID_PARAMETER;
971 stt_file_client_s* client = stt_file_client_get();
974 if (NULL == client) {
975 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail : A handle is not valid");
976 return STT_FILE_ERROR_INVALID_PARAMETER;
979 client->result_time_cb = callback;
980 client->result_time_user_data = user_data;
982 stt_engine_foreach_result_time(client->current_engine_id, client->time_info, __stt_file_result_time_cb, NULL);
984 client->result_time_cb = NULL;
985 client->result_time_user_data = NULL;
987 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
988 SLOG(LOG_DEBUG, TAG_STTFC, " ");
990 return STT_FILE_ERROR_NONE;
993 int stt_file_set_recognition_result_cb(stt_file_recognition_result_cb callback, void* user_data)
995 if (NULL == callback)
996 return STT_FILE_ERROR_INVALID_PARAMETER;
998 stt_file_client_s* client = stt_file_client_get();
1001 if (NULL == client) {
1002 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1003 return STT_FILE_ERROR_INVALID_PARAMETER;
1006 if (STT_FILE_STATE_READY != client->current_state) {
1007 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'");
1008 return STT_FILE_ERROR_INVALID_STATE;
1011 client->recognition_result_cb = callback;
1012 client->recognition_result_user_data = user_data;
1017 int stt_file_unset_recognition_result_cb()
1019 stt_file_client_s* client = stt_file_client_get();
1022 if (NULL == client) {
1023 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1024 return STT_FILE_ERROR_INVALID_PARAMETER;
1027 if (STT_FILE_STATE_READY != client->current_state) {
1028 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'");
1029 return STT_FILE_ERROR_INVALID_STATE;
1032 client->recognition_result_cb = NULL;
1033 client->recognition_result_user_data = NULL;
1038 int stt_file_set_state_changed_cb(stt_file_state_changed_cb callback, void* user_data)
1040 if (NULL == callback)
1041 return STT_FILE_ERROR_INVALID_PARAMETER;
1043 stt_file_client_s* client = stt_file_client_get();
1046 if (NULL == client) {
1047 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1048 return STT_FILE_ERROR_INVALID_PARAMETER;
1051 if (STT_FILE_STATE_READY != client->current_state) {
1052 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'");
1053 return STT_FILE_ERROR_INVALID_STATE;
1056 client->state_changed_cb = callback;
1057 client->state_changed_user_data = user_data;
1062 int stt_file_unset_state_changed_cb()
1064 stt_file_client_s* client = stt_file_client_get();
1067 if (NULL == client) {
1068 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1069 return STT_FILE_ERROR_INVALID_PARAMETER;
1072 if (STT_FILE_STATE_READY != client->current_state) {
1073 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state is not 'ready'");
1074 return STT_FILE_ERROR_INVALID_STATE;
1077 client->state_changed_cb = NULL;
1078 client->state_changed_user_data = NULL;