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.
15 #include <cynara-client.h>
16 #include <cynara-error.h>
17 #include <cynara-session.h>
23 #include <sys/types.h>
25 #include <system_info.h>
29 #include "stt_client.h"
31 #include "stt_config_mgr.h"
35 static void __stt_notify_state_changed(void *data);
36 static Eina_Bool __stt_notify_error(void *data);
38 static Ecore_Timer* g_connect_timer = NULL;
39 static float g_volume_db = 0;
41 static int g_feature_enabled = -1;
43 static int g_privilege_allowed = -1;
44 static cynara *p_cynara = NULL;
46 static bool g_err_callback_status = false;
53 static int __stt_get_feature_enabled()
55 if (0 == g_feature_enabled) {
56 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
57 return STT_ERROR_NOT_SUPPORTED;
58 } else if (-1 == g_feature_enabled) {
59 bool stt_supported = false;
60 bool mic_supported = false;
61 if (0 == system_info_get_platform_bool(STT_FEATURE_PATH, &stt_supported)) {
62 if (0 == system_info_get_platform_bool(STT_MIC_FEATURE_PATH, &mic_supported)) {
63 if (false == stt_supported || false == mic_supported) {
64 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
65 g_feature_enabled = 0;
66 return STT_ERROR_NOT_SUPPORTED;
69 g_feature_enabled = 1;
71 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
72 return STT_ERROR_NOT_SUPPORTED;
75 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
76 return STT_ERROR_NOT_SUPPORTED;
83 static int __check_privilege_initialize()
85 int ret = cynara_initialize(&p_cynara, NULL);
86 if (CYNARA_API_SUCCESS != ret)
87 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to initialize");
89 return ret == CYNARA_API_SUCCESS;
92 static int __check_privilege(const char* uid, const char * privilege)
95 char smack_label[1024] = "/proc/self/attr/current";
101 fp = fopen(smack_label, "r");
103 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
104 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread");
109 pid_t pid = getpid();
110 char *session = cynara_session_from_pid(pid);
111 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
112 SLOG(LOG_DEBUG, TAG_STTC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
116 if (ret != CYNARA_API_ACCESS_ALLOWED)
121 static void __check_privilege_deinitialize()
124 cynara_finish(p_cynara);
128 static int __stt_check_privilege()
132 if (0 == g_privilege_allowed) {
133 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
134 return STT_ERROR_PERMISSION_DENIED;
135 } else if (-1 == g_privilege_allowed) {
136 if (false == __check_privilege_initialize()){
137 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
138 return STT_ERROR_PERMISSION_DENIED;
140 snprintf(uid, 16, "%d", getuid());
141 if (false == __check_privilege(uid, STT_PRIVILEGE)) {
142 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
143 g_privilege_allowed = 0;
144 __check_privilege_deinitialize();
145 return STT_ERROR_PERMISSION_DENIED;
147 __check_privilege_deinitialize();
150 g_privilege_allowed = 1;
151 return STT_ERROR_NONE;
154 static const char* __stt_get_error_code(stt_error_e err)
157 case STT_ERROR_NONE: return "STT_ERROR_NONE";
158 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
159 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
160 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
161 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
162 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
163 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
164 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
165 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
166 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
167 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
168 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
169 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
170 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
172 return "Invalid error code";
176 static int __stt_convert_config_error_code(stt_config_error_e code)
178 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
179 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
180 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
181 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
182 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
183 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
184 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
185 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
186 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
187 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
192 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
194 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
195 before_language, current_language);
197 if (0 == strcmp(before_language, current_language)) {
201 GList* client_list = NULL;
202 client_list = stt_client_get_client_list();
205 stt_client_s *data = NULL;
207 if (g_list_length(client_list) > 0) {
208 /* Get a first item */
209 iter = g_list_first(client_list);
211 while (NULL != iter) {
213 if (NULL != data->default_lang_changed_cb) {
214 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
215 data->default_lang_changed_cb(data->stt, before_language, current_language,
216 data->default_lang_changed_user_data);
220 iter = g_list_next(iter);
227 void __stt_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, bool support_silence, bool need_credential, void* user_data)
229 stt_h stt = (stt_h)user_data;
231 stt_client_s* client = stt_client_get(stt);
232 if (NULL == client) {
233 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
237 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
238 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
239 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
240 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
242 /* call callback function */
243 if (NULL != client->engine_changed_cb) {
244 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
246 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
251 static int __stt_check_handle(stt_h stt, stt_client_s** client)
254 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
255 return STT_ERROR_INVALID_PARAMETER;
258 stt_client_s* temp = NULL;
259 temp = stt_client_get(stt);
263 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
264 return STT_ERROR_INVALID_PARAMETER;
268 return STT_ERROR_NONE;
271 int stt_create(stt_h* stt)
273 if (0 != __stt_get_feature_enabled()) {
274 return STT_ERROR_NOT_SUPPORTED;
276 if (0 != __stt_check_privilege()) {
277 return STT_ERROR_PERMISSION_DENIED;
280 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
283 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
284 return STT_ERROR_INVALID_PARAMETER;
287 if (0 == stt_client_get_size()) {
288 if (0 != stt_dbus_open_connection()) {
289 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
290 return STT_ERROR_OPERATION_FAILED;
294 if (0 != stt_client_new(stt)) {
295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
296 return STT_ERROR_OUT_OF_MEMORY;
299 stt_client_s* client = stt_client_get(*stt);
300 if (NULL == client) {
301 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
302 stt_client_destroy(*stt);
303 return STT_ERROR_OPERATION_FAILED;
306 int ret = stt_config_mgr_initialize(client->uid);
307 ret = __stt_convert_config_error_code(ret);
309 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
310 stt_client_destroy(*stt);
314 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
315 ret = __stt_convert_config_error_code(ret);
317 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
318 stt_client_destroy(*stt);
322 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
324 SLOG(LOG_DEBUG, TAG_STTC, "=====");
325 SLOG(LOG_DEBUG, TAG_STTC, " ");
327 return STT_ERROR_NONE;
330 int stt_destroy(stt_h stt)
332 if (0 != __stt_get_feature_enabled()) {
333 return STT_ERROR_NOT_SUPPORTED;
335 if (0 != __stt_check_privilege()) {
336 return STT_ERROR_PERMISSION_DENIED;
339 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
342 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
343 return STT_ERROR_INVALID_PARAMETER;
346 stt_client_s* client = stt_client_get(stt);
349 if (NULL == client) {
350 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
351 return STT_ERROR_INVALID_PARAMETER;
354 /* check used callback */
355 if (0 != stt_client_get_use_callback(client)) {
356 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
357 return STT_ERROR_OPERATION_FAILED;
360 stt_config_mgr_finalize(client->uid);
365 switch (client->current_state) {
366 case STT_STATE_PROCESSING:
367 case STT_STATE_RECORDING:
368 case STT_STATE_READY:
369 ret = stt_dbus_request_finalize(client->uid);
371 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
373 case STT_STATE_CREATED:
374 if (NULL != g_connect_timer) {
375 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
376 ecore_timer_del(g_connect_timer);
377 g_connect_timer = NULL;
381 stt_client_destroy(stt);
387 if (0 == stt_client_get_size()) {
388 if (0 != stt_dbus_close_connection()) {
389 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
395 SLOG(LOG_DEBUG, TAG_STTC, "=====");
396 SLOG(LOG_DEBUG, TAG_STTC, " ");
398 return STT_ERROR_NONE;
401 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
402 const char* setting, bool support_silence, void* user_data)
404 stt_h stt = (stt_h)user_data;
406 stt_client_s* client = stt_client_get(stt);
407 if (NULL == client) {
408 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
412 /* call callback function */
413 if (NULL != client->supported_engine_cb) {
414 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
416 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
422 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
424 if (0 != __stt_get_feature_enabled()) {
425 return STT_ERROR_NOT_SUPPORTED;
427 if (0 != __stt_check_privilege()) {
428 return STT_ERROR_PERMISSION_DENIED;
431 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
433 if (NULL == stt || NULL == callback) {
434 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
435 return STT_ERROR_INVALID_PARAMETER;
438 stt_client_s* client = stt_client_get(stt);
441 if (NULL == client) {
442 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
443 return STT_ERROR_INVALID_PARAMETER;
446 if (client->current_state != STT_STATE_CREATED) {
447 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
448 return STT_ERROR_INVALID_STATE;
451 client->supported_engine_cb = callback;
452 client->supported_engine_user_data = user_data;
455 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
456 ret = __stt_convert_config_error_code(ret);
458 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
461 client->supported_engine_cb = NULL;
462 client->supported_engine_user_data = NULL;
464 SLOG(LOG_DEBUG, TAG_STTC, "=====");
465 SLOG(LOG_DEBUG, TAG_STTC, " ");
470 int stt_get_engine(stt_h stt, char** engine_id)
472 if (0 != __stt_get_feature_enabled()) {
473 return STT_ERROR_NOT_SUPPORTED;
476 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
478 if (NULL == stt || NULL == engine_id) {
479 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
480 return STT_ERROR_INVALID_PARAMETER;
483 stt_client_s* client = stt_client_get(stt);
486 if (NULL == client) {
487 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
488 return STT_ERROR_INVALID_PARAMETER;
491 if (client->current_state != STT_STATE_CREATED) {
492 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
493 return STT_ERROR_INVALID_STATE;
498 if (NULL != client->current_engine_id) {
499 *engine_id = strdup(client->current_engine_id);
500 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
503 ret = stt_config_mgr_get_engine(engine_id);
504 ret = __stt_convert_config_error_code(ret);
506 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
508 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
512 SLOG(LOG_DEBUG, TAG_STTC, "=====");
513 SLOG(LOG_DEBUG, TAG_STTC, " ");
518 int stt_set_engine(stt_h stt, const char* engine_id)
520 if (0 != __stt_get_feature_enabled()) {
521 return STT_ERROR_NOT_SUPPORTED;
523 if (0 != __stt_check_privilege()) {
524 return STT_ERROR_PERMISSION_DENIED;
527 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
529 if (NULL == stt || NULL == engine_id) {
530 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
531 return STT_ERROR_INVALID_PARAMETER;
534 stt_client_s* client = stt_client_get(stt);
537 if (NULL == client) {
538 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
539 return STT_ERROR_INVALID_PARAMETER;
543 if (client->current_state != STT_STATE_CREATED) {
544 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
545 return STT_ERROR_INVALID_STATE;
548 if (NULL != client->current_engine_id) {
549 free(client->current_engine_id);
552 client->current_engine_id = strdup(engine_id);
554 SLOG(LOG_DEBUG, TAG_STTC, "=====");
555 SLOG(LOG_DEBUG, TAG_STTC, " ");
560 int stt_set_credential(stt_h stt, const char* credential)
562 if (0 != __stt_get_feature_enabled()) {
563 return STT_ERROR_NOT_SUPPORTED;
565 if (0 != __stt_check_privilege()) {
566 return STT_ERROR_PERMISSION_DENIED;
569 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
571 if (NULL == stt || NULL == credential) {
572 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL, stt(%s), credential(%a)", stt, credential);
573 return STT_ERROR_INVALID_PARAMETER;
576 stt_client_s* client = stt_client_get(stt);
579 if (NULL == client) {
580 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
581 return STT_ERROR_INVALID_PARAMETER;
585 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
586 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
587 return STT_ERROR_INVALID_STATE;
590 client->credential = strdup(credential);
592 SLOG(LOG_DEBUG, TAG_STTC, "=====");
593 SLOG(LOG_DEBUG, TAG_STTC, " ");
595 return STT_ERROR_NONE;
598 int stt_set_private_data(stt_h stt, const char* key, const char* data)
600 stt_client_s* client = NULL;
602 if (0 != __stt_get_feature_enabled()) {
603 return STT_ERROR_NOT_SUPPORTED;
605 if (0 != __stt_check_privilege()) {
606 return STT_ERROR_PERMISSION_DENIED;
608 if (0 != __stt_check_handle(stt, &client)) {
609 return STT_ERROR_INVALID_PARAMETER;
612 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
614 if (NULL == key || NULL == data) {
615 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
616 return STT_ERROR_INVALID_PARAMETER;
620 if (STT_STATE_READY != client->current_state) {
621 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
622 return STT_ERROR_INVALID_STATE;
628 ret = stt_dbus_request_set_private_data(client->uid, key, data);
630 if (STT_ERROR_TIMED_OUT != ret) {
631 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
634 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
637 if (STT_RETRY_COUNT == count) {
638 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
645 SLOG(LOG_DEBUG, TAG_STTC, "=====");
646 SLOG(LOG_DEBUG, TAG_STTC, "");
648 return STT_ERROR_NONE;
651 int stt_get_private_data(stt_h stt, const char* key, char** data)
653 stt_client_s* client = NULL;
655 if (0 != __stt_get_feature_enabled()) {
656 return STT_ERROR_NOT_SUPPORTED;
658 if (0 != __stt_check_privilege()) {
659 return STT_ERROR_PERMISSION_DENIED;
661 if (0 != __stt_check_handle(stt, &client)) {
662 return STT_ERROR_INVALID_PARAMETER;
665 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
667 if (NULL == key || NULL == data) {
668 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
669 return STT_ERROR_INVALID_PARAMETER;
673 if (STT_STATE_READY != client->current_state) {
674 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
675 return STT_ERROR_INVALID_STATE;
681 ret = stt_dbus_request_get_private_data(client->uid, key, data);
683 if (STT_ERROR_TIMED_OUT != ret) {
684 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
687 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
690 if (STT_RETRY_COUNT == count) {
691 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
698 SLOG(LOG_DEBUG, TAG_STTC, "=====");
699 SLOG(LOG_DEBUG, TAG_STTC, "");
701 return STT_ERROR_NONE;
703 static Eina_Bool __stt_connect_daemon(void *data)
705 stt_client_s* client = (stt_client_s*)data;
707 if (NULL == client) {
708 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
709 g_connect_timer = NULL;
715 ret = stt_dbus_request_hello();
718 if (STT_ERROR_INVALID_STATE == ret) {
719 g_connect_timer = NULL;
725 g_connect_timer = NULL;
726 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
728 /* request initialization */
729 bool silence_supported = false;
730 bool credential_needed = false;
732 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
734 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
735 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
737 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
738 ecore_timer_add(0, __stt_notify_error, (void*)client);
742 } else if (STT_ERROR_NONE != ret) {
743 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
746 /* success to connect stt-daemon */
747 client->silence_supported = silence_supported;
748 client->credential_needed = credential_needed;
749 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
752 if (NULL != client->current_engine_id) {
755 silence_supported = false;
756 credential_needed = false;
758 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
760 if (STT_ERROR_TIMED_OUT != ret) {
761 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
764 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
767 if (STT_RETRY_COUNT == count) {
768 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
773 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
775 /* success to change engine */
776 client->silence_supported = silence_supported;
777 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
782 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
784 client->before_state = client->current_state;
785 client->current_state = STT_STATE_READY;
787 if (NULL != client->state_changed_cb) {
788 stt_client_use_callback(client);
789 client->state_changed_cb(client->stt, client->before_state,
790 client->current_state, client->state_changed_user_data);
791 stt_client_not_use_callback(client);
792 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
794 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
797 SLOG(LOG_DEBUG, TAG_STTC, "=====");
798 SLOG(LOG_DEBUG, TAG_STTC, " ");
803 int stt_prepare(stt_h stt)
805 if (0 != __stt_get_feature_enabled()) {
806 return STT_ERROR_NOT_SUPPORTED;
808 if (0 != __stt_check_privilege()) {
809 return STT_ERROR_PERMISSION_DENIED;
812 SLOG(LOG_DEBUG, TAG_STTC, "===== Prepare STT");
814 stt_client_s* client = stt_client_get(stt);
817 if (NULL == client) {
818 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
819 return STT_ERROR_INVALID_PARAMETER;
823 if (client->current_state != STT_STATE_CREATED) {
824 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
825 return STT_ERROR_INVALID_STATE;
828 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
830 SLOG(LOG_DEBUG, TAG_STTC, "=====");
831 SLOG(LOG_DEBUG, TAG_STTC, " ");
833 return STT_ERROR_NONE;
836 int stt_unprepare(stt_h stt)
838 if (0 != __stt_get_feature_enabled()) {
839 return STT_ERROR_NOT_SUPPORTED;
841 if (0 != __stt_check_privilege()) {
842 return STT_ERROR_PERMISSION_DENIED;
845 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
847 stt_client_s* client = stt_client_get(stt);
850 if (NULL == client) {
851 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
852 return STT_ERROR_INVALID_PARAMETER;
856 if (client->current_state != STT_STATE_READY) {
857 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
858 return STT_ERROR_INVALID_STATE;
864 ret = stt_dbus_request_finalize(client->uid);
866 if (STT_ERROR_TIMED_OUT != ret) {
867 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
870 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
873 if (STT_RETRY_COUNT == count) {
874 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
881 client->internal_state = STT_INTERNAL_STATE_NONE;
883 client->before_state = client->current_state;
884 client->current_state = STT_STATE_CREATED;
886 if (NULL != client->state_changed_cb) {
887 stt_client_use_callback(client);
888 client->state_changed_cb(client->stt, client->before_state,
889 client->current_state, client->state_changed_user_data);
890 stt_client_not_use_callback(client);
892 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
895 if (g_connect_timer) {
896 ecore_timer_del(g_connect_timer);
897 g_connect_timer = NULL;
900 SLOG(LOG_DEBUG, TAG_STTC, "=====");
901 SLOG(LOG_DEBUG, TAG_STTC, " ");
903 return STT_ERROR_NONE;
906 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
908 stt_h stt = (stt_h)user_data;
910 stt_client_s* client = stt_client_get(stt);
911 if (NULL == client) {
912 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
916 /* call callback function */
917 if (NULL != client->supported_lang_cb) {
918 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
920 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
926 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
928 if (0 != __stt_get_feature_enabled()) {
929 return STT_ERROR_NOT_SUPPORTED;
931 if (0 != __stt_check_privilege()) {
932 return STT_ERROR_PERMISSION_DENIED;
935 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
937 if (NULL == stt || NULL == callback) {
938 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
939 return STT_ERROR_INVALID_PARAMETER;
942 stt_client_s* client = stt_client_get(stt);
945 if (NULL == client) {
946 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
947 return STT_ERROR_INVALID_PARAMETER;
951 char* current_engine_id = NULL;
953 if (NULL == client->current_engine_id) {
954 ret = stt_config_mgr_get_engine(¤t_engine_id);
955 ret = __stt_convert_config_error_code(ret);
957 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
961 current_engine_id = strdup(client->current_engine_id);
962 if (NULL == current_engine_id) {
963 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
964 return STT_ERROR_OUT_OF_MEMORY;
968 client->supported_lang_cb = callback;
969 client->supported_lang_user_data = user_data;
971 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
972 ret = __stt_convert_config_error_code(ret);
974 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
977 if (NULL != current_engine_id) {
978 free(current_engine_id);
981 client->supported_lang_cb = NULL;
982 client->supported_lang_user_data = NULL;
984 SLOG(LOG_DEBUG, TAG_STTC, "=====");
985 SLOG(LOG_DEBUG, TAG_STTC, " ");
990 int stt_get_default_language(stt_h stt, char** language)
992 if (0 != __stt_get_feature_enabled()) {
993 return STT_ERROR_NOT_SUPPORTED;
995 if (0 != __stt_check_privilege()) {
996 return STT_ERROR_PERMISSION_DENIED;
999 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
1001 if (NULL == stt || NULL == language) {
1002 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1003 return STT_ERROR_INVALID_PARAMETER;
1006 stt_client_s* client = stt_client_get(stt);
1007 if (NULL == client) {
1008 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1009 return STT_ERROR_INVALID_PARAMETER;
1013 ret = stt_config_mgr_get_default_language(language);
1014 ret = __stt_convert_config_error_code(ret);
1016 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
1018 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
1021 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1022 SLOG(LOG_DEBUG, TAG_STTC, " ");
1027 int stt_get_state(stt_h stt, stt_state_e* state)
1029 if (0 != __stt_get_feature_enabled()) {
1030 return STT_ERROR_NOT_SUPPORTED;
1032 if (0 != __stt_check_privilege()) {
1033 return STT_ERROR_PERMISSION_DENIED;
1036 if (NULL == stt || NULL == state) {
1037 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1038 return STT_ERROR_INVALID_PARAMETER;
1041 stt_client_s* client = stt_client_get(stt);
1042 if (NULL == client) {
1043 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1044 return STT_ERROR_INVALID_PARAMETER;
1047 *state = client->current_state;
1050 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1051 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1052 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1053 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1054 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1057 return STT_ERROR_NONE;
1060 int stt_get_error_message(stt_h stt, char** err_msg)
1062 if (0 != __stt_get_feature_enabled()) {
1063 return STT_ERROR_NOT_SUPPORTED;
1065 if (0 != __stt_check_privilege()) {
1066 return STT_ERROR_PERMISSION_DENIED;
1069 if (NULL == stt || NULL == err_msg) {
1070 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1071 return STT_ERROR_INVALID_PARAMETER;
1074 if (false == g_err_callback_status) {
1075 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1076 return STT_ERROR_OPERATION_FAILED;
1079 stt_client_s* client = stt_client_get(stt);
1080 if (NULL == client) {
1081 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get error msg : A handle is not valid");
1082 return STT_ERROR_INVALID_PARAMETER;
1085 if (NULL != client->err_msg) {
1086 *err_msg = strdup(client->err_msg);
1087 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1089 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1092 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1093 SLOG(LOG_DEBUG, TAG_STTC, " ");
1095 return STT_ERROR_NONE;
1098 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1100 if (0 != __stt_get_feature_enabled()) {
1101 return STT_ERROR_NOT_SUPPORTED;
1103 if (0 != __stt_check_privilege()) {
1104 return STT_ERROR_PERMISSION_DENIED;
1107 if (NULL == stt || NULL == type || NULL == support) {
1108 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1109 return STT_ERROR_INVALID_PARAMETER;
1112 stt_client_s* client = stt_client_get(stt);
1113 if (NULL == client) {
1114 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not valid");
1115 return STT_ERROR_INVALID_PARAMETER;
1119 if (client->current_state != STT_STATE_READY) {
1120 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1121 return STT_ERROR_INVALID_STATE;
1127 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1129 if (STT_ERROR_TIMED_OUT != ret) {
1130 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1133 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1136 if (STT_RETRY_COUNT == count) {
1137 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1142 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1147 return STT_ERROR_NONE;
1150 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1152 if (0 != __stt_get_feature_enabled()) {
1153 return STT_ERROR_NOT_SUPPORTED;
1155 if (0 != __stt_check_privilege()) {
1156 return STT_ERROR_PERMISSION_DENIED;
1160 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1161 return STT_ERROR_INVALID_PARAMETER;
1164 stt_client_s* client = stt_client_get(stt);
1165 if (NULL == client) {
1166 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1167 return STT_ERROR_INVALID_PARAMETER;
1171 if (client->current_state != STT_STATE_READY) {
1172 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1173 return STT_ERROR_INVALID_STATE;
1176 if (true == client->silence_supported) {
1177 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1178 client->silence = type;
1180 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1181 return STT_ERROR_INVALID_PARAMETER;
1184 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1187 return STT_ERROR_NONE;
1190 int stt_set_start_sound(stt_h stt, const char* filename)
1192 if (0 != __stt_get_feature_enabled()) {
1193 return STT_ERROR_NOT_SUPPORTED;
1195 if (0 != __stt_check_privilege()) {
1196 return STT_ERROR_PERMISSION_DENIED;
1199 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1201 if (NULL == stt || NULL == filename) {
1202 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1203 return STT_ERROR_INVALID_PARAMETER;
1206 if (0 != access(filename, F_OK)) {
1207 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1208 return STT_ERROR_INVALID_PARAMETER;
1211 stt_client_s* client = stt_client_get(stt);
1212 if (NULL == client) {
1213 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1214 return STT_ERROR_INVALID_PARAMETER;
1218 if (client->current_state != STT_STATE_READY) {
1219 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1220 return STT_ERROR_INVALID_STATE;
1226 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1228 if (STT_ERROR_TIMED_OUT != ret) {
1229 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1232 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1235 if (STT_RETRY_COUNT == count) {
1236 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1241 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1246 return STT_ERROR_NONE;
1249 int stt_unset_start_sound(stt_h stt)
1251 if (0 != __stt_get_feature_enabled()) {
1252 return STT_ERROR_NOT_SUPPORTED;
1254 if (0 != __stt_check_privilege()) {
1255 return STT_ERROR_PERMISSION_DENIED;
1258 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1261 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1262 return STT_ERROR_INVALID_PARAMETER;
1265 stt_client_s* client = stt_client_get(stt);
1267 if (NULL == client) {
1268 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1269 return STT_ERROR_INVALID_PARAMETER;
1273 if (client->current_state != STT_STATE_READY) {
1274 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1275 return STT_ERROR_INVALID_STATE;
1281 ret = stt_dbus_request_unset_start_sound(client->uid);
1283 if (STT_ERROR_TIMED_OUT != ret) {
1284 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1287 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1290 if (STT_RETRY_COUNT == count) {
1291 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1296 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1301 return STT_ERROR_NONE;
1304 int stt_set_stop_sound(stt_h stt, const char* filename)
1306 if (0 != __stt_get_feature_enabled()) {
1307 return STT_ERROR_NOT_SUPPORTED;
1309 if (0 != __stt_check_privilege()) {
1310 return STT_ERROR_PERMISSION_DENIED;
1313 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1315 if (NULL == stt || NULL == filename) {
1316 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1317 return STT_ERROR_INVALID_PARAMETER;
1320 if (0 != access(filename, F_OK)) {
1321 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1322 return STT_ERROR_INVALID_PARAMETER;
1325 stt_client_s* client = stt_client_get(stt);
1327 if (NULL == client) {
1328 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1329 return STT_ERROR_INVALID_PARAMETER;
1333 if (client->current_state != STT_STATE_READY) {
1334 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1335 return STT_ERROR_INVALID_STATE;
1341 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1343 if (STT_ERROR_TIMED_OUT != ret) {
1344 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1347 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1350 if (STT_RETRY_COUNT == count) {
1351 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1356 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1361 return STT_ERROR_NONE;
1364 int stt_unset_stop_sound(stt_h stt)
1366 if (0 != __stt_get_feature_enabled()) {
1367 return STT_ERROR_NOT_SUPPORTED;
1369 if (0 != __stt_check_privilege()) {
1370 return STT_ERROR_PERMISSION_DENIED;
1373 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
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);
1382 if (NULL == client) {
1383 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1384 return STT_ERROR_INVALID_PARAMETER;
1388 if (client->current_state != STT_STATE_READY) {
1389 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1390 return STT_ERROR_INVALID_STATE;
1396 ret = stt_dbus_request_unset_stop_sound(client->uid);
1398 if (STT_ERROR_TIMED_OUT != ret) {
1399 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1402 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1405 if (STT_RETRY_COUNT == count) {
1406 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1411 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1416 return STT_ERROR_NONE;
1419 int stt_start(stt_h stt, const char* language, const char* type)
1421 if (0 != __stt_get_feature_enabled()) {
1422 return STT_ERROR_NOT_SUPPORTED;
1424 if (0 != __stt_check_privilege()) {
1425 return STT_ERROR_PERMISSION_DENIED;
1428 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1431 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1432 return STT_ERROR_INVALID_PARAMETER;
1435 stt_client_s* client = stt_client_get(stt);
1436 if (NULL == client) {
1437 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1438 return STT_ERROR_INVALID_PARAMETER;
1442 if (client->current_state != STT_STATE_READY) {
1443 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1444 return STT_ERROR_INVALID_STATE;
1447 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1448 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1449 return STT_ERROR_INVALID_STATE;
1453 char appid[128] = {0, };
1454 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1456 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1457 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1459 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1463 if (NULL == language) {
1464 temp = strdup("default");
1466 temp = strdup(language);
1474 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid);
1477 if (STT_ERROR_TIMED_OUT != ret) {
1478 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1479 if (NULL != temp) free(temp);
1482 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry to start");
1485 if (STT_RETRY_COUNT == count) {
1486 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1487 if (NULL != temp) free(temp);
1493 if (NULL != temp) free(temp);
1495 if (STT_RESULT_STATE_DONE == ret) {
1496 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is done : %d", ret);
1497 client->before_state = client->current_state;
1498 client->current_state = STT_STATE_RECORDING;
1500 if (NULL != client->state_changed_cb) {
1501 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1503 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1505 } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1506 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is not done : %d", ret);
1507 client->internal_state = STT_INTERNAL_STATE_STARTING;
1509 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1512 ret = STT_ERROR_NONE;
1517 if (true == client->credential_needed && NULL == client->credential) {
1518 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1519 return STT_ERROR_PERMISSION_DENIED;
1522 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1524 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1526 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1527 client->internal_state = STT_INTERNAL_STATE_STARTING;
1530 if (NULL != temp) free(temp);
1532 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1533 SLOG(LOG_DEBUG, TAG_STTC, " ");
1538 int stt_stop(stt_h stt)
1540 if (0 != __stt_get_feature_enabled()) {
1541 return STT_ERROR_NOT_SUPPORTED;
1543 if (0 != __stt_check_privilege()) {
1544 return STT_ERROR_PERMISSION_DENIED;
1547 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1550 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1551 return STT_ERROR_INVALID_PARAMETER;
1554 stt_client_s* client = stt_client_get(stt);
1555 if (NULL == client) {
1556 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1557 return STT_ERROR_INVALID_PARAMETER;
1561 if (client->current_state != STT_STATE_RECORDING) {
1562 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1563 return STT_ERROR_INVALID_STATE;
1566 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1567 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1568 return STT_ERROR_INVALID_STATE;
1575 ret = stt_dbus_request_stop(client->uid);
1578 if (STT_ERROR_TIMED_OUT != ret) {
1579 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1582 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry stop");
1585 if (STT_RETRY_COUNT == count) {
1586 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1591 if (STT_RESULT_STATE_DONE == ret) {
1592 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is done : %d", ret);
1593 client->before_state = client->current_state;
1594 client->current_state = STT_STATE_PROCESSING;
1596 if (NULL != client->state_changed_cb) {
1597 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1598 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1600 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1602 } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1603 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is not done : %d", ret);
1604 client->internal_state = STT_INTERNAL_STATE_STOPING;
1606 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1608 ret = STT_ERROR_NONE;
1613 int ret = stt_dbus_request_stop(client->uid);
1616 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1618 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1619 client->internal_state = STT_INTERNAL_STATE_STOPING;
1622 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1623 SLOG(LOG_DEBUG, TAG_STTC, " ");
1629 int stt_cancel(stt_h stt)
1631 if (0 != __stt_get_feature_enabled()) {
1632 return STT_ERROR_NOT_SUPPORTED;
1634 if (0 != __stt_check_privilege()) {
1635 return STT_ERROR_PERMISSION_DENIED;
1638 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1641 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
1642 return STT_ERROR_INVALID_PARAMETER;
1645 stt_client_s* client = stt_client_get(stt);
1648 if (NULL == client) {
1649 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1650 return STT_ERROR_INVALID_PARAMETER;
1654 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1655 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1656 return STT_ERROR_INVALID_STATE;
1659 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1660 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1661 return STT_ERROR_INVALID_STATE;
1668 ret = stt_dbus_request_cancel(client->uid);
1671 if (STT_ERROR_TIMED_OUT != ret) {
1672 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1675 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1678 if (STT_RETRY_COUNT == count) {
1679 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1684 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
1686 client->before_state = client->current_state;
1687 client->current_state = STT_STATE_READY;
1689 if (NULL != client->state_changed_cb) {
1690 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1691 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1693 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1695 ret = STT_ERROR_NONE;
1700 int ret = stt_dbus_request_cancel(client->uid);
1702 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1704 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1705 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1708 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1709 SLOG(LOG_DEBUG, TAG_STTC, " ");
1714 int __stt_cb_set_volume(int uid, float volume)
1716 stt_client_s* client = NULL;
1718 client = stt_client_get_by_uid(uid);
1719 if (NULL == client) {
1720 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1721 return STT_ERROR_INVALID_PARAMETER;
1724 if (STT_STATE_RECORDING != client->current_state) {
1725 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1726 return STT_ERROR_INVALID_STATE;
1729 g_volume_db = volume;
1730 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1735 int stt_get_recording_volume(stt_h stt, float* volume)
1737 if (0 != __stt_get_feature_enabled()) {
1738 return STT_ERROR_NOT_SUPPORTED;
1740 if (0 != __stt_check_privilege()) {
1741 return STT_ERROR_PERMISSION_DENIED;
1744 if (NULL == stt || NULL == volume) {
1745 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1746 return STT_ERROR_INVALID_PARAMETER;
1749 stt_client_s* client = stt_client_get(stt);
1752 if (NULL == client) {
1753 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1754 return STT_ERROR_INVALID_PARAMETER;
1757 if (STT_STATE_RECORDING != client->current_state) {
1758 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1759 return STT_ERROR_INVALID_STATE;
1762 *volume = g_volume_db;
1764 return STT_ERROR_NONE;
1767 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1769 stt_client_s* client = (stt_client_s*)user_data;
1772 if (NULL == client) {
1773 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1777 if (NULL != client->result_time_cb) {
1778 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1779 index, event, text, start_time, end_time);
1780 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1781 text, start_time, end_time, client->result_time_user_data);
1783 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1790 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1792 if (0 != __stt_get_feature_enabled()) {
1793 return STT_ERROR_NOT_SUPPORTED;
1795 if (0 != __stt_check_privilege()) {
1796 return STT_ERROR_PERMISSION_DENIED;
1799 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1801 if (NULL == callback) {
1802 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1803 return STT_ERROR_INVALID_PARAMETER;
1806 stt_client_s* client = stt_client_get(stt);
1809 if (NULL == client) {
1810 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail : A handle is not valid");
1811 return STT_ERROR_INVALID_PARAMETER;
1814 client->result_time_cb = callback;
1815 client->result_time_user_data = user_data;
1818 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1819 ret = __stt_convert_config_error_code(ret);
1821 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1824 client->result_time_cb = NULL;
1825 client->result_time_user_data = NULL;
1827 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1828 SLOG(LOG_DEBUG, TAG_STTC, " ");
1833 static Eina_Bool __stt_notify_error(void *data)
1835 stt_client_s* client = (stt_client_s*)data;
1837 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1840 if (NULL == client) {
1841 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1845 if (NULL == stt_client_get_by_uid(client->uid))
1848 if (NULL != client->error_cb) {
1849 stt_client_use_callback(client);
1850 g_err_callback_status = true;
1851 client->error_cb(client->stt, client->reason, client->error_user_data);
1852 g_err_callback_status = false;
1853 stt_client_not_use_callback(client);
1854 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1856 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1862 int __stt_cb_error(int uid, int reason, char* err_msg)
1864 stt_client_s* client = stt_client_get_by_uid(uid);
1865 if (NULL == client) {
1866 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1870 client->reason = reason;
1871 client->internal_state = STT_INTERNAL_STATE_NONE;
1872 if (NULL != client->err_msg) {
1873 free(client->err_msg);
1874 client->err_msg = NULL;
1876 client->err_msg = strdup(err_msg);
1878 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1880 if (NULL != client->error_cb) {
1881 ecore_timer_add(0, __stt_notify_error, client);
1883 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1889 static void __stt_notify_state_changed(void *data)
1891 stt_client_s* client = (stt_client_s*)data;
1894 if (NULL == client) {
1895 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1899 if (NULL == stt_client_get_by_uid(client->uid)) {
1903 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1904 client->internal_state = STT_INTERNAL_STATE_NONE;
1905 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1906 } else if (STT_INTERNAL_STATE_STOPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1907 client->internal_state = STT_INTERNAL_STATE_NONE;
1908 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1909 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1910 client->internal_state = STT_INTERNAL_STATE_NONE;
1911 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1914 if (NULL != client->state_changed_cb) {
1915 stt_client_use_callback(client);
1916 client->state_changed_cb(client->stt, client->before_state,
1917 client->current_state, client->state_changed_user_data);
1918 stt_client_not_use_callback(client);
1919 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1921 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1927 static Eina_Bool __stt_notify_result(void *data)
1929 stt_client_s* client = (stt_client_s*)data;
1932 if (NULL == client) {
1933 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1937 if (NULL == stt_client_get_by_uid(client->uid)) {
1941 if (NULL != client->recognition_result_cb) {
1942 stt_client_use_callback(client);
1943 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1944 client->msg, client->recognition_result_user_data);
1945 stt_client_not_use_callback(client);
1946 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1948 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1951 if (NULL != client->msg) {
1956 if (NULL != client->data_list) {
1958 temp = client->data_list;
1961 for (i = 0; i < client->data_count; i++) {
1962 if (NULL != temp[i]) {
1966 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1969 free(client->data_list);
1970 client->data_list = NULL;
1973 client->data_count = 0;
1975 stt_config_mgr_remove_time_info_file();
1977 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1978 client->before_state = client->current_state;
1979 client->current_state = STT_STATE_READY;
1981 if (NULL != client->state_changed_cb) {
1982 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1984 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1991 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1993 stt_client_s* client = NULL;
1995 client = stt_client_get_by_uid(uid);
1996 if (NULL == client) {
1997 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1998 return STT_ERROR_INVALID_PARAMETER;
2002 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
2005 for (i = 0; i < data_count; i++) {
2006 if (NULL != data[i])
2007 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
2010 if (NULL != client->recognition_result_cb) {
2011 client->event = event;
2013 client->msg = strdup(msg);
2016 client->data_count = data_count;
2018 if (data_count > 0) {
2020 temp = (char**)calloc(data_count, sizeof(char*));
2022 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
2023 return STT_ERROR_OUT_OF_MEMORY;
2026 for (i = 0; i < data_count; i++) {
2027 if (NULL != data[i])
2028 temp[i] = strdup(data[i]);
2030 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
2033 client->data_list = temp;
2036 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
2039 ecore_timer_add(0, __stt_notify_result, client);
2041 return STT_ERROR_NONE;
2044 int __stt_cb_set_state(int uid, int state)
2046 stt_client_s* client = stt_client_get_by_uid(uid);
2047 if (NULL == client) {
2048 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
2052 stt_state_e state_from_daemon = (stt_state_e)state;
2054 if (client->current_state == state_from_daemon) {
2055 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
2059 client->before_state = client->current_state;
2060 client->current_state = state_from_daemon;
2062 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
2066 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
2068 if (0 != __stt_get_feature_enabled()) {
2069 return STT_ERROR_NOT_SUPPORTED;
2071 if (0 != __stt_check_privilege()) {
2072 return STT_ERROR_PERMISSION_DENIED;
2075 if (stt == NULL || callback == NULL)
2076 return STT_ERROR_INVALID_PARAMETER;
2078 stt_client_s* client = stt_client_get(stt);
2081 if (NULL == client) {
2082 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2083 return STT_ERROR_INVALID_PARAMETER;
2086 if (STT_STATE_CREATED != client->current_state) {
2087 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2088 return STT_ERROR_INVALID_STATE;
2091 client->recognition_result_cb = callback;
2092 client->recognition_result_user_data = user_data;
2097 int stt_unset_recognition_result_cb(stt_h stt)
2099 if (0 != __stt_get_feature_enabled()) {
2100 return STT_ERROR_NOT_SUPPORTED;
2102 if (0 != __stt_check_privilege()) {
2103 return STT_ERROR_PERMISSION_DENIED;
2107 return STT_ERROR_INVALID_PARAMETER;
2109 stt_client_s* client = stt_client_get(stt);
2112 if (NULL == client) {
2113 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2114 return STT_ERROR_INVALID_PARAMETER;
2117 if (STT_STATE_CREATED != client->current_state) {
2118 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2119 return STT_ERROR_INVALID_STATE;
2122 client->recognition_result_cb = NULL;
2123 client->recognition_result_user_data = NULL;
2128 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
2130 if (0 != __stt_get_feature_enabled()) {
2131 return STT_ERROR_NOT_SUPPORTED;
2133 if (0 != __stt_check_privilege()) {
2134 return STT_ERROR_PERMISSION_DENIED;
2137 if (NULL == stt || NULL == callback)
2138 return STT_ERROR_INVALID_PARAMETER;
2140 stt_client_s* client = stt_client_get(stt);
2143 if (NULL == client) {
2144 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2145 return STT_ERROR_INVALID_PARAMETER;
2148 if (STT_STATE_CREATED != client->current_state) {
2149 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2150 return STT_ERROR_INVALID_STATE;
2153 client->state_changed_cb = callback;
2154 client->state_changed_user_data = user_data;
2159 int stt_unset_state_changed_cb(stt_h stt)
2161 if (0 != __stt_get_feature_enabled()) {
2162 return STT_ERROR_NOT_SUPPORTED;
2164 if (0 != __stt_check_privilege()) {
2165 return STT_ERROR_PERMISSION_DENIED;
2169 return STT_ERROR_INVALID_PARAMETER;
2171 stt_client_s* client = stt_client_get(stt);
2174 if (NULL == client) {
2175 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2176 return STT_ERROR_INVALID_PARAMETER;
2179 if (STT_STATE_CREATED != client->current_state) {
2180 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2181 return STT_ERROR_INVALID_STATE;
2184 client->state_changed_cb = NULL;
2185 client->state_changed_user_data = NULL;
2190 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
2192 if (0 != __stt_get_feature_enabled()) {
2193 return STT_ERROR_NOT_SUPPORTED;
2195 if (0 != __stt_check_privilege()) {
2196 return STT_ERROR_PERMISSION_DENIED;
2199 if (NULL == stt || NULL == callback)
2200 return STT_ERROR_INVALID_PARAMETER;
2202 stt_client_s* client = stt_client_get(stt);
2205 if (NULL == client) {
2206 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2207 return STT_ERROR_INVALID_PARAMETER;
2210 if (STT_STATE_CREATED != client->current_state) {
2211 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2212 return STT_ERROR_INVALID_STATE;
2215 client->error_cb = callback;
2216 client->error_user_data = user_data;
2221 int stt_unset_error_cb(stt_h stt)
2223 if (0 != __stt_get_feature_enabled()) {
2224 return STT_ERROR_NOT_SUPPORTED;
2226 if (0 != __stt_check_privilege()) {
2227 return STT_ERROR_PERMISSION_DENIED;
2231 return STT_ERROR_INVALID_PARAMETER;
2233 stt_client_s* client = stt_client_get(stt);
2236 if (NULL == client) {
2237 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2238 return STT_ERROR_INVALID_PARAMETER;
2241 if (STT_STATE_CREATED != client->current_state) {
2242 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2243 return STT_ERROR_INVALID_STATE;
2246 client->error_cb = NULL;
2247 client->error_user_data = NULL;
2252 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2254 if (0 != __stt_get_feature_enabled()) {
2255 return STT_ERROR_NOT_SUPPORTED;
2257 if (0 != __stt_check_privilege()) {
2258 return STT_ERROR_PERMISSION_DENIED;
2261 if (NULL == stt || NULL == callback)
2262 return STT_ERROR_INVALID_PARAMETER;
2264 stt_client_s* client = stt_client_get(stt);
2267 if (NULL == client) {
2268 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2269 return STT_ERROR_INVALID_PARAMETER;
2272 if (STT_STATE_CREATED != client->current_state) {
2273 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2274 return STT_ERROR_INVALID_STATE;
2277 client->default_lang_changed_cb = callback;
2278 client->default_lang_changed_user_data = user_data;
2283 int stt_unset_default_language_changed_cb(stt_h stt)
2285 if (0 != __stt_get_feature_enabled()) {
2286 return STT_ERROR_NOT_SUPPORTED;
2288 if (0 != __stt_check_privilege()) {
2289 return STT_ERROR_PERMISSION_DENIED;
2293 return STT_ERROR_INVALID_PARAMETER;
2295 stt_client_s* client = stt_client_get(stt);
2298 if (NULL == client) {
2299 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2300 return STT_ERROR_INVALID_PARAMETER;
2303 if (STT_STATE_CREATED != client->current_state) {
2304 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2305 return STT_ERROR_INVALID_STATE;
2308 client->default_lang_changed_cb = NULL;
2309 client->default_lang_changed_user_data = NULL;
2314 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2316 if (0 != __stt_get_feature_enabled()) {
2317 return STT_ERROR_NOT_SUPPORTED;
2319 if (0 != __stt_check_privilege()) {
2320 return STT_ERROR_PERMISSION_DENIED;
2323 if (NULL == stt || NULL == callback)
2324 return STT_ERROR_INVALID_PARAMETER;
2326 stt_client_s* client = stt_client_get(stt);
2329 if (NULL == client) {
2330 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2331 return STT_ERROR_INVALID_PARAMETER;
2334 if (STT_STATE_CREATED != client->current_state) {
2335 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2336 return STT_ERROR_INVALID_STATE;
2339 client->engine_changed_cb = callback;
2340 client->engine_changed_user_data = user_data;
2345 int stt_unset_engine_changed_cb(stt_h stt)
2347 if (0 != __stt_get_feature_enabled()) {
2348 return STT_ERROR_NOT_SUPPORTED;
2350 if (0 != __stt_check_privilege()) {
2351 return STT_ERROR_PERMISSION_DENIED;
2355 return STT_ERROR_INVALID_PARAMETER;
2357 stt_client_s* client = stt_client_get(stt);
2360 if (NULL == client) {
2361 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2362 return STT_ERROR_INVALID_PARAMETER;
2365 if (STT_STATE_CREATED != client->current_state) {
2366 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2367 return STT_ERROR_INVALID_STATE;
2370 client->engine_changed_cb = NULL;
2371 client->engine_changed_user_data = NULL;