2 * Copyright (c) 2011-2016 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;
49 #define STT_FILE_CONFIG_HANDLE 100000
52 static const char* __stt_file_get_error_code(stt_file_error_e err)
55 case STT_FILE_ERROR_NONE: return "STT_FILE_ERROR_NONE";
56 case STT_FILE_ERROR_OUT_OF_MEMORY: return "STT_FILE_ERROR_OUT_OF_MEMORY";
57 case STT_FILE_ERROR_IO_ERROR: return "STT_FILE_ERROR_IO_ERROR";
58 case STT_FILE_ERROR_INVALID_PARAMETER: return "STT_FILE_ERROR_INVALID_PARAMETER";
59 case STT_FILE_ERROR_OUT_OF_NETWORK: return "STT_FILE_ERROR_OUT_OF_NETWORK";
60 case STT_FILE_ERROR_INVALID_STATE: return "STT_FILE_ERROR_INVALID_STATE";
61 case STT_FILE_ERROR_INVALID_LANGUAGE: return "STT_FILE_ERROR_INVALID_LANGUAGE";
62 case STT_FILE_ERROR_ENGINE_NOT_FOUND: return "STT_FILE_ERROR_ENGINE_NOT_FOUND";
63 case STT_FILE_ERROR_OPERATION_FAILED: return "STT_FILE_ERROR_OPERATION_FAILED";
64 case STT_FILE_ERROR_NOT_SUPPORTED_FEATURE: return "STT_FILE_ERROR_NOT_SUPPORTED_FEATURE";
65 case STT_FILE_ERROR_NOT_AGREE_SERVICE: return "STT_FILE_ERROR_NOT_AGREE_SERVICE";
67 return "Invalid error code";
71 void __stt_file_engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
72 bool use_network, void* user_data)
74 sttengine_info_s* temp = (sttengine_info_s*)user_data;
76 temp->engine_uuid = g_strdup(engine_uuid);
77 temp->engine_name = g_strdup(engine_name);
78 temp->engine_setting_path = g_strdup(setting_ug_name);
79 temp->use_network = use_network;
82 static int __stt_file_get_engine_info(const char* filepath, sttengine_info_s** info)
84 #ifdef __UNUSED_CODES__
85 if (NULL == filepath || NULL == info) {
86 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Invalid Parameter");
87 return STT_FILE_ERROR_INVALID_PARAMETER;
94 handle = dlopen(filepath, RTLD_LAZY);
97 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine : %s", filepath);
98 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
101 /* link engine to stt-service */
102 dlsym(handle, "sttp_load_engine");
103 if ((error = dlerror()) != NULL) {
104 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine. Fail to open sttp_load_engine : %s", error);
106 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
109 dlsym(handle, "sttp_unload_engine");
110 if ((error = dlerror()) != NULL) {
111 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Invalid engine. Fail to open sttp_unload_engine : %s", error);
113 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
116 int (*get_engine_info)(sttpe_engine_info_cb callback, void* user_data);
118 get_engine_info = (int (*)(sttpe_engine_info_cb, void*))dlsym(handle, "sttp_get_engine_info");
119 if ((error = dlerror()) != NULL || NULL == get_engine_info) {
120 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent WARNING] Invalid engine. Fail to open sttp_get_engine_info : %s", error);
122 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
125 sttengine_info_s* temp;
126 temp = (sttengine_info_s*)calloc(1, sizeof(sttengine_info_s));
128 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to allocate memory");
130 return STT_FILE_ERROR_OUT_OF_MEMORY;
133 /* get engine info */
134 if (0 != get_engine_info(__stt_file_engine_info_cb, (void*)temp)) {
135 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to get engine info from engine");
138 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
144 temp->engine_id = g_engine_id_count;
147 temp->engine_path = g_strdup(filepath);
148 temp->is_loaded = false;
150 SLOG(LOG_DEBUG, TAG_STTFC, "----- Valid Engine");
151 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine id : %d", temp->engine_id);
152 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine uuid : %s", temp->engine_uuid);
153 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine name : %s", temp->engine_name);
154 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine path : %s", temp->engine_path);
155 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Engine setting path : %s", temp->engine_setting_path);
156 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "Use network : %s", temp->use_network ? "true" : "false");
157 SLOG(LOG_DEBUG, TAG_STTFC, "-----");
158 SLOG(LOG_DEBUG, TAG_STTFC, " ");
163 return STT_FILE_ERROR_NONE;
166 static bool __stt_file_is_engine(const char* filepath)
169 sttengine_info_s *engine = NULL;
171 if (0 < g_slist_length(g_engine_list)) {
172 /* Get a first item */
173 iter = g_slist_nth(g_engine_list, 0);
175 while (NULL != iter) {
176 /* Get handle data from list */
179 if (0 == strcmp(engine->engine_path, filepath)) {
183 iter = g_slist_next(iter);
190 void __stt_file_relseae_engine_info(void)
194 /* Release engine list */
195 sttengine_info_s *engine = NULL;
197 if (0 < g_slist_length(g_engine_list)) {
198 /* Get a first item */
199 iter = g_slist_nth(g_engine_list, 0);
201 while (NULL != iter) {
202 /* Get handle data from list */
204 g_engine_list = g_slist_remove_link(g_engine_list, iter);
206 /* Check engine unload */
207 if (NULL != engine) {
208 if (engine->is_loaded) {
209 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[Engine Agent] Unload engine id(%d)", engine->engine_id);
211 if (0 != stt_engine_deinitialize())
212 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to deinitialize engine id(%d)", engine->engine_id);
214 if (0 != stt_engine_unload())
215 SECURE_SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent] Fail to unload engine id(%d)", engine->engine_id);
217 engine->is_loaded = false;
220 if (NULL != engine->engine_uuid) free(engine->engine_uuid);
221 if (NULL != engine->engine_path) free(engine->engine_path);
222 if (NULL != engine->engine_name) free(engine->engine_name);
223 if (NULL != engine->engine_setting_path)free(engine->engine_setting_path);
228 iter = g_slist_nth(g_engine_list, 0);
233 static sttengine_info_s* __stt_file_get_engine_by_id(int engine_id)
236 sttengine_info_s *data = NULL;
238 iter = g_slist_nth(g_engine_list, 0);
240 while (NULL != iter) {
244 if (data->engine_id == engine_id)
247 iter = g_slist_next(iter);
253 void __stt_file_result_cb(stte_result_event_e event, const char* type, const char** data, int data_count,
254 const char* msg, void* time_info, void *user_data)
257 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Result event(%d) type(%s) msg(%s)", event, type, msg);
261 for (i = 0; i < data_count; i++) {
262 if (NULL != data[i]) {
263 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] [%d] %s", i, data[i]);
268 stt_file_client_s* client = stt_file_client_get();
271 if (NULL == client) {
272 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to notify error : A handle is not valid");
276 if (NULL != time_info) {
277 client->time_info = time_info;
280 if (NULL != client->recognition_result_cb) {
281 stt_file_client_use_callback(client);
282 client->recognition_result_cb(event, data, data_count, msg, client->recognition_result_user_data);
283 stt_file_client_not_use_callback(client);
284 SLOG(LOG_DEBUG, TAG_STTFC, "client recognition result callback called");
286 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] User recognition result callback is NULL");
289 client->time_info = NULL;
291 if (STTE_RESULT_EVENT_FINAL_RESULT == event || STTE_RESULT_EVENT_ERROR == event) {
292 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] State change : 'Ready'");
294 client->before_state = client->current_state;
295 client->current_state = STT_FILE_STATE_READY;
297 if (NULL != client->state_changed_cb) {
298 stt_file_client_use_callback(client);
299 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
300 stt_file_client_not_use_callback(client);
301 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
303 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
310 void __stt_file_speech_status_cb(stte_speech_status_e status, void *user_data)
312 /* it seems to be no necessity yet */
313 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] This callback should NOT be called.");
317 void __stt_file_error_cb(stte_error_e error, const char* msg)
319 /* it seems to be no necessity yet */
320 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Error callback is called");
324 static int __stt_file_load_engine(sttengine_info_s* engine)
326 if (NULL == engine) {
327 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Input engine is NULL");
328 return STT_FILE_ERROR_INVALID_PARAMETER;
331 if (0 != stt_engine_load(engine->engine_path, NULL)) {
332 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to load engine(%s)", engine->engine_path);
333 return STT_FILE_ERROR_OPERATION_FAILED;
336 int ret = stt_engine_initialize(true);
338 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine : id(%d) path(%s)", engine->engine_id, engine->engine_path);
339 return STT_FILE_ERROR_OPERATION_FAILED;
342 engine->is_loaded = true;
344 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE Success] Load engine id(%d) path(%s)", engine->engine_id, engine->engine_path);
346 return STT_FILE_ERROR_NONE;
349 int stt_file_initialize(void)
351 SLOG(LOG_DEBUG, TAG_STTFC, "===== Initialize STT FILE");
353 stt_file_client_s* client = stt_file_client_get();
354 if (NULL != client) {
355 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Already initialized");
356 return STT_FILE_ERROR_INVALID_STATE;
359 /* Get file name from default engine directory */
363 struct dirent *dirp = NULL;
364 dp = opendir(STT_DEFAULT_ENGINE);
367 ret = readdir_r(dp, &entry, &dirp);
369 SLOG(LOG_ERROR, TAG_STTFC, "[File ERROR] Fail to read directory");
374 sttengine_info_s* info = NULL;
378 filesize = strlen(STT_DEFAULT_ENGINE) + strlen(dirp->d_name) + 5;
379 filepath = (char*)calloc(filesize, sizeof(char));
382 if (NULL != filepath) {
383 snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE, dirp->d_name);
385 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Memory not enough!!");
389 if (false == __stt_file_is_engine(filepath)) {
390 /* get its and update engine list */
391 if (0 == __stt_file_get_engine_info(filepath, &info)) {
392 /* add engine info to g_engine_list */
393 g_engine_list = g_slist_append(g_engine_list, info);
397 if (NULL != filepath)
400 } while (NULL != dirp);
404 SLOG(LOG_WARN, TAG_STTFC, "[Engine Agent WARNING] Fail to open default directory");
407 if (0 >= g_slist_length(g_engine_list)) {
408 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Not found engine");
409 return STT_FILE_ERROR_ENGINE_NOT_FOUND;
412 ret = stt_file_client_new();
414 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to create client : %s", __stt_file_get_error_code(ret));
415 return STT_FILE_ERROR_OPERATION_FAILED;
418 client = stt_file_client_get();
419 if (NULL == client) {
420 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Not initialized");
421 return STT_FILE_ERROR_OPERATION_FAILED;
424 ret = stt_config_mgr_initialize(getpid() + STT_FILE_CONFIG_HANDLE);
426 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to init config manager : %s", __stt_file_get_error_code(ret));
427 stt_file_client_destroy();
428 return STT_FILE_ERROR_OPERATION_FAILED;
432 char* engine_id = NULL;
433 ret = stt_config_mgr_get_engine(&engine_id);
435 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Fail to get engine id : %s", __stt_file_get_error_code(ret));
436 stt_file_client_destroy();
437 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
438 __stt_file_relseae_engine_info();
439 return STT_FILE_ERROR_OPERATION_FAILED;
442 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Get engine id : %s", engine_id);
444 bool is_found = false;
446 sttengine_info_s* engine = NULL;
449 if (0 < g_slist_length(g_engine_list)) {
450 /* Get a first item */
451 iter = g_slist_nth(g_engine_list, 0);
453 while (NULL != iter) {
454 /* Get handle data from list */
457 if (0 == strcmp(engine->engine_uuid, engine_id)) {
462 iter = g_slist_next(iter);
466 if (NULL != engine_id) free(engine_id);
468 if (false == is_found) {
470 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Fail to find default engine");
471 iter = g_slist_nth(g_engine_list, 0);
475 if (NULL == engine) {
476 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
477 stt_file_client_destroy();
478 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
479 __stt_file_relseae_engine_info();
480 return STT_FILE_ERROR_OPERATION_FAILED;
482 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] Set default engine (%s)", engine->engine_name);
485 ret = __stt_file_load_engine(engine);
487 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
488 stt_file_client_destroy();
489 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
490 __stt_file_relseae_engine_info();
491 return STT_FILE_ERROR_OPERATION_FAILED;
494 client->current_engine_id = engine->engine_id;
496 stt_network_initialize();
498 SECURE_SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE Success] Initialize : pid(%d)", getpid());
500 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
501 SLOG(LOG_DEBUG, TAG_STTFC, " ");
503 return STT_FILE_ERROR_NONE;
506 int stt_file_deinitialize(void)
508 SLOG(LOG_DEBUG, TAG_STTFC, "===== Deinitialize STT FILE");
510 stt_file_client_s* client = stt_file_client_get();
511 if (NULL == client) {
512 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Not initialized");
513 return STT_FILE_ERROR_INVALID_STATE;
516 /* check used callback */
517 if (0 != stt_file_client_get_use_callback(client)) {
518 SLOG(LOG_ERROR, TAG_STTFC, "[STT FILE ERROR] Client should NOT deinitialize STT FILE in callback function");
519 return STT_FILE_ERROR_OPERATION_FAILED;
522 stt_network_finalize();
524 stt_config_mgr_finalize(getpid() + STT_FILE_CONFIG_HANDLE);
527 switch (client->current_state) {
528 case STT_FILE_STATE_PROCESSING:
529 /* Cancel file recognition */
530 stt_engine_recognize_cancel_file();
532 case STT_FILE_STATE_READY:
534 __stt_file_relseae_engine_info();
537 stt_file_client_destroy();
540 case STT_FILE_STATE_NONE:
541 SLOG(LOG_WARN, TAG_STTFC, "[STT FILE WARNING] NOT initialized");
547 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
548 SLOG(LOG_DEBUG, TAG_STTFC, " ");
550 return STT_FILE_ERROR_NONE;
553 int stt_file_get_state(stt_file_state_e* state)
556 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
557 return STT_FILE_ERROR_INVALID_PARAMETER;
560 stt_file_client_s* client = stt_file_client_get();
562 if (NULL == client) {
563 SLOG(LOG_DEBUG, TAG_STTFC, "[STT FILE] Not initialized");
564 *state = STT_FILE_STATE_NONE;
565 return STT_FILE_ERROR_NONE;
568 *state = client->current_state;
571 case STT_FILE_STATE_NONE: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'NONE'"); break;
572 case STT_FILE_STATE_READY: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Ready'"); break;
573 case STT_FILE_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTFC, "Current state is 'Processing'"); break;
574 default: SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid value"); break;
577 return STT_FILE_ERROR_NONE;
580 int stt_file_foreach_supported_engines(stt_file_supported_engine_cb callback, void* user_data)
582 SLOG(LOG_DEBUG, TAG_STTFC, "===== Foreach Supported engine");
584 if (NULL == callback) {
585 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
586 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
587 SLOG(LOG_DEBUG, TAG_STTFC, " ");
588 return STT_FILE_ERROR_INVALID_PARAMETER;
591 stt_file_client_s* client = stt_file_client_get();
594 if (NULL == client) {
595 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
596 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
597 SLOG(LOG_DEBUG, TAG_STTFC, " ");
598 return STT_FILE_ERROR_INVALID_PARAMETER;
601 if (client->current_state != STT_FILE_STATE_READY) {
602 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state);
603 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
604 SLOG(LOG_DEBUG, TAG_STTFC, " ");
605 return STT_FILE_ERROR_INVALID_STATE;
609 sttengine_info_s *engine = NULL;
611 /* Get a first item */
612 iter = g_slist_nth(g_engine_list, 0);
614 while (NULL != iter) {
615 /* Get handle data from list */
618 if (NULL != engine) {
619 if (false == callback(engine->engine_uuid, engine->engine_name, user_data)) {
623 iter = g_slist_next(iter);
626 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
627 SLOG(LOG_DEBUG, TAG_STTFC, " ");
629 return STT_FILE_ERROR_NONE;
632 int stt_file_get_engine(char** engine_id)
634 SLOG(LOG_DEBUG, TAG_STTFC, "===== Get current engine");
636 if (NULL == engine_id) {
637 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
638 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
639 SLOG(LOG_DEBUG, TAG_STTFC, " ");
640 return STT_FILE_ERROR_INVALID_PARAMETER;
643 stt_file_client_s* client = stt_file_client_get();
646 if (NULL == client) {
647 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
648 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
649 SLOG(LOG_DEBUG, TAG_STTFC, " ");
650 return STT_FILE_ERROR_INVALID_PARAMETER;
653 if (client->current_state != STT_FILE_STATE_READY) {
654 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state);
655 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
656 SLOG(LOG_DEBUG, TAG_STTFC, " ");
657 return STT_FILE_ERROR_INVALID_STATE;
660 sttengine_info_s* engine = NULL;
661 engine = __stt_file_get_engine_by_id(client->current_engine_id);
662 if (NULL == engine) {
663 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
664 return STT_FILE_ERROR_OPERATION_FAILED;
667 *engine_id = strdup(engine->engine_uuid);
669 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
670 SLOG(LOG_DEBUG, TAG_STTFC, " ");
672 return STT_FILE_ERROR_NONE;
675 int stt_file_set_engine(const char* engine_id)
677 SLOG(LOG_DEBUG, TAG_STTFC, "===== Set current engine");
679 if (NULL == engine_id) {
680 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
681 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
682 SLOG(LOG_DEBUG, TAG_STTFC, " ");
683 return STT_FILE_ERROR_INVALID_PARAMETER;
686 stt_file_client_s* client = stt_file_client_get();
689 if (NULL == client) {
690 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
691 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
692 SLOG(LOG_DEBUG, TAG_STTFC, " ");
693 return STT_FILE_ERROR_INVALID_PARAMETER;
697 if (client->current_state != STT_FILE_STATE_READY) {
698 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not 'Ready'", client->current_state);
699 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
700 SLOG(LOG_DEBUG, TAG_STTFC, " ");
701 return STT_FILE_ERROR_INVALID_STATE;
705 sttengine_info_s *engine = NULL;
707 int temp_old_engine = -1;
709 /* Get a first item */
710 iter = g_slist_nth(g_engine_list, 0);
712 while (NULL != iter) {
713 /* Get handle data from list */
716 if (0 == strcmp(engine->engine_uuid, engine_id)) {
717 if (client->current_engine_id != engine->engine_id) {
718 temp_old_engine = client->current_engine_id;
720 SLOG(LOG_DEBUG, TAG_STTFC, "Already loaded engine : %s", engine_id);
727 iter = g_slist_next(iter);
731 if (NULL == engine) {
732 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Engine id is NOT valid");
733 return STT_FILE_ERROR_INVALID_PARAMETER;
736 int ret = __stt_file_load_engine(engine);
738 SLOG(LOG_ERROR, TAG_STTFC, "[Engine Agent ERROR] Fail to initialize engine");
739 return STT_FILE_ERROR_OPERATION_FAILED;
742 client->current_engine_id = engine->engine_id;
744 if (-1 != temp_old_engine) {
745 stt_engine_deinitialize();
749 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
750 SLOG(LOG_DEBUG, TAG_STTFC, " ");
755 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
757 stt_file_client_s* client = stt_file_client_get();
758 if (NULL == client) {
759 SLOG(LOG_ERROR, TAG_STTFC, "[WARNING] A handle is not valid");
763 /* call callback function */
764 if (NULL != client->supported_lang_cb) {
765 return client->supported_lang_cb(language, client->supported_lang_user_data);
767 SLOG(LOG_WARN, TAG_STTFC, "No registered callback function of supported languages");
773 int stt_file_foreach_supported_languages(stt_file_supported_language_cb callback, void* user_data)
775 SLOG(LOG_DEBUG, TAG_STTFC, "===== Foreach Supported Language");
777 if (NULL == callback) {
778 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
779 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
780 SLOG(LOG_DEBUG, TAG_STTFC, " ");
781 return STT_FILE_ERROR_INVALID_PARAMETER;
784 stt_file_client_s* client = stt_file_client_get();
787 if (NULL == client) {
788 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
789 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
790 SLOG(LOG_DEBUG, TAG_STTFC, " ");
791 return STT_FILE_ERROR_INVALID_PARAMETER;
794 sttengine_info_s* engine = NULL;
795 engine = __stt_file_get_engine_by_id(client->current_engine_id);
796 if (NULL == engine) {
797 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
798 return STT_FILE_ERROR_OPERATION_FAILED;
801 client->supported_lang_cb = callback;
802 client->supported_lang_user_data = user_data;
805 ret = stt_config_mgr_get_language_list(engine->engine_uuid, __stt_config_supported_language_cb, NULL);
807 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get languages");
810 client->supported_lang_cb = NULL;
811 client->supported_lang_user_data = NULL;
813 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
814 SLOG(LOG_DEBUG, TAG_STTFC, " ");
816 return STT_FILE_ERROR_NONE;
819 int stt_file_start(const char* language, const char* type, const char* filepath,
820 stt_file_audio_type_e audio_type, int sample_rate)
822 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE START");
824 stt_file_client_s* client = stt_file_client_get();
827 if (NULL == client) {
828 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
829 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
830 SLOG(LOG_DEBUG, TAG_STTFC, " ");
831 return STT_FILE_ERROR_INVALID_STATE;
835 if (client->current_state != STT_FILE_STATE_READY) {
836 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
837 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
838 SLOG(LOG_DEBUG, TAG_STTFC, " ");
839 return STT_FILE_ERROR_INVALID_STATE;
842 if (NULL == language || NULL == filepath) {
843 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
844 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
845 SLOG(LOG_DEBUG, TAG_STTFC, " ");
846 return STT_FILE_ERROR_INVALID_PARAMETER;
849 /* check if engine use network */
850 sttengine_info_s* engine = NULL;
851 engine = __stt_file_get_engine_by_id(client->current_engine_id);
852 if (NULL == engine) {
853 SECURE_SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to get engine info(%d)", client->current_engine_id);
854 return STT_FILE_ERROR_OPERATION_FAILED;
857 if (true == engine->use_network) {
858 if (false == stt_network_is_connected()) {
859 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Disconnect network. Current engine needs to network connection.");
860 return STT_FILE_ERROR_OUT_OF_NETWORK;
864 SLOG(LOG_DEBUG, TAG_STTFC, "[START Info] Engine(%d) Lang(%s) Type(%s) Filepath(%s) Audio(%d) Sample rate(%d)",
865 client->current_engine_id, language, type, filepath, audio_type, sample_rate);
868 ret = stt_engine_recognize_start_file(language, type, filepath, audio_type, sample_rate, NULL);
870 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to start file recognition");
871 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
872 SLOG(LOG_DEBUG, TAG_STTFC, " ");
873 return STT_FILE_ERROR_OPERATION_FAILED;
876 client->before_state = client->current_state;
877 client->current_state = STT_FILE_STATE_PROCESSING;
879 if (NULL != client->state_changed_cb) {
880 stt_file_client_use_callback(client);
881 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
882 stt_file_client_not_use_callback(client);
883 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
885 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
888 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
889 SLOG(LOG_DEBUG, TAG_STTFC, " ");
891 return STT_FILE_ERROR_NONE;
894 int stt_file_cancel(void)
896 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE CANCEL");
898 stt_file_client_s* client = stt_file_client_get();
901 if (NULL == client) {
902 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
903 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
904 SLOG(LOG_DEBUG, TAG_STTFC, " ");
905 return STT_FILE_ERROR_INVALID_PARAMETER;
909 if (STT_FILE_STATE_PROCESSING != client->current_state) {
910 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Invalid state : Current state(%d) is NOT 'Processing'", client->current_state);
911 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
912 SLOG(LOG_DEBUG, TAG_STTFC, " ");
913 return STT_FILE_ERROR_INVALID_STATE;
917 ret = stt_engine_recognize_cancel_file();
919 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to cancel file recognition");
920 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
921 SLOG(LOG_DEBUG, TAG_STTFC, " ");
922 return STT_FILE_ERROR_OPERATION_FAILED;
925 client->before_state = client->current_state;
926 client->current_state = STT_FILE_STATE_READY;
928 if (NULL != client->state_changed_cb) {
929 stt_file_client_use_callback(client);
930 client->state_changed_cb(client->before_state, client->current_state, client->state_changed_user_data);
931 stt_file_client_not_use_callback(client);
932 SLOG(LOG_DEBUG, TAG_STTFC, "State changed callback is called");
934 SLOG(LOG_WARN, TAG_STTFC, "[WARNING] State changed callback is null");
937 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
938 SLOG(LOG_DEBUG, TAG_STTFC, " ");
940 return STT_FILE_ERROR_NONE;
943 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)
945 SLOG(LOG_DEBUG, TAG_STTFC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
946 index, event, text, start_time, end_time);
948 stt_file_client_s* client = stt_file_client_get();
951 if (NULL == client) {
952 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to notify error : A handle is not valid");
956 if (NULL != client->result_time_cb) {
957 client->result_time_cb(index, (stt_file_result_time_event_e)event,
958 text, start_time, end_time, client->result_time_user_data);
960 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Callback is NULL");
967 int stt_file_foreach_detailed_result(stt_file_result_time_cb callback, void* user_data)
969 SLOG(LOG_DEBUG, TAG_STTFC, "===== STT FILE FOREACH DETAILED RESULT");
971 if (NULL == callback) {
972 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Input parameter is NULL");
973 return STT_FILE_ERROR_INVALID_PARAMETER;
976 stt_file_client_s* client = stt_file_client_get();
979 if (NULL == client) {
980 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail : A handle is not valid");
981 return STT_FILE_ERROR_INVALID_PARAMETER;
984 client->result_time_cb = callback;
985 client->result_time_user_data = user_data;
987 stt_engine_foreach_result_time(client->time_info, __stt_file_result_time_cb, NULL);
989 client->result_time_cb = NULL;
990 client->result_time_user_data = NULL;
992 SLOG(LOG_DEBUG, TAG_STTFC, "=====");
993 SLOG(LOG_DEBUG, TAG_STTFC, " ");
995 return STT_FILE_ERROR_NONE;
998 int stt_file_set_recognition_result_cb(stt_file_recognition_result_cb callback, void* user_data)
1000 if (NULL == callback)
1001 return STT_FILE_ERROR_INVALID_PARAMETER;
1003 stt_file_client_s* client = stt_file_client_get();
1006 if (NULL == client) {
1007 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1008 return STT_FILE_ERROR_INVALID_PARAMETER;
1011 if (STT_FILE_STATE_READY != client->current_state) {
1012 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state);
1013 return STT_FILE_ERROR_INVALID_STATE;
1016 int ret = stt_engine_set_recognition_result_cb(__stt_file_result_cb, NULL);
1018 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to set recognition result cb");
1021 client->recognition_result_cb = callback;
1022 client->recognition_result_user_data = user_data;
1027 int stt_file_unset_recognition_result_cb(void)
1029 stt_file_client_s* client = stt_file_client_get();
1032 if (NULL == client) {
1033 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1034 return STT_FILE_ERROR_INVALID_PARAMETER;
1037 if (STT_FILE_STATE_READY != client->current_state) {
1038 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state);
1039 return STT_FILE_ERROR_INVALID_STATE;
1042 int ret = stt_engine_set_recognition_result_cb(NULL, NULL);
1044 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Fail to set recognition result cb");
1047 client->recognition_result_cb = NULL;
1048 client->recognition_result_user_data = NULL;
1053 int stt_file_set_state_changed_cb(stt_file_state_changed_cb callback, void* user_data)
1055 if (NULL == callback)
1056 return STT_FILE_ERROR_INVALID_PARAMETER;
1058 stt_file_client_s* client = stt_file_client_get();
1061 if (NULL == client) {
1062 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1063 return STT_FILE_ERROR_INVALID_PARAMETER;
1066 if (STT_FILE_STATE_READY != client->current_state) {
1067 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state);
1068 return STT_FILE_ERROR_INVALID_STATE;
1071 client->state_changed_cb = callback;
1072 client->state_changed_user_data = user_data;
1077 int stt_file_unset_state_changed_cb(void)
1079 stt_file_client_s* client = stt_file_client_get();
1082 if (NULL == client) {
1083 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] A handle is not available");
1084 return STT_FILE_ERROR_INVALID_PARAMETER;
1087 if (STT_FILE_STATE_READY != client->current_state) {
1088 SLOG(LOG_ERROR, TAG_STTFC, "[ERROR] Current state(%d) is not 'ready'", client->current_state);
1089 return STT_FILE_ERROR_INVALID_STATE;
1092 client->state_changed_cb = NULL;
1093 client->state_changed_user_data = NULL;