2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
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>
30 #include "stt_client.h"
32 #include "stt_config_mgr.h"
33 #include "stt_internal.h"
37 static void __stt_notify_state_changed(void *data);
38 static void __stt_notify_error(void *data);
40 static Ecore_Timer* g_connect_timer = NULL;
41 static float g_volume_db = 0;
43 static int g_feature_enabled = -1;
45 static int g_privilege_allowed = -1;
46 static int g_privilege_applaunch_allowed = -1;
48 static cynara *p_cynara = NULL;
50 static bool g_err_callback_status = false;
57 static int __stt_get_feature_enabled()
59 if (0 == g_feature_enabled) {
60 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
61 return STT_ERROR_NOT_SUPPORTED;
62 } else if (-1 == g_feature_enabled) {
63 bool stt_supported = false;
64 bool mic_supported = false;
65 if (0 == system_info_get_platform_bool(STT_FEATURE_PATH, &stt_supported)) {
66 if (0 == system_info_get_platform_bool(STT_MIC_FEATURE_PATH, &mic_supported)) {
67 if (false == stt_supported || false == mic_supported) {
68 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
69 g_feature_enabled = 0;
70 return STT_ERROR_NOT_SUPPORTED;
73 g_feature_enabled = 1;
75 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
76 return STT_ERROR_NOT_SUPPORTED;
79 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
80 return STT_ERROR_NOT_SUPPORTED;
87 static int __check_privilege_initialize()
89 int ret = cynara_initialize(&p_cynara, NULL);
90 if (CYNARA_API_SUCCESS != ret)
91 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to initialize");
93 return ret == CYNARA_API_SUCCESS;
96 static bool __check_privilege(const char* uid, const char * privilege)
99 char label_path[1024] = "/proc/self/attr/current";
100 char smack_label[1024] = {'\0',};
106 fp = fopen(label_path, "r");
108 if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
109 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread");
114 pid_t pid = getpid();
115 char *session = cynara_session_from_pid(pid);
116 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
117 SLOG(LOG_DEBUG, TAG_STTC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
123 if (ret != CYNARA_API_ACCESS_ALLOWED)
128 static void __check_privilege_deinitialize()
131 cynara_finish(p_cynara);
135 static int __stt_check_privilege()
139 if (0 == g_privilege_allowed) {
140 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
141 return STT_ERROR_PERMISSION_DENIED;
142 } else if (-1 == g_privilege_allowed) {
143 if (false == __check_privilege_initialize()) {
144 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
145 return STT_ERROR_PERMISSION_DENIED;
147 snprintf(uid, 16, "%d", getuid());
148 if (false == __check_privilege(uid, STT_PRIVILEGE_RECORDER)) {
149 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
150 g_privilege_allowed = 0;
151 __check_privilege_deinitialize();
152 return STT_ERROR_PERMISSION_DENIED;
154 __check_privilege_deinitialize();
157 g_privilege_allowed = 1;
158 return STT_ERROR_NONE;
161 static int __stt_check_privilege_for_applaunch()
165 if (0 == g_privilege_applaunch_allowed) {
166 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission for applaunch is denied");
167 return STT_ERROR_PERMISSION_DENIED;
168 } else if (-1 == g_privilege_applaunch_allowed) {
169 if (false == __check_privilege_initialize()) {
170 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed (applaunch)");
171 return STT_ERROR_PERMISSION_DENIED;
173 snprintf(uid, 16, "%d", getuid());
174 if (false == __check_privilege(uid, STT_PRIVILEGE_APPLAUNCH)) {
175 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied : appmanager.launch");
176 g_privilege_applaunch_allowed = 0;
177 __check_privilege_deinitialize();
178 return STT_ERROR_PERMISSION_DENIED;
180 __check_privilege_deinitialize();
183 g_privilege_applaunch_allowed = 1;
184 return STT_ERROR_NONE;
187 static const char* __stt_get_error_code(stt_error_e err)
190 case STT_ERROR_NONE: return "STT_ERROR_NONE";
191 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
192 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
193 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
194 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
195 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
196 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
197 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
198 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
199 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
200 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
201 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
202 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
203 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
204 case STT_ERROR_SERVICE_RESET: return "STT_ERROR_SERVICE_RESET";
206 return "Invalid error code";
210 static int __stt_convert_config_error_code(stt_config_error_e code)
212 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
213 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
214 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
215 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
216 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
217 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
218 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
219 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
220 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
221 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
226 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
228 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
229 before_language, current_language);
231 if (0 == strcmp(before_language, current_language)) {
235 GList* client_list = NULL;
236 client_list = stt_client_get_client_list();
239 stt_client_s *data = NULL;
241 if (g_list_length(client_list) > 0) {
242 /* Get a first item */
243 iter = g_list_first(client_list);
245 while (NULL != iter) {
247 if (NULL != data->default_lang_changed_cb) {
248 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
249 data->default_lang_changed_cb(data->stt, before_language, current_language,
250 data->default_lang_changed_user_data);
254 iter = g_list_next(iter);
261 static Eina_Bool __reconnect_by_engine_changed(void *data)
263 stt_h stt = (stt_h)data;
265 stt_client_s* client = stt_client_get(stt);
266 if (NULL == client) {
267 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
271 if (STT_STATE_READY != client->current_state) {
276 int ret = stt_unprepare(stt);
278 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
280 ret = stt_prepare(stt);
282 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
288 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)
290 stt_h stt = (stt_h)user_data;
292 stt_client_s* client = stt_client_get(stt);
293 if (NULL == client) {
294 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
298 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
299 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
300 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
301 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
303 /* When the default engine is changed, please unload the old engine and load the new one. */
306 if (NULL == client->current_engine_id) {
307 if (STT_STATE_RECORDING == client->current_state || STT_STATE_PROCESSING == client->current_state) {
308 ret = stt_cancel(stt);
310 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] STT client canceling...");
313 ecore_idler_add(__reconnect_by_engine_changed, (void*)stt);
314 } else if (STT_STATE_READY == client->current_state) {
315 ret = stt_unprepare(stt);
317 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
319 ret = stt_prepare(stt);
321 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare for setting a new engine... (%d)", ret);
326 /* call callback function */
327 if (NULL != client->engine_changed_cb) {
328 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
330 SLOG(LOG_WARN, TAG_STTC, "No registered callback function for engine change");
335 static int __stt_check_handle(stt_h stt, stt_client_s** client)
338 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
339 return STT_ERROR_INVALID_PARAMETER;
342 stt_client_s* temp = NULL;
343 temp = stt_client_get(stt);
347 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
348 return STT_ERROR_INVALID_PARAMETER;
352 return STT_ERROR_NONE;
355 int stt_create(stt_h* stt)
357 if (0 != __stt_get_feature_enabled()) {
358 return STT_ERROR_NOT_SUPPORTED;
360 if (0 != __stt_check_privilege()) {
361 return STT_ERROR_PERMISSION_DENIED;
364 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
367 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
368 return STT_ERROR_INVALID_PARAMETER;
371 if (0 == stt_client_get_size()) {
372 if (0 != stt_dbus_open_connection()) {
373 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
374 return STT_ERROR_OPERATION_FAILED;
378 if (0 != stt_client_new(stt)) {
379 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
380 return STT_ERROR_OUT_OF_MEMORY;
383 stt_client_s* client = stt_client_get(*stt);
384 if (NULL == client) {
385 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
386 stt_client_destroy(*stt);
387 return STT_ERROR_OPERATION_FAILED;
390 int ret = stt_config_mgr_initialize(client->uid);
391 ret = __stt_convert_config_error_code(ret);
393 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
394 stt_client_destroy(*stt);
398 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
399 ret = __stt_convert_config_error_code(ret);
401 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
402 stt_client_destroy(*stt);
406 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
408 SLOG(LOG_DEBUG, TAG_STTC, "=====");
409 SLOG(LOG_DEBUG, TAG_STTC, " ");
411 return STT_ERROR_NONE;
414 int stt_destroy(stt_h stt)
416 stt_client_s* client = NULL;
417 if (0 != __stt_get_feature_enabled()) {
418 return STT_ERROR_NOT_SUPPORTED;
420 if (0 != __stt_check_privilege()) {
421 return STT_ERROR_PERMISSION_DENIED;
423 if (0 != __stt_check_handle(stt, &client)) {
424 return STT_ERROR_INVALID_PARAMETER;
427 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
429 /* check used callback */
430 if (0 != stt_client_get_use_callback(client)) {
431 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
432 return STT_ERROR_OPERATION_FAILED;
435 stt_config_mgr_finalize(client->uid);
440 switch (client->current_state) {
441 case STT_STATE_PROCESSING:
442 case STT_STATE_RECORDING:
443 case STT_STATE_READY:
444 ret = stt_dbus_request_finalize(client->uid);
446 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
448 case STT_STATE_CREATED:
449 if (NULL != g_connect_timer) {
450 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
451 ecore_timer_del(g_connect_timer);
452 g_connect_timer = NULL;
456 stt_client_destroy(stt);
462 if (0 == stt_client_get_size()) {
463 if (0 != stt_dbus_close_connection()) {
464 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
470 SLOG(LOG_DEBUG, TAG_STTC, "=====");
471 SLOG(LOG_DEBUG, TAG_STTC, " ");
473 return STT_ERROR_NONE;
476 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
477 const char* setting, bool support_silence, void* user_data)
479 stt_h stt = (stt_h)user_data;
481 stt_client_s* client = stt_client_get(stt);
482 if (NULL == client) {
483 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
487 /* call callback function */
488 if (NULL != client->supported_engine_cb) {
489 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
491 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
497 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
499 stt_client_s* client = NULL;
500 if (0 != __stt_get_feature_enabled()) {
501 return STT_ERROR_NOT_SUPPORTED;
503 if (0 != __stt_check_privilege()) {
504 return STT_ERROR_PERMISSION_DENIED;
506 if (0 != __stt_check_handle(stt, &client)) {
507 return STT_ERROR_INVALID_PARAMETER;
510 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
512 if (NULL == callback) {
513 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
514 return STT_ERROR_INVALID_PARAMETER;
517 if (client->current_state != STT_STATE_CREATED) {
518 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
519 return STT_ERROR_INVALID_STATE;
522 client->supported_engine_cb = callback;
523 client->supported_engine_user_data = user_data;
526 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
527 ret = __stt_convert_config_error_code(ret);
529 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
532 client->supported_engine_cb = NULL;
533 client->supported_engine_user_data = NULL;
535 SLOG(LOG_DEBUG, TAG_STTC, "=====");
536 SLOG(LOG_DEBUG, TAG_STTC, " ");
541 int stt_get_engine(stt_h stt, char** engine_id)
543 stt_client_s* client = NULL;
544 if (0 != __stt_get_feature_enabled()) {
545 return STT_ERROR_NOT_SUPPORTED;
547 if (0 != __stt_check_privilege()) {
548 return STT_ERROR_PERMISSION_DENIED;
550 if (0 != __stt_check_handle(stt, &client)) {
551 return STT_ERROR_INVALID_PARAMETER;
554 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
556 if (NULL == engine_id) {
557 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
558 return STT_ERROR_INVALID_PARAMETER;
561 if (client->current_state != STT_STATE_CREATED) {
562 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
563 return STT_ERROR_INVALID_STATE;
568 if (NULL != client->current_engine_id) {
569 *engine_id = strdup(client->current_engine_id);
570 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
573 ret = stt_config_mgr_get_engine(engine_id);
574 ret = __stt_convert_config_error_code(ret);
576 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
578 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
582 SLOG(LOG_DEBUG, TAG_STTC, "=====");
583 SLOG(LOG_DEBUG, TAG_STTC, " ");
588 int __stt_set_buxtonkey(const char* engine_id)
591 struct buxton_client * bux_cli;
592 struct buxton_layer * bux_layer;
593 struct buxton_value * bux_val;
595 int ret = buxton_open(&bux_cli, NULL, NULL);
597 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to open buxton client");
598 return STT_ERROR_OPERATION_FAILED;
600 SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_open: %d", ret);
601 bux_layer = buxton_create_layer("system");
602 if (NULL == bux_layer) {
603 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
604 buxton_close(bux_cli);
606 return STT_ERROR_OPERATION_FAILED;
608 bux_val = buxton_value_create_string(engine_id);
609 if (NULL == bux_val) {
610 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
611 buxton_free_layer(bux_layer);
612 buxton_close(bux_cli);
615 return STT_ERROR_OPERATION_FAILED;
618 ret = buxton_set_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_CUSTOM, bux_val);
620 SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to set value sync");
621 buxton_value_free(bux_val);
622 buxton_free_layer(bux_layer);
623 buxton_close(bux_cli);
628 return STT_ERROR_OPERATION_FAILED;
630 SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, STT_ENGINE_DB_CUSTOM);
632 buxton_value_free(bux_val);
633 buxton_free_layer(bux_layer);
634 buxton_close(bux_cli);
640 return STT_ERROR_NONE;
643 int stt_set_engine(stt_h stt, const char* engine_id)
645 stt_client_s* client = NULL;
646 if (0 != __stt_get_feature_enabled()) {
647 return STT_ERROR_NOT_SUPPORTED;
649 if (0 != __stt_check_privilege()) {
650 return STT_ERROR_PERMISSION_DENIED;
652 if (0 != __stt_check_privilege_for_applaunch()) {
653 return STT_ERROR_PERMISSION_DENIED;
655 if (0 != __stt_check_handle(stt, &client)) {
656 return STT_ERROR_INVALID_PARAMETER;
659 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
661 if (NULL == engine_id) {
662 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
663 return STT_ERROR_INVALID_PARAMETER;
667 if (client->current_state != STT_STATE_CREATED) {
668 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
669 return STT_ERROR_INVALID_STATE;
672 if (NULL != client->current_engine_id) {
673 free(client->current_engine_id);
674 client->current_engine_id = NULL;
677 SLOG(LOG_DEBUG, TAG_STTC, "===== engined_id(%s)", engine_id);
679 client->current_engine_id = strdup(engine_id);
682 int ret = __stt_set_buxtonkey(engine_id);
684 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] set buxtonkey Failed!!!");
688 SLOG(LOG_DEBUG, TAG_STTC, "=====");
689 SLOG(LOG_DEBUG, TAG_STTC, " ");
694 int stt_set_credential(stt_h stt, const char* credential)
696 stt_client_s* client = NULL;
697 if (0 != __stt_get_feature_enabled()) {
698 return STT_ERROR_NOT_SUPPORTED;
700 if (0 != __stt_check_privilege()) {
701 return STT_ERROR_PERMISSION_DENIED;
703 if (0 != __stt_check_handle(stt, &client)) {
704 return STT_ERROR_INVALID_PARAMETER;
707 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
709 if (NULL == credential) {
710 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
711 return STT_ERROR_INVALID_PARAMETER;
715 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
716 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
717 return STT_ERROR_INVALID_STATE;
720 if (NULL != client->credential) {
721 free(client->credential);
722 client->credential = NULL;
724 client->credential = strdup(credential);
726 SLOG(LOG_DEBUG, TAG_STTC, "=====");
727 SLOG(LOG_DEBUG, TAG_STTC, " ");
729 return STT_ERROR_NONE;
732 int stt_set_private_data(stt_h stt, const char* key, const char* data)
734 stt_client_s* client = NULL;
735 if (0 != __stt_get_feature_enabled()) {
736 return STT_ERROR_NOT_SUPPORTED;
738 if (0 != __stt_check_privilege()) {
739 return STT_ERROR_PERMISSION_DENIED;
741 if (0 != __stt_check_handle(stt, &client)) {
742 return STT_ERROR_INVALID_PARAMETER;
745 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
747 if (NULL == key || NULL == data) {
748 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
749 return STT_ERROR_INVALID_PARAMETER;
753 if (STT_STATE_READY != client->current_state) {
754 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
755 return STT_ERROR_INVALID_STATE;
758 if (true != client->internal && (0 == strcmp(key, "server") || 0 == strcmp(key, "rampcode") || 0 == strcmp(key, "epd"))) {
759 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This is not an internal app");
760 return STT_ERROR_INVALID_PARAMETER;
766 ret = stt_dbus_request_set_private_data(client->uid, key, data);
768 if (STT_ERROR_TIMED_OUT != ret) {
769 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
772 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
775 if (STT_RETRY_COUNT == count) {
776 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
783 SLOG(LOG_DEBUG, TAG_STTC, "=====");
784 SLOG(LOG_DEBUG, TAG_STTC, "");
786 return STT_ERROR_NONE;
789 int stt_get_private_data(stt_h stt, const char* key, char** data)
791 stt_client_s* client = NULL;
792 if (0 != __stt_get_feature_enabled()) {
793 return STT_ERROR_NOT_SUPPORTED;
795 if (0 != __stt_check_privilege()) {
796 return STT_ERROR_PERMISSION_DENIED;
798 if (0 != __stt_check_handle(stt, &client)) {
799 return STT_ERROR_INVALID_PARAMETER;
802 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
804 if (NULL == key || NULL == data) {
805 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
806 return STT_ERROR_INVALID_PARAMETER;
810 if (STT_STATE_READY != client->current_state) {
811 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
812 return STT_ERROR_INVALID_STATE;
818 ret = stt_dbus_request_get_private_data(client->uid, key, data);
820 if (STT_ERROR_TIMED_OUT != ret) {
821 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
824 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
827 if (STT_RETRY_COUNT == count) {
828 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
835 if (0 == strncmp(*data, "NULL", strlen(*data))) {
840 SLOG(LOG_DEBUG, TAG_STTC, "=====");
841 SLOG(LOG_DEBUG, TAG_STTC, "");
843 return STT_ERROR_NONE;
846 int stt_set_server_stt(stt_h stt, const char* key, char* user_data)
849 stt_client_s* client = NULL;
851 if (0 != __stt_get_feature_enabled()) {
852 return STT_ERROR_NOT_SUPPORTED;
854 if (0 != __stt_check_privilege()) {
855 return STT_ERROR_PERMISSION_DENIED;
857 if (0 != __stt_check_handle(stt, &client)) {
858 return STT_ERROR_INVALID_PARAMETER;
861 SLOG(LOG_DEBUG, TAG_STTC, "===== Set STT server");
863 if (NULL == key || NULL == user_data) {
864 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
865 return STT_ERROR_INVALID_PARAMETER;
868 if (STT_STATE_CREATED != client->current_state && STT_STATE_READY != client->current_state) {
869 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] The current state is invalid (%d).", client->current_state);
870 return STT_ERROR_INVALID_STATE;
874 client->internal = true;
876 char* private_key = NULL;
877 private_key = strdup(key);
878 if (NULL == private_key) {
879 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory(private_key)");
880 return STT_ERROR_OUT_OF_MEMORY;
884 data = strdup(user_data);
886 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory(data)");
889 return STT_ERROR_OUT_OF_MEMORY;
892 ret = stt_set_private_data(stt, private_key, data);
894 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data, ret(%d), key(%s)", ret, private_key);
902 SLOG(LOG_DEBUG, TAG_STTC, "======");
903 SLOG(LOG_DEBUG, TAG_STTC, " ");
908 static Eina_Bool __stt_connect_daemon(void *data)
910 stt_client_s* client = (stt_client_s*)data;
913 if (NULL == client) {
914 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
915 g_connect_timer = NULL;
919 if (0 == stt_client_get_size() || NULL == stt_client_get_by_uid(client->uid)) {
920 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Client has been already destroyed");
924 /* Check and Set vconfkey of custom engine before sending hello */
925 if (1 == g_privilege_applaunch_allowed && NULL != client->current_engine_id) {
927 ret = __stt_set_buxtonkey(client->current_engine_id);
929 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] set buxtonkey Failed!!! (inside __stt_connect_daemon)");
935 ret = stt_dbus_request_hello(client->uid);
938 if (STT_ERROR_INVALID_STATE == ret) {
939 g_connect_timer = NULL;
945 g_connect_timer = NULL;
946 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect stt-service");
948 /* request initialization */
949 bool silence_supported = false;
950 bool credential_needed = false;
952 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
954 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
955 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
957 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
958 ecore_main_loop_thread_safe_call_async(__stt_notify_error, (void*)client);
962 } else if (STT_ERROR_NONE != ret) {
963 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
966 /* success to connect stt-service */
967 client->silence_supported = silence_supported;
968 client->credential_needed = credential_needed;
969 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
972 #ifdef __UNUSED_CODES__
973 if (NULL != client->current_engine_id) {
976 silence_supported = false;
977 credential_needed = false;
978 SLOG(LOG_DEBUG, TAG_STTC, "[WARNING] current_engine_id(%s)", client->current_engine_id);
981 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
983 if (STT_ERROR_TIMED_OUT != ret) {
984 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
987 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
990 if (STT_RETRY_COUNT == count) {
991 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
996 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
998 /* success to change engine */
999 client->silence_supported = silence_supported;
1000 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
1005 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
1007 client->before_state = client->current_state;
1008 client->current_state = STT_STATE_READY;
1010 if (NULL != client->state_changed_cb) {
1011 stt_client_use_callback(client);
1012 client->state_changed_cb(client->stt, client->before_state,
1013 client->current_state, client->state_changed_user_data);
1014 stt_client_not_use_callback(client);
1015 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1017 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1020 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1021 SLOG(LOG_DEBUG, TAG_STTC, " ");
1026 int stt_prepare(stt_h stt)
1028 stt_client_s* client = NULL;
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;
1035 if (0 != __stt_check_handle(stt, &client)) {
1036 return STT_ERROR_INVALID_PARAMETER;
1040 if (client->current_state != STT_STATE_CREATED) {
1041 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
1042 return STT_ERROR_INVALID_STATE;
1045 ecore_thread_main_loop_begin();
1046 g_connect_timer = ecore_timer_add(0.02, __stt_connect_daemon, (void*)client);
1047 ecore_thread_main_loop_end();
1049 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1050 SLOG(LOG_DEBUG, TAG_STTC, " ");
1052 return STT_ERROR_NONE;
1055 int stt_unprepare(stt_h stt)
1057 stt_client_s* client = NULL;
1058 if (0 != __stt_get_feature_enabled()) {
1059 return STT_ERROR_NOT_SUPPORTED;
1061 if (0 != __stt_check_privilege()) {
1062 return STT_ERROR_PERMISSION_DENIED;
1064 if (0 != __stt_check_handle(stt, &client)) {
1065 return STT_ERROR_INVALID_PARAMETER;
1068 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
1071 if (client->current_state != STT_STATE_READY) {
1072 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
1073 return STT_ERROR_INVALID_STATE;
1079 ret = stt_dbus_request_finalize(client->uid);
1081 if (STT_ERROR_TIMED_OUT != ret) {
1082 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
1085 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1088 if (STT_RETRY_COUNT == count) {
1089 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1096 client->internal_state = STT_INTERNAL_STATE_NONE;
1098 client->before_state = client->current_state;
1099 client->current_state = STT_STATE_CREATED;
1101 if (NULL != client->state_changed_cb) {
1102 stt_client_use_callback(client);
1103 client->state_changed_cb(client->stt, client->before_state,
1104 client->current_state, client->state_changed_user_data);
1105 stt_client_not_use_callback(client);
1107 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1110 if (g_connect_timer) {
1111 ecore_timer_del(g_connect_timer);
1112 g_connect_timer = NULL;
1115 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1116 SLOG(LOG_DEBUG, TAG_STTC, " ");
1118 return STT_ERROR_NONE;
1121 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
1123 stt_h stt = (stt_h)user_data;
1125 stt_client_s* client = stt_client_get(stt);
1126 if (NULL == client) {
1127 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
1131 /* call callback function */
1132 if (NULL != client->supported_lang_cb) {
1133 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
1135 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
1141 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
1143 stt_client_s* client = NULL;
1144 if (0 != __stt_get_feature_enabled()) {
1145 return STT_ERROR_NOT_SUPPORTED;
1147 if (0 != __stt_check_privilege()) {
1148 return STT_ERROR_PERMISSION_DENIED;
1150 if (0 != __stt_check_handle(stt, &client)) {
1151 return STT_ERROR_INVALID_PARAMETER;
1154 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
1156 if (NULL == callback) {
1157 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1158 return STT_ERROR_INVALID_PARAMETER;
1162 char* current_engine_id = NULL;
1164 if (NULL == client->current_engine_id) {
1165 ret = stt_config_mgr_get_engine(¤t_engine_id);
1166 ret = __stt_convert_config_error_code(ret);
1168 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
1172 current_engine_id = strdup(client->current_engine_id);
1173 if (NULL == current_engine_id) {
1174 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1175 return STT_ERROR_OUT_OF_MEMORY;
1179 client->supported_lang_cb = callback;
1180 client->supported_lang_user_data = user_data;
1182 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
1183 ret = __stt_convert_config_error_code(ret);
1185 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
1188 if (NULL != current_engine_id) {
1189 free(current_engine_id);
1190 current_engine_id = NULL;
1193 client->supported_lang_cb = NULL;
1194 client->supported_lang_user_data = NULL;
1196 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1197 SLOG(LOG_DEBUG, TAG_STTC, " ");
1202 int stt_get_default_language(stt_h stt, char** language)
1204 stt_client_s* client = NULL;
1205 if (0 != __stt_get_feature_enabled()) {
1206 return STT_ERROR_NOT_SUPPORTED;
1208 if (0 != __stt_check_privilege()) {
1209 return STT_ERROR_PERMISSION_DENIED;
1211 if (0 != __stt_check_handle(stt, &client)) {
1212 return STT_ERROR_INVALID_PARAMETER;
1215 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
1217 if (NULL == language) {
1218 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1219 return STT_ERROR_INVALID_PARAMETER;
1223 ret = stt_config_mgr_get_default_language(language);
1224 ret = __stt_convert_config_error_code(ret);
1226 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
1228 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
1231 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1232 SLOG(LOG_DEBUG, TAG_STTC, " ");
1237 int stt_get_state(stt_h stt, stt_state_e* state)
1239 stt_client_s* client = NULL;
1240 if (0 != __stt_get_feature_enabled()) {
1241 return STT_ERROR_NOT_SUPPORTED;
1243 if (0 != __stt_check_privilege()) {
1244 return STT_ERROR_PERMISSION_DENIED;
1246 if (0 != __stt_check_handle(stt, &client)) {
1247 return STT_ERROR_INVALID_PARAMETER;
1250 if (NULL == state) {
1251 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1252 return STT_ERROR_INVALID_PARAMETER;
1255 *state = client->current_state;
1258 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1259 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1260 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1261 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1262 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1265 return STT_ERROR_NONE;
1268 int stt_get_error_message(stt_h stt, char** err_msg)
1270 stt_client_s* client = NULL;
1271 if (0 != __stt_get_feature_enabled()) {
1272 return STT_ERROR_NOT_SUPPORTED;
1274 if (0 != __stt_check_privilege()) {
1275 return STT_ERROR_PERMISSION_DENIED;
1277 if (0 != __stt_check_handle(stt, &client)) {
1278 return STT_ERROR_INVALID_PARAMETER;
1281 if (NULL == err_msg) {
1282 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1283 return STT_ERROR_INVALID_PARAMETER;
1286 if (false == g_err_callback_status) {
1287 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1288 return STT_ERROR_OPERATION_FAILED;
1291 if (NULL != client->err_msg) {
1292 *err_msg = strdup(client->err_msg);
1293 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1295 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1298 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1299 SLOG(LOG_DEBUG, TAG_STTC, " ");
1301 return STT_ERROR_NONE;
1304 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1306 stt_client_s* client = NULL;
1307 if (0 != __stt_get_feature_enabled()) {
1308 return STT_ERROR_NOT_SUPPORTED;
1310 if (0 != __stt_check_privilege()) {
1311 return STT_ERROR_PERMISSION_DENIED;
1313 if (0 != __stt_check_handle(stt, &client)) {
1314 return STT_ERROR_INVALID_PARAMETER;
1317 if (NULL == type || NULL == support) {
1318 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1319 return STT_ERROR_INVALID_PARAMETER;
1323 if (client->current_state != STT_STATE_READY) {
1324 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1325 return STT_ERROR_INVALID_STATE;
1331 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1333 if (STT_ERROR_TIMED_OUT != ret) {
1334 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1337 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1340 if (STT_RETRY_COUNT == count) {
1341 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1346 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1351 return STT_ERROR_NONE;
1354 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1356 stt_client_s* client = NULL;
1357 if (0 != __stt_get_feature_enabled()) {
1358 return STT_ERROR_NOT_SUPPORTED;
1360 if (0 != __stt_check_privilege()) {
1361 return STT_ERROR_PERMISSION_DENIED;
1363 if (0 != __stt_check_handle(stt, &client)) {
1364 return STT_ERROR_INVALID_PARAMETER;
1368 if (client->current_state != STT_STATE_READY) {
1369 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1370 return STT_ERROR_INVALID_STATE;
1373 if (true == client->silence_supported) {
1374 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1375 client->silence = type;
1377 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1378 return STT_ERROR_INVALID_PARAMETER;
1381 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1384 return STT_ERROR_NONE;
1387 int stt_set_start_sound(stt_h stt, const char* filename)
1389 stt_client_s* client = NULL;
1390 if (0 != __stt_get_feature_enabled()) {
1391 return STT_ERROR_NOT_SUPPORTED;
1393 if (0 != __stt_check_privilege()) {
1394 return STT_ERROR_PERMISSION_DENIED;
1396 if (0 != __stt_check_handle(stt, &client)) {
1397 return STT_ERROR_INVALID_PARAMETER;
1400 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1402 if (NULL == filename) {
1403 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1404 return STT_ERROR_INVALID_PARAMETER;
1407 if (0 != access(filename, F_OK)) {
1408 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1409 return STT_ERROR_INVALID_PARAMETER;
1413 if (client->current_state != STT_STATE_READY) {
1414 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1415 return STT_ERROR_INVALID_STATE;
1421 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1423 if (STT_ERROR_TIMED_OUT != ret) {
1424 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1427 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1430 if (STT_RETRY_COUNT == count) {
1431 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1436 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1441 return STT_ERROR_NONE;
1444 int stt_unset_start_sound(stt_h stt)
1446 stt_client_s* client = NULL;
1447 if (0 != __stt_get_feature_enabled()) {
1448 return STT_ERROR_NOT_SUPPORTED;
1450 if (0 != __stt_check_privilege()) {
1451 return STT_ERROR_PERMISSION_DENIED;
1453 if (0 != __stt_check_handle(stt, &client)) {
1454 return STT_ERROR_INVALID_PARAMETER;
1457 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1460 if (client->current_state != STT_STATE_READY) {
1461 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1462 return STT_ERROR_INVALID_STATE;
1468 ret = stt_dbus_request_unset_start_sound(client->uid);
1470 if (STT_ERROR_TIMED_OUT != ret) {
1471 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1474 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1477 if (STT_RETRY_COUNT == count) {
1478 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1483 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1488 return STT_ERROR_NONE;
1491 int stt_set_stop_sound(stt_h stt, const char* filename)
1493 stt_client_s* client = NULL;
1494 if (0 != __stt_get_feature_enabled()) {
1495 return STT_ERROR_NOT_SUPPORTED;
1497 if (0 != __stt_check_privilege()) {
1498 return STT_ERROR_PERMISSION_DENIED;
1500 if (0 != __stt_check_handle(stt, &client)) {
1501 return STT_ERROR_INVALID_PARAMETER;
1504 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1506 if (NULL == filename) {
1507 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1508 return STT_ERROR_INVALID_PARAMETER;
1511 if (0 != access(filename, F_OK)) {
1512 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1513 return STT_ERROR_INVALID_PARAMETER;
1517 if (client->current_state != STT_STATE_READY) {
1518 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1519 return STT_ERROR_INVALID_STATE;
1525 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1527 if (STT_ERROR_TIMED_OUT != ret) {
1528 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1531 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1534 if (STT_RETRY_COUNT == count) {
1535 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1540 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1545 return STT_ERROR_NONE;
1548 int stt_unset_stop_sound(stt_h stt)
1550 stt_client_s* client = NULL;
1551 if (0 != __stt_get_feature_enabled()) {
1552 return STT_ERROR_NOT_SUPPORTED;
1554 if (0 != __stt_check_privilege()) {
1555 return STT_ERROR_PERMISSION_DENIED;
1557 if (0 != __stt_check_handle(stt, &client)) {
1558 return STT_ERROR_INVALID_PARAMETER;
1561 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1564 if (client->current_state != STT_STATE_READY) {
1565 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1566 return STT_ERROR_INVALID_STATE;
1572 ret = stt_dbus_request_unset_stop_sound(client->uid);
1574 if (STT_ERROR_TIMED_OUT != ret) {
1575 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1578 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1581 if (STT_RETRY_COUNT == count) {
1582 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1587 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1592 return STT_ERROR_NONE;
1595 int stt_start(stt_h stt, const char* language, const char* type)
1597 stt_client_s* client = NULL;
1598 if (0 != __stt_get_feature_enabled()) {
1599 return STT_ERROR_NOT_SUPPORTED;
1601 if (0 != __stt_check_privilege()) {
1602 return STT_ERROR_PERMISSION_DENIED;
1604 if (0 != __stt_check_handle(stt, &client)) {
1605 return STT_ERROR_INVALID_PARAMETER;
1608 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1611 if (client->current_state != STT_STATE_READY) {
1612 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1613 return STT_ERROR_INVALID_STATE;
1616 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1617 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1618 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1622 char appid[1024] = {0, };
1623 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
1625 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1626 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1628 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1632 if (NULL == language) {
1633 temp = strdup("default");
1635 temp = strdup(language);
1639 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1640 return STT_ERROR_OUT_OF_MEMORY;
1643 if (true == client->credential_needed && NULL == client->credential) {
1644 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1647 return STT_ERROR_PERMISSION_DENIED;
1650 client->internal_state = STT_INTERNAL_STATE_STARTING;
1651 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1653 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1654 client->internal_state = STT_INTERNAL_STATE_NONE;
1656 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1662 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1663 SLOG(LOG_DEBUG, TAG_STTC, " ");
1668 int stt_stop(stt_h stt)
1670 stt_client_s* client = NULL;
1671 if (0 != __stt_get_feature_enabled()) {
1672 return STT_ERROR_NOT_SUPPORTED;
1674 if (0 != __stt_check_privilege()) {
1675 return STT_ERROR_PERMISSION_DENIED;
1677 if (0 != __stt_check_handle(stt, &client)) {
1678 return STT_ERROR_INVALID_PARAMETER;
1681 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1684 if (client->current_state != STT_STATE_RECORDING) {
1685 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1686 return STT_ERROR_INVALID_STATE;
1689 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1690 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1691 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1692 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1693 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1694 return STT_ERROR_IN_PROGRESS_TO_READY;
1695 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1696 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1697 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1700 client->internal_state = STT_INTERNAL_STATE_STOPPING;
1701 int ret = stt_dbus_request_stop(client->uid);
1703 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1704 client->internal_state = STT_INTERNAL_STATE_NONE;
1706 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1709 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1710 SLOG(LOG_DEBUG, TAG_STTC, " ");
1716 int stt_cancel(stt_h stt)
1718 stt_client_s* client = NULL;
1719 if (0 != __stt_get_feature_enabled()) {
1720 return STT_ERROR_NOT_SUPPORTED;
1722 if (0 != __stt_check_privilege()) {
1723 return STT_ERROR_PERMISSION_DENIED;
1725 if (0 != __stt_check_handle(stt, &client)) {
1726 return STT_ERROR_INVALID_PARAMETER;
1729 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1732 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1733 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1734 return STT_ERROR_INVALID_STATE;
1737 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1738 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1739 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1740 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1741 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1742 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1743 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1744 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1745 return STT_ERROR_IN_PROGRESS_TO_READY;
1748 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1749 int ret = stt_dbus_request_cancel(client->uid);
1751 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1752 client->internal_state = STT_INTERNAL_STATE_NONE;
1754 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1757 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1758 SLOG(LOG_DEBUG, TAG_STTC, " ");
1763 int __stt_cb_set_volume(int uid, float volume)
1765 stt_client_s* client = NULL;
1767 client = stt_client_get_by_uid(uid);
1768 if (NULL == client) {
1769 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1770 return STT_ERROR_INVALID_PARAMETER;
1773 if (STT_STATE_RECORDING != client->current_state) {
1774 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1775 return STT_ERROR_INVALID_STATE;
1778 g_volume_db = volume;
1779 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1784 int stt_get_recording_volume(stt_h stt, float* volume)
1786 stt_client_s* client = NULL;
1787 if (0 != __stt_get_feature_enabled()) {
1788 return STT_ERROR_NOT_SUPPORTED;
1790 if (0 != __stt_check_privilege()) {
1791 return STT_ERROR_PERMISSION_DENIED;
1793 if (0 != __stt_check_handle(stt, &client)) {
1794 return STT_ERROR_INVALID_PARAMETER;
1797 if (NULL == volume) {
1798 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1799 return STT_ERROR_INVALID_PARAMETER;
1802 if (STT_STATE_RECORDING != client->current_state) {
1803 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1804 return STT_ERROR_INVALID_STATE;
1807 *volume = g_volume_db;
1809 return STT_ERROR_NONE;
1812 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1814 stt_client_s* client = (stt_client_s*)user_data;
1817 if (NULL == client) {
1818 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1822 if (NULL != client->result_time_cb) {
1823 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1824 index, event, text, start_time, end_time);
1825 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1826 text, start_time, end_time, client->result_time_user_data);
1828 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1835 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1837 stt_client_s* client = NULL;
1838 if (0 != __stt_get_feature_enabled()) {
1839 return STT_ERROR_NOT_SUPPORTED;
1841 if (0 != __stt_check_privilege()) {
1842 return STT_ERROR_PERMISSION_DENIED;
1844 if (0 != __stt_check_handle(stt, &client)) {
1845 return STT_ERROR_INVALID_PARAMETER;
1848 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1850 if (NULL == callback) {
1851 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1852 return STT_ERROR_INVALID_PARAMETER;
1855 client->result_time_cb = callback;
1856 client->result_time_user_data = user_data;
1859 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1860 ret = __stt_convert_config_error_code(ret);
1862 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1865 client->result_time_cb = NULL;
1866 client->result_time_user_data = NULL;
1868 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1869 SLOG(LOG_DEBUG, TAG_STTC, " ");
1874 static void __stt_notify_error(void *data)
1876 stt_client_s* client = (stt_client_s*)data;
1878 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1881 if (NULL == client) {
1882 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1886 if (NULL == stt_client_get_by_uid(client->uid))
1889 if (NULL != client->error_cb) {
1890 stt_client_use_callback(client);
1891 g_err_callback_status = true;
1892 client->error_cb(client->stt, client->reason, client->error_user_data);
1893 g_err_callback_status = false;
1894 stt_client_not_use_callback(client);
1895 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1897 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1903 int __stt_cb_error(int uid, int reason, char* err_msg)
1906 GList* client_list = NULL;
1907 client_list = stt_client_get_client_list();
1910 stt_client_s *data = NULL;
1912 if (g_list_length(client_list) > 0) {
1913 /* Get a first item */
1914 iter = g_list_first(client_list);
1916 while (NULL != iter) {
1919 data->reason = reason;
1920 data->internal_state = STT_INTERNAL_STATE_NONE;
1921 if (NULL != data->err_msg) {
1922 free(data->err_msg);
1923 data->err_msg = NULL;
1925 if (NULL != err_msg)
1926 data->err_msg = strdup(err_msg);
1928 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1930 if (NULL != data->error_cb) {
1931 ecore_main_loop_thread_safe_call_async(__stt_notify_error, data);
1933 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1936 if (STT_ERROR_SERVICE_RESET == reason) {
1937 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
1939 data->current_state = STT_STATE_CREATED;
1940 if (0 != stt_prepare(data->stt)) {
1941 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
1946 iter = g_list_next(iter);
1950 stt_client_s* client = stt_client_get_by_uid(uid);
1951 if (NULL == client) {
1952 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1956 client->reason = reason;
1957 client->internal_state = STT_INTERNAL_STATE_NONE;
1958 if (NULL != client->err_msg) {
1959 free(client->err_msg);
1960 client->err_msg = NULL;
1962 if (NULL != err_msg)
1963 client->err_msg = strdup(err_msg);
1965 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1967 if (NULL != client->error_cb) {
1968 ecore_main_loop_thread_safe_call_async(__stt_notify_error, client);
1970 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1973 if (STT_ERROR_SERVICE_RESET == reason) {
1974 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
1976 client->current_state = STT_STATE_CREATED;
1977 if (0 != stt_prepare(client->stt)) {
1978 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
1986 static void __stt_notify_state_changed(void *data)
1988 stt_client_s* client = (stt_client_s*)data;
1991 if (NULL == client) {
1992 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1996 if (NULL == stt_client_get_by_uid(client->uid)) {
2000 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
2001 client->internal_state = STT_INTERNAL_STATE_NONE;
2002 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
2003 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
2004 client->internal_state = STT_INTERNAL_STATE_NONE;
2005 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
2006 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
2007 client->internal_state = STT_INTERNAL_STATE_NONE;
2008 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
2011 if (NULL != client->state_changed_cb) {
2012 stt_client_use_callback(client);
2013 client->state_changed_cb(client->stt, client->before_state,
2014 client->current_state, client->state_changed_user_data);
2015 stt_client_not_use_callback(client);
2016 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called, State(%d)", client->current_state);
2018 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null, State(%d)", client->current_state);
2024 static Eina_Bool __stt_notify_result(void *data)
2026 stt_client_s* client = (stt_client_s*)data;
2029 if (NULL == client) {
2030 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
2034 if (NULL == stt_client_get_by_uid(client->uid)) {
2038 if (NULL != client->recognition_result_cb) {
2039 stt_client_use_callback(client);
2040 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
2041 client->msg, client->recognition_result_user_data);
2042 stt_client_not_use_callback(client);
2043 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
2045 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
2048 if (NULL != client->msg) {
2053 if (NULL != client->data_list) {
2055 temp = client->data_list;
2058 for (i = 0; i < client->data_count; i++) {
2059 if (NULL != temp[i]) {
2063 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
2066 free(client->data_list);
2067 client->data_list = NULL;
2070 client->data_count = 0;
2072 stt_config_mgr_remove_time_info_file();
2074 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
2075 client->before_state = client->current_state;
2076 client->current_state = STT_STATE_READY;
2078 if (NULL != client->state_changed_cb) {
2079 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
2081 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
2088 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
2090 stt_client_s* client = NULL;
2092 client = stt_client_get_by_uid(uid);
2093 if (NULL == client) {
2094 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
2095 return STT_ERROR_INVALID_PARAMETER;
2099 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
2102 for (i = 0; i < data_count; i++) {
2103 if (NULL != data[i])
2104 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
2107 if (NULL != client->recognition_result_cb) {
2108 client->event = event;
2110 client->msg = strdup(msg);
2113 client->data_count = data_count;
2115 if (data_count > 0) {
2117 temp = (char**)calloc(data_count, sizeof(char*));
2119 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
2120 return STT_ERROR_OUT_OF_MEMORY;
2123 for (i = 0; i < data_count; i++) {
2124 if (NULL != data[i])
2125 temp[i] = strdup(data[i]);
2127 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
2130 client->data_list = temp;
2133 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
2136 __stt_notify_result(client);
2138 return STT_ERROR_NONE;
2141 int __stt_cb_set_state(int uid, int state)
2143 stt_client_s* client = stt_client_get_by_uid(uid);
2144 if (NULL == client) {
2145 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
2149 stt_state_e state_from_daemon = (stt_state_e)state;
2151 if (client->current_state == state_from_daemon) {
2152 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
2156 client->before_state = client->current_state;
2157 client->current_state = state_from_daemon;
2159 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
2163 static void __stt_notify_speech_status(void *data)
2165 stt_client_s* client = (stt_client_s*)data;
2168 if (NULL == client) {
2169 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify speech status : A handle is not valid");
2173 if (NULL == stt_client_get_by_uid(client->uid)) {
2177 if (NULL != client->speech_status_cb) {
2178 stt_client_use_callback(client);
2179 client->speech_status_cb(client->stt, client->speech_status, client->speech_status_user_data);
2180 stt_client_not_use_callback(client);
2181 SLOG(LOG_DEBUG, TAG_STTC, "Speech status callback is called");
2183 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Speech status callback is null");
2189 int __stt_cb_speech_status(int uid, int status)
2191 stt_client_s* client = stt_client_get_by_uid(uid);
2192 if (NULL == client) {
2193 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
2197 client->speech_status = status;
2199 ecore_main_loop_thread_safe_call_async(__stt_notify_speech_status, client);
2203 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
2205 stt_client_s* client = NULL;
2206 if (0 != __stt_get_feature_enabled()) {
2207 return STT_ERROR_NOT_SUPPORTED;
2209 if (0 != __stt_check_privilege()) {
2210 return STT_ERROR_PERMISSION_DENIED;
2212 if (0 != __stt_check_handle(stt, &client)) {
2213 return STT_ERROR_INVALID_PARAMETER;
2216 if (callback == NULL)
2217 return STT_ERROR_INVALID_PARAMETER;
2219 if (STT_STATE_CREATED != client->current_state) {
2220 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2221 return STT_ERROR_INVALID_STATE;
2224 client->recognition_result_cb = callback;
2225 client->recognition_result_user_data = user_data;
2230 int stt_unset_recognition_result_cb(stt_h stt)
2232 stt_client_s* client = NULL;
2233 if (0 != __stt_get_feature_enabled()) {
2234 return STT_ERROR_NOT_SUPPORTED;
2236 if (0 != __stt_check_privilege()) {
2237 return STT_ERROR_PERMISSION_DENIED;
2239 if (0 != __stt_check_handle(stt, &client)) {
2240 return STT_ERROR_INVALID_PARAMETER;
2243 if (STT_STATE_CREATED != client->current_state) {
2244 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2245 return STT_ERROR_INVALID_STATE;
2248 client->recognition_result_cb = NULL;
2249 client->recognition_result_user_data = NULL;
2254 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
2256 stt_client_s* client = NULL;
2257 if (0 != __stt_get_feature_enabled()) {
2258 return STT_ERROR_NOT_SUPPORTED;
2260 if (0 != __stt_check_privilege()) {
2261 return STT_ERROR_PERMISSION_DENIED;
2263 if (0 != __stt_check_handle(stt, &client)) {
2264 return STT_ERROR_INVALID_PARAMETER;
2267 if (NULL == callback)
2268 return STT_ERROR_INVALID_PARAMETER;
2270 if (STT_STATE_CREATED != client->current_state) {
2271 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2272 return STT_ERROR_INVALID_STATE;
2275 client->state_changed_cb = callback;
2276 client->state_changed_user_data = user_data;
2281 int stt_unset_state_changed_cb(stt_h stt)
2283 stt_client_s* client = NULL;
2284 if (0 != __stt_get_feature_enabled()) {
2285 return STT_ERROR_NOT_SUPPORTED;
2287 if (0 != __stt_check_privilege()) {
2288 return STT_ERROR_PERMISSION_DENIED;
2290 if (0 != __stt_check_handle(stt, &client)) {
2291 return STT_ERROR_INVALID_PARAMETER;
2294 if (STT_STATE_CREATED != client->current_state) {
2295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2296 return STT_ERROR_INVALID_STATE;
2299 client->state_changed_cb = NULL;
2300 client->state_changed_user_data = NULL;
2305 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
2307 stt_client_s* client = NULL;
2308 if (0 != __stt_get_feature_enabled()) {
2309 return STT_ERROR_NOT_SUPPORTED;
2311 if (0 != __stt_check_privilege()) {
2312 return STT_ERROR_PERMISSION_DENIED;
2314 if (0 != __stt_check_handle(stt, &client)) {
2315 return STT_ERROR_INVALID_PARAMETER;
2318 if (NULL == callback)
2319 return STT_ERROR_INVALID_PARAMETER;
2321 if (STT_STATE_CREATED != client->current_state) {
2322 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2323 return STT_ERROR_INVALID_STATE;
2326 client->error_cb = callback;
2327 client->error_user_data = user_data;
2332 int stt_unset_error_cb(stt_h stt)
2334 stt_client_s* client = NULL;
2335 if (0 != __stt_get_feature_enabled()) {
2336 return STT_ERROR_NOT_SUPPORTED;
2338 if (0 != __stt_check_privilege()) {
2339 return STT_ERROR_PERMISSION_DENIED;
2341 if (0 != __stt_check_handle(stt, &client)) {
2342 return STT_ERROR_INVALID_PARAMETER;
2345 if (STT_STATE_CREATED != client->current_state) {
2346 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2347 return STT_ERROR_INVALID_STATE;
2350 client->error_cb = NULL;
2351 client->error_user_data = NULL;
2356 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2358 stt_client_s* client = NULL;
2359 if (0 != __stt_get_feature_enabled()) {
2360 return STT_ERROR_NOT_SUPPORTED;
2362 if (0 != __stt_check_privilege()) {
2363 return STT_ERROR_PERMISSION_DENIED;
2365 if (0 != __stt_check_handle(stt, &client)) {
2366 return STT_ERROR_INVALID_PARAMETER;
2369 if (NULL == callback)
2370 return STT_ERROR_INVALID_PARAMETER;
2372 if (STT_STATE_CREATED != client->current_state) {
2373 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2374 return STT_ERROR_INVALID_STATE;
2377 client->default_lang_changed_cb = callback;
2378 client->default_lang_changed_user_data = user_data;
2383 int stt_unset_default_language_changed_cb(stt_h stt)
2385 stt_client_s* client = NULL;
2386 if (0 != __stt_get_feature_enabled()) {
2387 return STT_ERROR_NOT_SUPPORTED;
2389 if (0 != __stt_check_privilege()) {
2390 return STT_ERROR_PERMISSION_DENIED;
2392 if (0 != __stt_check_handle(stt, &client)) {
2393 return STT_ERROR_INVALID_PARAMETER;
2396 if (STT_STATE_CREATED != client->current_state) {
2397 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2398 return STT_ERROR_INVALID_STATE;
2401 client->default_lang_changed_cb = NULL;
2402 client->default_lang_changed_user_data = NULL;
2407 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2409 stt_client_s* client = NULL;
2410 if (0 != __stt_get_feature_enabled()) {
2411 return STT_ERROR_NOT_SUPPORTED;
2413 if (0 != __stt_check_privilege()) {
2414 return STT_ERROR_PERMISSION_DENIED;
2416 if (0 != __stt_check_handle(stt, &client)) {
2417 return STT_ERROR_INVALID_PARAMETER;
2420 if (NULL == callback)
2421 return STT_ERROR_INVALID_PARAMETER;
2423 if (STT_STATE_CREATED != client->current_state) {
2424 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2425 return STT_ERROR_INVALID_STATE;
2428 client->engine_changed_cb = callback;
2429 client->engine_changed_user_data = user_data;
2434 int stt_unset_engine_changed_cb(stt_h stt)
2436 stt_client_s* client = NULL;
2437 if (0 != __stt_get_feature_enabled()) {
2438 return STT_ERROR_NOT_SUPPORTED;
2440 if (0 != __stt_check_privilege()) {
2441 return STT_ERROR_PERMISSION_DENIED;
2443 if (0 != __stt_check_handle(stt, &client)) {
2444 return STT_ERROR_INVALID_PARAMETER;
2447 if (STT_STATE_CREATED != client->current_state) {
2448 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2449 return STT_ERROR_INVALID_STATE;
2452 client->engine_changed_cb = NULL;
2453 client->engine_changed_user_data = NULL;
2458 int stt_set_speech_status_cb(stt_h stt, stt_speech_status_cb callback, void* user_data)
2460 stt_client_s* client = NULL;
2461 if (0 != __stt_get_feature_enabled()) {
2462 return STT_ERROR_NOT_SUPPORTED;
2464 if (0 != __stt_check_privilege()) {
2465 return STT_ERROR_PERMISSION_DENIED;
2467 if (0 != __stt_check_handle(stt, &client)) {
2468 return STT_ERROR_INVALID_PARAMETER;
2471 if (NULL == callback)
2472 return STT_ERROR_INVALID_PARAMETER;
2474 if (STT_STATE_CREATED != client->current_state) {
2475 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2476 return STT_ERROR_INVALID_STATE;
2479 client->speech_status_cb = callback;
2480 client->speech_status_user_data = user_data;
2485 int stt_unset_speech_status_cb(stt_h stt)
2487 stt_client_s* client = NULL;
2488 if (0 != __stt_get_feature_enabled()) {
2489 return STT_ERROR_NOT_SUPPORTED;
2491 if (0 != __stt_check_privilege()) {
2492 return STT_ERROR_PERMISSION_DENIED;
2494 if (0 != __stt_check_handle(stt, &client)) {
2495 return STT_ERROR_INVALID_PARAMETER;
2498 if (STT_STATE_CREATED != client->current_state) {
2499 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2500 return STT_ERROR_INVALID_STATE;
2503 client->speech_status_cb = NULL;
2504 client->speech_status_user_data = NULL;
2509 int stt_start_file(stt_h stt, const char* language, const char* type, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
2511 stt_client_s* client = NULL;
2512 if (0 != __stt_get_feature_enabled()) {
2513 return STT_ERROR_NOT_SUPPORTED;
2515 if (0 != __stt_check_privilege()) {
2516 return STT_ERROR_PERMISSION_DENIED;
2518 if (0 != __stt_check_handle(stt, &client)) {
2519 return STT_ERROR_INVALID_PARAMETER;
2521 if (NULL == filepath) {
2522 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
2523 return STT_ERROR_INVALID_PARAMETER;
2526 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START FILE");
2529 if (client->current_state != STT_STATE_READY) {
2530 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
2531 return STT_ERROR_INVALID_STATE;
2534 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
2535 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
2536 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
2540 char appid[1024] = {0, };
2541 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
2543 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
2544 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
2546 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
2550 if (NULL == language) {
2551 temp = strdup("default");
2553 temp = strdup(language);
2557 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
2558 return STT_ERROR_OUT_OF_MEMORY;
2561 if (true == client->credential_needed && NULL == client->credential) {
2562 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
2565 return STT_ERROR_PERMISSION_DENIED;
2568 client->internal_state = STT_INTERNAL_STATE_STARTING;
2569 ret = stt_dbus_request_start_file(client->uid, temp, type, client->silence, appid, client->credential, filepath, audio_type, sample_rate);
2571 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start file : %s", __stt_get_error_code(ret));
2572 client->internal_state = STT_INTERNAL_STATE_NONE;
2574 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
2580 SLOG(LOG_DEBUG, TAG_STTC, "=====");
2581 SLOG(LOG_DEBUG, TAG_STTC, " ");
2586 int stt_cancel_file(stt_h stt)
2588 stt_client_s* client = NULL;
2589 if (0 != __stt_get_feature_enabled()) {
2590 return STT_ERROR_NOT_SUPPORTED;
2592 if (0 != __stt_check_privilege()) {
2593 return STT_ERROR_PERMISSION_DENIED;
2595 if (0 != __stt_check_handle(stt, &client)) {
2596 return STT_ERROR_INVALID_PARAMETER;
2599 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL FILE");
2602 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
2603 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
2604 return STT_ERROR_INVALID_STATE;
2607 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
2608 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
2609 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
2610 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
2611 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
2612 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
2613 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
2614 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
2615 return STT_ERROR_IN_PROGRESS_TO_READY;
2618 client->internal_state = STT_INTERNAL_STATE_CANCELING;
2619 int ret = stt_dbus_request_cancel_file(client->uid);
2621 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel file : %s", __stt_get_error_code(ret));
2622 client->internal_state = STT_INTERNAL_STATE_NONE;
2624 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel file is successful but not done");
2627 SLOG(LOG_DEBUG, TAG_STTC, "=====");
2628 SLOG(LOG_DEBUG, TAG_STTC, " ");