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.
20 #include <sys/types.h>
22 #include <system_info.h>
26 #include "stt_client.h"
28 #include "stt_config_mgr.h"
32 static void __stt_notify_state_changed(void *data);
33 static Eina_Bool __stt_notify_error(void *data);
35 static Ecore_Timer* g_connect_timer = NULL;
36 static float g_volume_db = 0;
38 static int g_feature_enabled = -1;
45 static int __stt_get_feature_enabled()
47 if (0 == g_feature_enabled) {
48 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
49 return STT_ERROR_NOT_SUPPORTED;
50 } else if (-1 == g_feature_enabled) {
51 bool stt_supported = false;
52 bool mic_supported = false;
53 if (0 == system_info_get_platform_bool(STT_FEATURE_PATH, &stt_supported)) {
54 if (0 == system_info_get_platform_bool(STT_MIC_FEATURE_PATH, &mic_supported)) {
55 if (false == stt_supported || false == mic_supported) {
56 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
57 g_feature_enabled = 0;
58 return STT_ERROR_NOT_SUPPORTED;
61 g_feature_enabled = 1;
63 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
64 return STT_ERROR_NOT_SUPPORTED;
67 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
68 return STT_ERROR_NOT_SUPPORTED;
75 static const char* __stt_get_error_code(stt_error_e err)
78 case STT_ERROR_NONE: return "STT_ERROR_NONE";
79 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
80 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
81 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
82 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
83 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
84 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
85 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
86 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
87 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
88 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
89 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
90 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
91 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
93 return "Invalid error code";
97 static int __stt_convert_config_error_code(stt_config_error_e code)
99 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
100 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
101 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
102 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
103 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
104 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
105 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
106 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
107 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
108 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
113 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
115 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
116 before_language, current_language);
118 if (0 == strcmp(before_language, current_language)) {
122 GList* client_list = NULL;
123 client_list = stt_client_get_client_list();
126 stt_client_s *data = NULL;
128 if (g_list_length(client_list) > 0) {
129 /* Get a first item */
130 iter = g_list_first(client_list);
132 while (NULL != iter) {
134 if (NULL != data->default_lang_changed_cb) {
135 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
136 data->default_lang_changed_cb(data->stt, before_language, current_language,
137 data->default_lang_changed_user_data);
141 iter = g_list_next(iter);
148 int stt_create(stt_h* stt)
150 if (0 != __stt_get_feature_enabled()) {
151 return STT_ERROR_NOT_SUPPORTED;
154 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
157 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
158 return STT_ERROR_INVALID_PARAMETER;
161 if (0 == stt_client_get_size()) {
162 if (0 != stt_dbus_open_connection()) {
163 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
164 return STT_ERROR_OPERATION_FAILED;
168 if (0 != stt_client_new(stt)) {
169 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
170 return STT_ERROR_OUT_OF_MEMORY;
173 stt_client_s* client = stt_client_get(*stt);
174 if (NULL == client) {
175 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
176 stt_client_destroy(*stt);
177 return STT_ERROR_OPERATION_FAILED;
180 int ret = stt_config_mgr_initialize(client->uid);
181 ret = __stt_convert_config_error_code(ret);
183 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
184 stt_client_destroy(*stt);
188 ret = stt_config_mgr_set_callback(client->uid, NULL, __stt_config_lang_changed_cb, NULL, NULL);
189 ret = __stt_convert_config_error_code(ret);
191 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
192 stt_client_destroy(*stt);
196 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
198 SLOG(LOG_DEBUG, TAG_STTC, "=====");
199 SLOG(LOG_DEBUG, TAG_STTC, " ");
201 return STT_ERROR_NONE;
204 int stt_destroy(stt_h stt)
206 if (0 != __stt_get_feature_enabled()) {
207 return STT_ERROR_NOT_SUPPORTED;
210 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
213 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
214 return STT_ERROR_INVALID_PARAMETER;
217 stt_client_s* client = stt_client_get(stt);
220 if (NULL == client) {
221 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
222 return STT_ERROR_INVALID_PARAMETER;
225 /* check used callback */
226 if (0 != stt_client_get_use_callback(client)) {
227 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
228 return STT_ERROR_OPERATION_FAILED;
231 stt_config_mgr_finalize(client->uid);
236 switch (client->current_state) {
237 case STT_STATE_PROCESSING:
238 case STT_STATE_RECORDING:
239 case STT_STATE_READY:
240 ret = stt_dbus_request_finalize(client->uid);
242 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
244 case STT_STATE_CREATED:
245 if (NULL != g_connect_timer) {
246 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
247 ecore_timer_del(g_connect_timer);
248 g_connect_timer = NULL;
252 stt_client_destroy(stt);
258 if (0 == stt_client_get_size()) {
259 if (0 != stt_dbus_close_connection()) {
260 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
266 SLOG(LOG_DEBUG, TAG_STTC, "=====");
267 SLOG(LOG_DEBUG, TAG_STTC, " ");
269 return STT_ERROR_NONE;
272 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
273 const char* setting, bool support_silence, void* user_data)
275 stt_h stt = (stt_h)user_data;
277 stt_client_s* client = stt_client_get(stt);
278 if (NULL == client) {
279 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
283 /* call callback function */
284 if (NULL != client->supported_engine_cb) {
285 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
287 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
293 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
295 if (0 != __stt_get_feature_enabled()) {
296 return STT_ERROR_NOT_SUPPORTED;
299 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
301 if (NULL == stt || NULL == callback) {
302 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
303 return STT_ERROR_INVALID_PARAMETER;
306 stt_client_s* client = stt_client_get(stt);
309 if (NULL == client) {
310 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
311 return STT_ERROR_INVALID_PARAMETER;
314 if (client->current_state != STT_STATE_CREATED) {
315 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
316 return STT_ERROR_INVALID_STATE;
319 client->supported_engine_cb = callback;
320 client->supported_engine_user_data = user_data;
323 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
324 ret = __stt_convert_config_error_code(ret);
326 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
329 client->supported_engine_cb = NULL;
330 client->supported_engine_user_data = NULL;
332 SLOG(LOG_DEBUG, TAG_STTC, "=====");
333 SLOG(LOG_DEBUG, TAG_STTC, " ");
338 int stt_get_engine(stt_h stt, char** engine_id)
340 if (0 != __stt_get_feature_enabled()) {
341 return STT_ERROR_NOT_SUPPORTED;
344 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
346 if (NULL == stt || NULL == engine_id) {
347 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
348 return STT_ERROR_INVALID_PARAMETER;
351 stt_client_s* client = stt_client_get(stt);
354 if (NULL == client) {
355 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
356 return STT_ERROR_INVALID_PARAMETER;
359 if (client->current_state != STT_STATE_CREATED) {
360 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
361 return STT_ERROR_INVALID_STATE;
366 if (NULL != client->current_engine_id) {
367 *engine_id = strdup(client->current_engine_id);
368 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
371 ret = stt_config_mgr_get_engine(engine_id);
372 ret = __stt_convert_config_error_code(ret);
374 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
376 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
380 SLOG(LOG_DEBUG, TAG_STTC, "=====");
381 SLOG(LOG_DEBUG, TAG_STTC, " ");
386 int stt_set_engine(stt_h stt, const char* engine_id)
388 if (0 != __stt_get_feature_enabled()) {
389 return STT_ERROR_NOT_SUPPORTED;
392 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
394 if (NULL == stt || NULL == engine_id) {
395 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
396 return STT_ERROR_INVALID_PARAMETER;
399 stt_client_s* client = stt_client_get(stt);
402 if (NULL == client) {
403 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
404 return STT_ERROR_INVALID_PARAMETER;
408 if (client->current_state != STT_STATE_CREATED) {
409 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
410 return STT_ERROR_INVALID_STATE;
413 if (NULL != client->current_engine_id) {
414 free(client->current_engine_id);
417 client->current_engine_id = strdup(engine_id);
419 SLOG(LOG_DEBUG, TAG_STTC, "=====");
420 SLOG(LOG_DEBUG, TAG_STTC, " ");
425 static Eina_Bool __stt_connect_daemon(void *data)
427 stt_client_s* client = (stt_client_s*)data;
429 if (NULL == client) {
430 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
431 g_connect_timer = NULL;
437 ret = stt_dbus_request_hello();
440 if (STT_ERROR_INVALID_STATE == ret) {
441 g_connect_timer = NULL;
447 g_connect_timer = NULL;
448 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
450 /* request initialization */
451 bool silence_supported = false;
453 ret = stt_dbus_request_initialize(client->uid, &silence_supported);
455 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
456 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
458 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
459 ecore_timer_add(0, __stt_notify_error, (void*)client);
463 } else if (STT_ERROR_NONE != ret) {
464 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
467 /* success to connect stt-daemon */
468 client->silence_supported = silence_supported;
469 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s)", silence_supported ? "true" : "false");
472 if (NULL != client->current_engine_id) {
475 silence_supported = false;
477 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported);
479 if (STT_ERROR_TIMED_OUT != ret) {
480 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
483 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
486 if (STT_RETRY_COUNT == count) {
487 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
492 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
494 /* success to change engine */
495 client->silence_supported = silence_supported;
496 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s)", silence_supported ? "true" : "false");
501 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
503 client->before_state = client->current_state;
504 client->current_state = STT_STATE_READY;
506 if (NULL != client->state_changed_cb) {
507 stt_client_use_callback(client);
508 client->state_changed_cb(client->stt, client->before_state,
509 client->current_state, client->state_changed_user_data);
510 stt_client_not_use_callback(client);
511 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
513 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
516 SLOG(LOG_DEBUG, TAG_STTC, "=====");
517 SLOG(LOG_DEBUG, TAG_STTC, " ");
522 int stt_prepare(stt_h stt)
524 if (0 != __stt_get_feature_enabled()) {
525 return STT_ERROR_NOT_SUPPORTED;
528 SLOG(LOG_DEBUG, TAG_STTC, "===== Prepare STT");
530 stt_client_s* client = stt_client_get(stt);
533 if (NULL == client) {
534 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
535 return STT_ERROR_INVALID_PARAMETER;
539 if (client->current_state != STT_STATE_CREATED) {
540 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
541 return STT_ERROR_INVALID_STATE;
544 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
546 SLOG(LOG_DEBUG, TAG_STTC, "=====");
547 SLOG(LOG_DEBUG, TAG_STTC, " ");
549 return STT_ERROR_NONE;
552 int stt_unprepare(stt_h stt)
554 if (0 != __stt_get_feature_enabled()) {
555 return STT_ERROR_NOT_SUPPORTED;
558 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
560 stt_client_s* client = stt_client_get(stt);
563 if (NULL == client) {
564 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
565 return STT_ERROR_INVALID_PARAMETER;
569 if (client->current_state != STT_STATE_READY) {
570 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
571 return STT_ERROR_INVALID_STATE;
577 ret = stt_dbus_request_finalize(client->uid);
579 if (STT_ERROR_TIMED_OUT != ret) {
580 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
583 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
586 if (STT_RETRY_COUNT == count) {
587 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
594 client->internal_state = STT_INTERNAL_STATE_NONE;
596 client->before_state = client->current_state;
597 client->current_state = STT_STATE_CREATED;
599 if (NULL != client->state_changed_cb) {
600 stt_client_use_callback(client);
601 client->state_changed_cb(client->stt, client->before_state,
602 client->current_state, client->state_changed_user_data);
603 stt_client_not_use_callback(client);
605 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
608 if(g_connect_timer) {
609 ecore_timer_del(g_connect_timer);
610 g_connect_timer = NULL;
613 SLOG(LOG_DEBUG, TAG_STTC, "=====");
614 SLOG(LOG_DEBUG, TAG_STTC, " ");
616 return STT_ERROR_NONE;
619 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
621 stt_h stt = (stt_h)user_data;
623 stt_client_s* client = stt_client_get(stt);
624 if (NULL == client) {
625 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
629 /* call callback function */
630 if (NULL != client->supported_lang_cb) {
631 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
633 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
639 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
641 if (0 != __stt_get_feature_enabled()) {
642 return STT_ERROR_NOT_SUPPORTED;
645 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
647 if (NULL == stt || NULL == callback) {
648 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
649 return STT_ERROR_INVALID_PARAMETER;
652 stt_client_s* client = stt_client_get(stt);
655 if (NULL == client) {
656 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
657 return STT_ERROR_INVALID_PARAMETER;
661 char* current_engine_id = NULL;
663 if (NULL == client->current_engine_id) {
664 ret = stt_config_mgr_get_engine(¤t_engine_id);
665 ret = __stt_convert_config_error_code(ret);
667 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
671 current_engine_id = strdup(client->current_engine_id);
672 if (NULL == current_engine_id) {
673 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
674 return STT_ERROR_OUT_OF_MEMORY;
678 client->supported_lang_cb = callback;
679 client->supported_lang_user_data = user_data;
681 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
682 ret = __stt_convert_config_error_code(ret);
684 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
687 if (NULL != current_engine_id) {
688 free(current_engine_id);
691 client->supported_lang_cb = NULL;
692 client->supported_lang_user_data = NULL;
694 SLOG(LOG_DEBUG, TAG_STTC, "=====");
695 SLOG(LOG_DEBUG, TAG_STTC, " ");
700 int stt_get_default_language(stt_h stt, char** language)
702 if (0 != __stt_get_feature_enabled()) {
703 return STT_ERROR_NOT_SUPPORTED;
706 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
708 if (NULL == stt || NULL == language) {
709 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
710 return STT_ERROR_INVALID_PARAMETER;
713 stt_client_s* client = stt_client_get(stt);
714 if (NULL == client) {
715 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
716 return STT_ERROR_INVALID_PARAMETER;
720 ret = stt_config_mgr_get_default_language(language);
721 ret = __stt_convert_config_error_code(ret);
723 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
725 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
728 SLOG(LOG_DEBUG, TAG_STTC, "=====");
729 SLOG(LOG_DEBUG, TAG_STTC, " ");
734 int stt_get_state(stt_h stt, stt_state_e* state)
736 if (0 != __stt_get_feature_enabled()) {
737 return STT_ERROR_NOT_SUPPORTED;
740 if (NULL == stt || NULL == state) {
741 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
742 return STT_ERROR_INVALID_PARAMETER;
745 stt_client_s* client = stt_client_get(stt);
746 if (NULL == client) {
747 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
748 return STT_ERROR_INVALID_PARAMETER;
751 *state = client->current_state;
754 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
755 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
756 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
757 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
758 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
761 return STT_ERROR_NONE;
764 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
766 if (0 != __stt_get_feature_enabled()) {
767 return STT_ERROR_NOT_SUPPORTED;
770 if (NULL == stt || NULL == type || NULL == support) {
771 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
772 return STT_ERROR_INVALID_PARAMETER;
775 stt_client_s* client = stt_client_get(stt);
776 if (NULL == client) {
777 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not valid");
778 return STT_ERROR_INVALID_PARAMETER;
782 if (client->current_state != STT_STATE_READY) {
783 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
784 return STT_ERROR_INVALID_STATE;
790 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
792 if (STT_ERROR_TIMED_OUT != ret) {
793 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
796 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
799 if (STT_RETRY_COUNT == count) {
800 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
805 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
810 return STT_ERROR_NONE;
813 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
815 if (0 != __stt_get_feature_enabled()) {
816 return STT_ERROR_NOT_SUPPORTED;
820 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
821 return STT_ERROR_INVALID_PARAMETER;
824 stt_client_s* client = stt_client_get(stt);
825 if (NULL == client) {
826 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
827 return STT_ERROR_INVALID_PARAMETER;
831 if (client->current_state != STT_STATE_READY) {
832 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
833 return STT_ERROR_INVALID_STATE;
836 if (true == client->silence_supported) {
837 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
838 client->silence = type;
840 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
841 return STT_ERROR_INVALID_PARAMETER;
844 return STT_ERROR_NOT_SUPPORTED_FEATURE;
847 return STT_ERROR_NONE;
850 int stt_set_start_sound(stt_h stt, const char* filename)
852 if (0 != __stt_get_feature_enabled()) {
853 return STT_ERROR_NOT_SUPPORTED;
856 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
858 if (NULL == stt || NULL == filename) {
859 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
860 return STT_ERROR_INVALID_PARAMETER;
863 if (0 != access(filename, F_OK)) {
864 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
865 return STT_ERROR_INVALID_PARAMETER;
868 stt_client_s* client = stt_client_get(stt);
869 if (NULL == client) {
870 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
871 return STT_ERROR_INVALID_PARAMETER;
875 if (client->current_state != STT_STATE_READY) {
876 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
877 return STT_ERROR_INVALID_STATE;
883 ret = stt_dbus_request_set_start_sound(client->uid, filename);
885 if (STT_ERROR_TIMED_OUT != ret) {
886 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
889 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
892 if (STT_RETRY_COUNT == count) {
893 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
898 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
903 return STT_ERROR_NONE;
906 int stt_unset_start_sound(stt_h stt)
908 if (0 != __stt_get_feature_enabled()) {
909 return STT_ERROR_NOT_SUPPORTED;
912 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
915 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
916 return STT_ERROR_INVALID_PARAMETER;
919 stt_client_s* client = stt_client_get(stt);
921 if (NULL == client) {
922 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
923 return STT_ERROR_INVALID_PARAMETER;
927 if (client->current_state != STT_STATE_READY) {
928 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
929 return STT_ERROR_INVALID_STATE;
935 ret = stt_dbus_request_unset_start_sound(client->uid);
937 if (STT_ERROR_TIMED_OUT != ret) {
938 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
941 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
944 if (STT_RETRY_COUNT == count) {
945 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
950 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
955 return STT_ERROR_NONE;
958 int stt_set_stop_sound(stt_h stt, const char* filename)
960 if (0 != __stt_get_feature_enabled()) {
961 return STT_ERROR_NOT_SUPPORTED;
964 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
966 if (NULL == stt || NULL == filename) {
967 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
968 return STT_ERROR_INVALID_PARAMETER;
971 if (0 != access(filename, F_OK)) {
972 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
973 return STT_ERROR_INVALID_PARAMETER;
976 stt_client_s* client = stt_client_get(stt);
978 if (NULL == client) {
979 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
980 return STT_ERROR_INVALID_PARAMETER;
984 if (client->current_state != STT_STATE_READY) {
985 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
986 return STT_ERROR_INVALID_STATE;
992 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
994 if (STT_ERROR_TIMED_OUT != ret) {
995 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
998 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1001 if (STT_RETRY_COUNT == count) {
1002 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1007 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1012 return STT_ERROR_NONE;
1015 int stt_unset_stop_sound(stt_h stt)
1017 if (0 != __stt_get_feature_enabled()) {
1018 return STT_ERROR_NOT_SUPPORTED;
1021 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1024 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1025 return STT_ERROR_INVALID_PARAMETER;
1028 stt_client_s* client = stt_client_get(stt);
1030 if (NULL == client) {
1031 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1032 return STT_ERROR_INVALID_PARAMETER;
1036 if (client->current_state != STT_STATE_READY) {
1037 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1038 return STT_ERROR_INVALID_STATE;
1044 ret = stt_dbus_request_unset_stop_sound(client->uid);
1046 if (STT_ERROR_TIMED_OUT != ret) {
1047 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1050 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1053 if (STT_RETRY_COUNT == count) {
1054 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1059 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1064 return STT_ERROR_NONE;
1067 int stt_start(stt_h stt, const char* language, const char* type)
1069 if (0 != __stt_get_feature_enabled()) {
1070 return STT_ERROR_NOT_SUPPORTED;
1073 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1076 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1077 return STT_ERROR_INVALID_PARAMETER;
1080 stt_client_s* client = stt_client_get(stt);
1081 if (NULL == client) {
1082 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1083 return STT_ERROR_INVALID_PARAMETER;
1087 if (client->current_state != STT_STATE_READY) {
1088 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1089 return STT_ERROR_INVALID_STATE;
1092 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1093 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1094 return STT_ERROR_INVALID_STATE;
1098 char appid[128] = {0, };
1099 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1101 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1102 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1104 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1108 if (NULL == language) {
1109 temp = strdup("default");
1111 temp = strdup(language);
1119 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid);
1122 if (STT_ERROR_TIMED_OUT != ret) {
1123 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1124 if (NULL != temp) free(temp);
1127 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry to start");
1130 if (STT_RETRY_COUNT == count) {
1131 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1132 if (NULL != temp) free(temp);
1138 if (NULL != temp) free(temp);
1140 if (STT_RESULT_STATE_DONE == ret) {
1141 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is done : %d", ret);
1142 client->before_state = client->current_state;
1143 client->current_state = STT_STATE_RECORDING;
1145 if (NULL != client->state_changed_cb) {
1146 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1148 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1150 } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1151 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is not done : %d", ret);
1152 client->internal_state = STT_INTERNAL_STATE_STARTING;
1154 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1157 ret = STT_ERROR_NONE;
1162 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid);
1164 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1166 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1167 client->internal_state = STT_INTERNAL_STATE_STARTING;
1170 if (NULL != temp) free(temp);
1172 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1173 SLOG(LOG_DEBUG, TAG_STTC, " ");
1178 int stt_stop(stt_h stt)
1180 if (0 != __stt_get_feature_enabled()) {
1181 return STT_ERROR_NOT_SUPPORTED;
1184 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1187 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1188 return STT_ERROR_INVALID_PARAMETER;
1191 stt_client_s* client = stt_client_get(stt);
1192 if (NULL == client) {
1193 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1194 return STT_ERROR_INVALID_PARAMETER;
1198 if (client->current_state != STT_STATE_RECORDING) {
1199 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1200 return STT_ERROR_INVALID_STATE;
1203 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1204 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1205 return STT_ERROR_INVALID_STATE;
1212 ret = stt_dbus_request_stop(client->uid);
1215 if (STT_ERROR_TIMED_OUT != ret) {
1216 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1219 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry stop");
1222 if (STT_RETRY_COUNT == count) {
1223 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1228 if (STT_RESULT_STATE_DONE == ret) {
1229 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is done : %d", ret);
1230 client->before_state = client->current_state;
1231 client->current_state = STT_STATE_PROCESSING;
1233 if (NULL != client->state_changed_cb) {
1234 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1235 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1237 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1239 } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1240 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is not done : %d", ret);
1241 client->internal_state = STT_INTERNAL_STATE_STOPING;
1243 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1245 ret = STT_ERROR_NONE;
1250 int ret = stt_dbus_request_stop(client->uid);
1253 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1255 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1256 client->internal_state = STT_INTERNAL_STATE_STOPING;
1259 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1260 SLOG(LOG_DEBUG, TAG_STTC, " ");
1266 int stt_cancel(stt_h stt)
1268 if (0 != __stt_get_feature_enabled()) {
1269 return STT_ERROR_NOT_SUPPORTED;
1272 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1275 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
1276 return STT_ERROR_INVALID_PARAMETER;
1279 stt_client_s* client = stt_client_get(stt);
1282 if (NULL == client) {
1283 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1284 return STT_ERROR_INVALID_PARAMETER;
1288 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1289 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1290 return STT_ERROR_INVALID_STATE;
1293 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1294 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1295 return STT_ERROR_INVALID_STATE;
1302 ret = stt_dbus_request_cancel(client->uid);
1305 if (STT_ERROR_TIMED_OUT != ret) {
1306 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1309 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1312 if (STT_RETRY_COUNT == count) {
1313 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1318 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
1320 client->before_state = client->current_state;
1321 client->current_state = STT_STATE_READY;
1323 if (NULL != client->state_changed_cb) {
1324 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1325 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1327 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1329 ret = STT_ERROR_NONE;
1334 int ret = stt_dbus_request_cancel(client->uid);
1336 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1338 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1339 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1342 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1343 SLOG(LOG_DEBUG, TAG_STTC, " ");
1348 int __stt_cb_set_volume(int uid, float volume)
1350 stt_client_s* client = NULL;
1352 client = stt_client_get_by_uid(uid);
1353 if (NULL == client) {
1354 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1355 return STT_ERROR_INVALID_PARAMETER;
1358 if (STT_STATE_RECORDING != client->current_state) {
1359 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1360 return STT_ERROR_INVALID_STATE;
1363 g_volume_db = volume;
1364 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1369 int stt_get_recording_volume(stt_h stt, float* volume)
1371 if (0 != __stt_get_feature_enabled()) {
1372 return STT_ERROR_NOT_SUPPORTED;
1375 if (NULL == stt || NULL == volume) {
1376 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1377 return STT_ERROR_INVALID_PARAMETER;
1380 stt_client_s* client = stt_client_get(stt);
1383 if (NULL == client) {
1384 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1385 return STT_ERROR_INVALID_PARAMETER;
1388 if (STT_STATE_RECORDING != client->current_state) {
1389 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1390 return STT_ERROR_INVALID_STATE;
1393 *volume = g_volume_db;
1395 return STT_ERROR_NONE;
1398 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1400 stt_client_s* client = (stt_client_s*)user_data;
1403 if (NULL == client) {
1404 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1408 if (NULL != client->result_time_cb) {
1409 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1410 index, event, text, start_time, end_time);
1411 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1412 text, start_time, end_time, client->result_time_user_data);
1414 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1421 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1423 if (0 != __stt_get_feature_enabled()) {
1424 return STT_ERROR_NOT_SUPPORTED;
1427 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1429 if (NULL == callback) {
1430 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1431 return STT_ERROR_INVALID_PARAMETER;
1434 stt_client_s* client = stt_client_get(stt);
1437 if (NULL == client) {
1438 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail : A handle is not valid");
1439 return STT_ERROR_INVALID_PARAMETER;
1442 client->result_time_cb = callback;
1443 client->result_time_user_data = user_data;
1446 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1447 ret = __stt_convert_config_error_code(ret);
1449 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1452 client->result_time_cb = NULL;
1453 client->result_time_user_data = NULL;
1455 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1456 SLOG(LOG_DEBUG, TAG_STTC, " ");
1461 static Eina_Bool __stt_notify_error(void *data)
1463 stt_client_s* client = (stt_client_s*)data;
1465 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1468 if (NULL == client) {
1469 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1473 if (NULL == stt_client_get_by_uid(client->uid))
1476 if (NULL != client->error_cb) {
1477 stt_client_use_callback(client);
1478 client->error_cb(client->stt, client->reason, client->error_user_data);
1479 stt_client_not_use_callback(client);
1480 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1482 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1488 int __stt_cb_error(int uid, int reason)
1490 stt_client_s* client = stt_client_get_by_uid(uid);
1491 if( NULL == client ) {
1492 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1496 client->reason = reason;
1497 client->internal_state = STT_INTERNAL_STATE_NONE;
1498 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1500 if (NULL != client->error_cb) {
1501 ecore_timer_add(0, __stt_notify_error, client);
1503 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1509 static void __stt_notify_state_changed(void *data)
1511 stt_client_s* client = (stt_client_s*)data;
1514 if (NULL == client) {
1515 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1519 if (NULL == stt_client_get_by_uid(client->uid)) {
1523 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1524 client->internal_state = STT_INTERNAL_STATE_NONE;
1525 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1526 } else if (STT_INTERNAL_STATE_STOPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1527 client->internal_state = STT_INTERNAL_STATE_NONE;
1528 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1529 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1530 client->internal_state = STT_INTERNAL_STATE_NONE;
1531 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1534 if (NULL != client->state_changed_cb) {
1535 stt_client_use_callback(client);
1536 client->state_changed_cb(client->stt, client->before_state,
1537 client->current_state, client->state_changed_user_data);
1538 stt_client_not_use_callback(client);
1539 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1541 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1547 static Eina_Bool __stt_notify_result(void *data)
1549 stt_client_s* client = (stt_client_s*)data;
1552 if (NULL == client) {
1553 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1557 if (NULL == stt_client_get_by_uid(client->uid)) {
1561 if (NULL != client->recognition_result_cb) {
1562 stt_client_use_callback(client);
1563 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1564 client->msg, client->recognition_result_user_data);
1565 stt_client_not_use_callback(client);
1566 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1568 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1571 if (NULL != client->msg) {
1576 if (NULL != client->data_list) {
1578 temp = client->data_list;
1581 for (i = 0; i < client->data_count; i++) {
1582 if (NULL != temp[i]) {
1586 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1589 free(client->data_list);
1590 client->data_list = NULL;
1593 client->data_count = 0;
1595 stt_config_mgr_remove_time_info_file();
1597 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1598 client->before_state = client->current_state;
1599 client->current_state = STT_STATE_READY;
1601 if (NULL != client->state_changed_cb) {
1602 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1604 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1611 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1613 stt_client_s* client = NULL;
1615 client = stt_client_get_by_uid(uid);
1616 if (NULL == client) {
1617 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1618 return STT_ERROR_INVALID_PARAMETER;
1622 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1625 for (i = 0; i < data_count; i++) {
1626 if (NULL != data[i])
1627 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1630 if (NULL != client->recognition_result_cb) {
1631 client->event = event;
1633 client->msg = strdup(msg);
1636 client->data_count = data_count;
1638 if (data_count > 0) {
1640 temp = (char**)calloc(data_count, sizeof(char*));
1642 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1643 return STT_ERROR_OUT_OF_MEMORY;
1646 for (i = 0; i < data_count; i++) {
1647 if (NULL != data[i])
1648 temp[i] = strdup(data[i]);
1650 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1653 client->data_list = temp;
1656 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1659 ecore_timer_add(0, __stt_notify_result, client);
1661 return STT_ERROR_NONE;
1664 int __stt_cb_set_state(int uid, int state)
1666 stt_client_s* client = stt_client_get_by_uid(uid);
1667 if (NULL == client) {
1668 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1672 stt_state_e state_from_daemon = (stt_state_e)state;
1674 if (client->current_state == state_from_daemon) {
1675 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1679 client->before_state = client->current_state;
1680 client->current_state = state_from_daemon;
1682 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1686 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1688 if (0 != __stt_get_feature_enabled()) {
1689 return STT_ERROR_NOT_SUPPORTED;
1692 if (stt == NULL || callback == NULL)
1693 return STT_ERROR_INVALID_PARAMETER;
1695 stt_client_s* client = stt_client_get(stt);
1698 if (NULL == client) {
1699 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1700 return STT_ERROR_INVALID_PARAMETER;
1703 if (STT_STATE_CREATED != client->current_state) {
1704 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1705 return STT_ERROR_INVALID_STATE;
1708 client->recognition_result_cb = callback;
1709 client->recognition_result_user_data = user_data;
1714 int stt_unset_recognition_result_cb(stt_h stt)
1716 if (0 != __stt_get_feature_enabled()) {
1717 return STT_ERROR_NOT_SUPPORTED;
1721 return STT_ERROR_INVALID_PARAMETER;
1723 stt_client_s* client = stt_client_get(stt);
1726 if (NULL == client) {
1727 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1728 return STT_ERROR_INVALID_PARAMETER;
1731 if (STT_STATE_CREATED != client->current_state) {
1732 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1733 return STT_ERROR_INVALID_STATE;
1736 client->recognition_result_cb = NULL;
1737 client->recognition_result_user_data = NULL;
1742 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1744 if (0 != __stt_get_feature_enabled()) {
1745 return STT_ERROR_NOT_SUPPORTED;
1748 if (NULL == stt || NULL == callback)
1749 return STT_ERROR_INVALID_PARAMETER;
1751 stt_client_s* client = stt_client_get(stt);
1754 if (NULL == client) {
1755 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1756 return STT_ERROR_INVALID_PARAMETER;
1759 if (STT_STATE_CREATED != client->current_state) {
1760 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1761 return STT_ERROR_INVALID_STATE;
1764 client->state_changed_cb = callback;
1765 client->state_changed_user_data = user_data;
1770 int stt_unset_state_changed_cb(stt_h stt)
1772 if (0 != __stt_get_feature_enabled()) {
1773 return STT_ERROR_NOT_SUPPORTED;
1777 return STT_ERROR_INVALID_PARAMETER;
1779 stt_client_s* client = stt_client_get(stt);
1782 if (NULL == client) {
1783 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1784 return STT_ERROR_INVALID_PARAMETER;
1787 if (STT_STATE_CREATED != client->current_state) {
1788 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1789 return STT_ERROR_INVALID_STATE;
1792 client->state_changed_cb = NULL;
1793 client->state_changed_user_data = NULL;
1798 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1800 if (0 != __stt_get_feature_enabled()) {
1801 return STT_ERROR_NOT_SUPPORTED;
1804 if (NULL == stt || NULL == callback)
1805 return STT_ERROR_INVALID_PARAMETER;
1807 stt_client_s* client = stt_client_get(stt);
1810 if (NULL == client) {
1811 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1812 return STT_ERROR_INVALID_PARAMETER;
1815 if (STT_STATE_CREATED != client->current_state) {
1816 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1817 return STT_ERROR_INVALID_STATE;
1820 client->error_cb = callback;
1821 client->error_user_data = user_data;
1826 int stt_unset_error_cb(stt_h stt)
1828 if (0 != __stt_get_feature_enabled()) {
1829 return STT_ERROR_NOT_SUPPORTED;
1833 return STT_ERROR_INVALID_PARAMETER;
1835 stt_client_s* client = stt_client_get(stt);
1838 if (NULL == client) {
1839 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1840 return STT_ERROR_INVALID_PARAMETER;
1843 if (STT_STATE_CREATED != client->current_state) {
1844 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1845 return STT_ERROR_INVALID_STATE;
1848 client->error_cb = NULL;
1849 client->error_user_data = NULL;
1854 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
1856 if (0 != __stt_get_feature_enabled()) {
1857 return STT_ERROR_NOT_SUPPORTED;
1860 if (NULL == stt || NULL == callback)
1861 return STT_ERROR_INVALID_PARAMETER;
1863 stt_client_s* client = stt_client_get(stt);
1866 if (NULL == client) {
1867 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1868 return STT_ERROR_INVALID_PARAMETER;
1871 if (STT_STATE_CREATED != client->current_state) {
1872 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1873 return STT_ERROR_INVALID_STATE;
1876 client->default_lang_changed_cb = callback;
1877 client->default_lang_changed_user_data = user_data;
1882 int stt_unset_default_language_changed_cb(stt_h stt)
1884 if (0 != __stt_get_feature_enabled()) {
1885 return STT_ERROR_NOT_SUPPORTED;
1889 return STT_ERROR_INVALID_PARAMETER;
1891 stt_client_s* client = stt_client_get(stt);
1894 if (NULL == client) {
1895 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1896 return STT_ERROR_INVALID_PARAMETER;
1899 if (STT_STATE_CREATED != client->current_state) {
1900 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1901 return STT_ERROR_INVALID_STATE;
1904 client->default_lang_changed_cb = NULL;
1905 client->default_lang_changed_user_data = NULL;