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>
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");
118 if (ret != CYNARA_API_ACCESS_ALLOWED)
123 static void __check_privilege_deinitialize()
126 cynara_finish(p_cynara);
130 static int __stt_check_privilege()
134 if (0 == g_privilege_allowed) {
135 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
136 return STT_ERROR_PERMISSION_DENIED;
137 } else if (-1 == g_privilege_allowed) {
138 if (false == __check_privilege_initialize()) {
139 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
140 return STT_ERROR_PERMISSION_DENIED;
142 snprintf(uid, 16, "%d", getuid());
143 if (false == __check_privilege(uid, STT_PRIVILEGE)) {
144 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
145 g_privilege_allowed = 0;
146 __check_privilege_deinitialize();
147 return STT_ERROR_PERMISSION_DENIED;
149 __check_privilege_deinitialize();
152 g_privilege_allowed = 1;
153 return STT_ERROR_NONE;
156 static const char* __stt_get_error_code(stt_error_e err)
159 case STT_ERROR_NONE: return "STT_ERROR_NONE";
160 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
161 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
162 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
163 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
164 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
165 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
166 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
167 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
168 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
169 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
170 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
171 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
172 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
173 case STT_ERROR_SERVICE_RESET: return "STT_ERROR_SERVICE_RESET";
175 return "Invalid error code";
179 static int __stt_convert_config_error_code(stt_config_error_e code)
181 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
182 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
183 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
184 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
185 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
186 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
187 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
188 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
189 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
190 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
195 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
197 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
198 before_language, current_language);
200 if (0 == strcmp(before_language, current_language)) {
204 GList* client_list = NULL;
205 client_list = stt_client_get_client_list();
208 stt_client_s *data = NULL;
210 if (g_list_length(client_list) > 0) {
211 /* Get a first item */
212 iter = g_list_first(client_list);
214 while (NULL != iter) {
216 if (NULL != data->default_lang_changed_cb) {
217 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
218 data->default_lang_changed_cb(data->stt, before_language, current_language,
219 data->default_lang_changed_user_data);
223 iter = g_list_next(iter);
230 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)
232 stt_h stt = (stt_h)user_data;
234 stt_client_s* client = stt_client_get(stt);
235 if (NULL == client) {
236 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
240 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
241 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
242 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
243 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
245 /* call callback function */
246 if (NULL != client->engine_changed_cb) {
247 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
249 SLOG(LOG_WARN, TAG_STTC, "No registered callback function for engine change");
254 static int __stt_check_handle(stt_h stt, stt_client_s** client)
257 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
258 return STT_ERROR_INVALID_PARAMETER;
261 stt_client_s* temp = NULL;
262 temp = stt_client_get(stt);
266 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
267 return STT_ERROR_INVALID_PARAMETER;
271 return STT_ERROR_NONE;
274 int stt_create(stt_h* stt)
276 if (0 != __stt_get_feature_enabled()) {
277 return STT_ERROR_NOT_SUPPORTED;
279 if (0 != __stt_check_privilege()) {
280 return STT_ERROR_PERMISSION_DENIED;
283 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
286 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
287 return STT_ERROR_INVALID_PARAMETER;
290 if (0 == stt_client_get_size()) {
291 if (0 != stt_dbus_open_connection()) {
292 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
293 return STT_ERROR_OPERATION_FAILED;
297 if (0 != stt_client_new(stt)) {
298 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
299 return STT_ERROR_OUT_OF_MEMORY;
302 stt_client_s* client = stt_client_get(*stt);
303 if (NULL == client) {
304 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
305 stt_client_destroy(*stt);
306 return STT_ERROR_OPERATION_FAILED;
309 int ret = stt_config_mgr_initialize(client->uid);
310 ret = __stt_convert_config_error_code(ret);
312 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
313 stt_client_destroy(*stt);
317 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
318 ret = __stt_convert_config_error_code(ret);
320 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
321 stt_client_destroy(*stt);
325 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
327 SLOG(LOG_DEBUG, TAG_STTC, "=====");
328 SLOG(LOG_DEBUG, TAG_STTC, " ");
330 return STT_ERROR_NONE;
333 int stt_destroy(stt_h stt)
335 stt_client_s* client = NULL;
336 if (0 != __stt_get_feature_enabled()) {
337 return STT_ERROR_NOT_SUPPORTED;
339 if (0 != __stt_check_privilege()) {
340 return STT_ERROR_PERMISSION_DENIED;
342 if (0 != __stt_check_handle(stt, &client)) {
343 return STT_ERROR_INVALID_PARAMETER;
346 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
348 /* check used callback */
349 if (0 != stt_client_get_use_callback(client)) {
350 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
351 return STT_ERROR_OPERATION_FAILED;
354 stt_config_mgr_finalize(client->uid);
359 switch (client->current_state) {
360 case STT_STATE_PROCESSING:
361 case STT_STATE_RECORDING:
362 case STT_STATE_READY:
363 ret = stt_dbus_request_finalize(client->uid);
365 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
367 case STT_STATE_CREATED:
368 if (NULL != g_connect_timer) {
369 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
370 ecore_timer_del(g_connect_timer);
371 g_connect_timer = NULL;
375 stt_client_destroy(stt);
381 if (0 == stt_client_get_size()) {
382 if (0 != stt_dbus_close_connection()) {
383 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
389 SLOG(LOG_DEBUG, TAG_STTC, "=====");
390 SLOG(LOG_DEBUG, TAG_STTC, " ");
392 return STT_ERROR_NONE;
395 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
396 const char* setting, bool support_silence, void* user_data)
398 stt_h stt = (stt_h)user_data;
400 stt_client_s* client = stt_client_get(stt);
401 if (NULL == client) {
402 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
406 /* call callback function */
407 if (NULL != client->supported_engine_cb) {
408 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
410 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
416 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
418 stt_client_s* client = NULL;
419 if (0 != __stt_get_feature_enabled()) {
420 return STT_ERROR_NOT_SUPPORTED;
422 if (0 != __stt_check_privilege()) {
423 return STT_ERROR_PERMISSION_DENIED;
425 if (0 != __stt_check_handle(stt, &client)) {
426 return STT_ERROR_INVALID_PARAMETER;
429 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
431 if (NULL == callback) {
432 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
433 return STT_ERROR_INVALID_PARAMETER;
436 if (client->current_state != STT_STATE_CREATED) {
437 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
438 return STT_ERROR_INVALID_STATE;
441 client->supported_engine_cb = callback;
442 client->supported_engine_user_data = user_data;
445 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
446 ret = __stt_convert_config_error_code(ret);
448 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
451 client->supported_engine_cb = NULL;
452 client->supported_engine_user_data = NULL;
454 SLOG(LOG_DEBUG, TAG_STTC, "=====");
455 SLOG(LOG_DEBUG, TAG_STTC, " ");
460 int stt_get_engine(stt_h stt, char** engine_id)
462 stt_client_s* client = NULL;
463 if (0 != __stt_get_feature_enabled()) {
464 return STT_ERROR_NOT_SUPPORTED;
466 if (0 != __stt_check_privilege()) {
467 return STT_ERROR_PERMISSION_DENIED;
469 if (0 != __stt_check_handle(stt, &client)) {
470 return STT_ERROR_INVALID_PARAMETER;
473 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
475 if (NULL == engine_id) {
476 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
477 return STT_ERROR_INVALID_PARAMETER;
480 if (client->current_state != STT_STATE_CREATED) {
481 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
482 return STT_ERROR_INVALID_STATE;
487 if (NULL != client->current_engine_id) {
488 *engine_id = strdup(client->current_engine_id);
489 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
492 ret = stt_config_mgr_get_engine(engine_id);
493 ret = __stt_convert_config_error_code(ret);
495 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
497 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
501 SLOG(LOG_DEBUG, TAG_STTC, "=====");
502 SLOG(LOG_DEBUG, TAG_STTC, " ");
507 int stt_set_engine(stt_h stt, const char* engine_id)
509 stt_client_s* client = NULL;
510 if (0 != __stt_get_feature_enabled()) {
511 return STT_ERROR_NOT_SUPPORTED;
513 if (0 != __stt_check_privilege()) {
514 return STT_ERROR_PERMISSION_DENIED;
516 if (0 != __stt_check_handle(stt, &client)) {
517 return STT_ERROR_INVALID_PARAMETER;
520 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
522 if (NULL == engine_id) {
523 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
524 return STT_ERROR_INVALID_PARAMETER;
528 if (client->current_state != STT_STATE_CREATED) {
529 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
530 return STT_ERROR_INVALID_STATE;
533 if (NULL != client->current_engine_id) {
534 free(client->current_engine_id);
537 SLOG(LOG_DEBUG, TAG_STTC, "===== engined_id(%s)", engine_id);
539 client->current_engine_id = strdup(engine_id);
541 SLOG(LOG_DEBUG, TAG_STTC, "=====");
542 SLOG(LOG_DEBUG, TAG_STTC, " ");
547 int stt_set_credential(stt_h stt, const char* credential)
549 stt_client_s* client = NULL;
550 if (0 != __stt_get_feature_enabled()) {
551 return STT_ERROR_NOT_SUPPORTED;
553 if (0 != __stt_check_privilege()) {
554 return STT_ERROR_PERMISSION_DENIED;
556 if (0 != __stt_check_handle(stt, &client)) {
557 return STT_ERROR_INVALID_PARAMETER;
560 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
562 if (NULL == credential) {
563 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
564 return STT_ERROR_INVALID_PARAMETER;
568 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
569 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
570 return STT_ERROR_INVALID_STATE;
573 if (NULL != client->credential) {
574 free(client->credential);
575 client->credential = NULL;
577 client->credential = strdup(credential);
579 SLOG(LOG_DEBUG, TAG_STTC, "=====");
580 SLOG(LOG_DEBUG, TAG_STTC, " ");
582 return STT_ERROR_NONE;
585 int stt_set_private_data(stt_h stt, const char* key, const char* data)
587 stt_client_s* client = NULL;
588 if (0 != __stt_get_feature_enabled()) {
589 return STT_ERROR_NOT_SUPPORTED;
591 if (0 != __stt_check_privilege()) {
592 return STT_ERROR_PERMISSION_DENIED;
594 if (0 != __stt_check_handle(stt, &client)) {
595 return STT_ERROR_INVALID_PARAMETER;
598 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
600 if (NULL == key || NULL == data) {
601 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
602 return STT_ERROR_INVALID_PARAMETER;
606 if (STT_STATE_READY != client->current_state) {
607 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
608 return STT_ERROR_INVALID_STATE;
614 ret = stt_dbus_request_set_private_data(client->uid, key, data);
616 if (STT_ERROR_TIMED_OUT != ret) {
617 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
620 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
623 if (STT_RETRY_COUNT == count) {
624 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
631 SLOG(LOG_DEBUG, TAG_STTC, "=====");
632 SLOG(LOG_DEBUG, TAG_STTC, "");
634 return STT_ERROR_NONE;
637 int stt_get_private_data(stt_h stt, const char* key, char** data)
639 stt_client_s* client = NULL;
640 if (0 != __stt_get_feature_enabled()) {
641 return STT_ERROR_NOT_SUPPORTED;
643 if (0 != __stt_check_privilege()) {
644 return STT_ERROR_PERMISSION_DENIED;
646 if (0 != __stt_check_handle(stt, &client)) {
647 return STT_ERROR_INVALID_PARAMETER;
650 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
652 if (NULL == key || NULL == data) {
653 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
654 return STT_ERROR_INVALID_PARAMETER;
658 if (STT_STATE_READY != client->current_state) {
659 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
660 return STT_ERROR_INVALID_STATE;
666 ret = stt_dbus_request_get_private_data(client->uid, key, data);
668 if (STT_ERROR_TIMED_OUT != ret) {
669 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
672 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
675 if (STT_RETRY_COUNT == count) {
676 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
683 if (0 == strncmp(*data, "NULL", strlen(*data))) {
688 SLOG(LOG_DEBUG, TAG_STTC, "=====");
689 SLOG(LOG_DEBUG, TAG_STTC, "");
691 return STT_ERROR_NONE;
693 static Eina_Bool __stt_connect_daemon(void *data)
695 stt_client_s* client = (stt_client_s*)data;
697 if (NULL == client) {
698 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
699 g_connect_timer = NULL;
705 ret = stt_dbus_request_hello();
708 if (STT_ERROR_INVALID_STATE == ret) {
709 g_connect_timer = NULL;
715 g_connect_timer = NULL;
716 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect stt-service");
718 /* request initialization */
719 bool silence_supported = false;
720 bool credential_needed = false;
722 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
724 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
725 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
727 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
728 ecore_timer_add(0, __stt_notify_error, (void*)client);
732 } else if (STT_ERROR_NONE != ret) {
733 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
736 /* success to connect stt-service */
737 client->silence_supported = silence_supported;
738 client->credential_needed = credential_needed;
739 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
742 if (NULL != client->current_engine_id) {
745 silence_supported = false;
746 credential_needed = false;
747 SLOG(LOG_DEBUG, TAG_STTC, "[WARNING] current_engine_id(%s)", client->current_engine_id);
750 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
752 if (STT_ERROR_TIMED_OUT != ret) {
753 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
756 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
759 if (STT_RETRY_COUNT == count) {
760 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
765 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
767 /* success to change engine */
768 client->silence_supported = silence_supported;
769 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
774 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
776 client->before_state = client->current_state;
777 client->current_state = STT_STATE_READY;
779 if (NULL != client->state_changed_cb) {
780 stt_client_use_callback(client);
781 client->state_changed_cb(client->stt, client->before_state,
782 client->current_state, client->state_changed_user_data);
783 stt_client_not_use_callback(client);
784 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
786 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
789 SLOG(LOG_DEBUG, TAG_STTC, "=====");
790 SLOG(LOG_DEBUG, TAG_STTC, " ");
795 int stt_prepare(stt_h stt)
797 stt_client_s* client = NULL;
798 if (0 != __stt_get_feature_enabled()) {
799 return STT_ERROR_NOT_SUPPORTED;
801 if (0 != __stt_check_privilege()) {
802 return STT_ERROR_PERMISSION_DENIED;
804 if (0 != __stt_check_handle(stt, &client)) {
805 return STT_ERROR_INVALID_PARAMETER;
809 if (client->current_state != STT_STATE_CREATED) {
810 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
811 return STT_ERROR_INVALID_STATE;
814 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
816 SLOG(LOG_DEBUG, TAG_STTC, "=====");
817 SLOG(LOG_DEBUG, TAG_STTC, " ");
819 return STT_ERROR_NONE;
822 int stt_unprepare(stt_h stt)
824 stt_client_s* client = NULL;
825 if (0 != __stt_get_feature_enabled()) {
826 return STT_ERROR_NOT_SUPPORTED;
828 if (0 != __stt_check_privilege()) {
829 return STT_ERROR_PERMISSION_DENIED;
831 if (0 != __stt_check_handle(stt, &client)) {
832 return STT_ERROR_INVALID_PARAMETER;
835 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
838 if (client->current_state != STT_STATE_READY) {
839 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
840 return STT_ERROR_INVALID_STATE;
846 ret = stt_dbus_request_finalize(client->uid);
848 if (STT_ERROR_TIMED_OUT != ret) {
849 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
852 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
855 if (STT_RETRY_COUNT == count) {
856 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
863 client->internal_state = STT_INTERNAL_STATE_NONE;
865 client->before_state = client->current_state;
866 client->current_state = STT_STATE_CREATED;
868 if (NULL != client->state_changed_cb) {
869 stt_client_use_callback(client);
870 client->state_changed_cb(client->stt, client->before_state,
871 client->current_state, client->state_changed_user_data);
872 stt_client_not_use_callback(client);
874 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
877 if (g_connect_timer) {
878 ecore_timer_del(g_connect_timer);
879 g_connect_timer = NULL;
882 SLOG(LOG_DEBUG, TAG_STTC, "=====");
883 SLOG(LOG_DEBUG, TAG_STTC, " ");
885 return STT_ERROR_NONE;
888 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
890 stt_h stt = (stt_h)user_data;
892 stt_client_s* client = stt_client_get(stt);
893 if (NULL == client) {
894 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
898 /* call callback function */
899 if (NULL != client->supported_lang_cb) {
900 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
902 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
908 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
910 stt_client_s* client = NULL;
911 if (0 != __stt_get_feature_enabled()) {
912 return STT_ERROR_NOT_SUPPORTED;
914 if (0 != __stt_check_privilege()) {
915 return STT_ERROR_PERMISSION_DENIED;
917 if (0 != __stt_check_handle(stt, &client)) {
918 return STT_ERROR_INVALID_PARAMETER;
921 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
923 if (NULL == callback) {
924 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
925 return STT_ERROR_INVALID_PARAMETER;
929 char* current_engine_id = NULL;
931 if (NULL == client->current_engine_id) {
932 ret = stt_config_mgr_get_engine(¤t_engine_id);
933 ret = __stt_convert_config_error_code(ret);
935 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
939 current_engine_id = strdup(client->current_engine_id);
940 if (NULL == current_engine_id) {
941 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
942 return STT_ERROR_OUT_OF_MEMORY;
946 client->supported_lang_cb = callback;
947 client->supported_lang_user_data = user_data;
949 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
950 ret = __stt_convert_config_error_code(ret);
952 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
955 if (NULL != current_engine_id) {
956 free(current_engine_id);
959 client->supported_lang_cb = NULL;
960 client->supported_lang_user_data = NULL;
962 SLOG(LOG_DEBUG, TAG_STTC, "=====");
963 SLOG(LOG_DEBUG, TAG_STTC, " ");
968 int stt_get_default_language(stt_h stt, char** language)
970 stt_client_s* client = NULL;
971 if (0 != __stt_get_feature_enabled()) {
972 return STT_ERROR_NOT_SUPPORTED;
974 if (0 != __stt_check_privilege()) {
975 return STT_ERROR_PERMISSION_DENIED;
977 if (0 != __stt_check_handle(stt, &client)) {
978 return STT_ERROR_INVALID_PARAMETER;
981 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
983 if (NULL == language) {
984 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
985 return STT_ERROR_INVALID_PARAMETER;
989 ret = stt_config_mgr_get_default_language(language);
990 ret = __stt_convert_config_error_code(ret);
992 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
994 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
997 SLOG(LOG_DEBUG, TAG_STTC, "=====");
998 SLOG(LOG_DEBUG, TAG_STTC, " ");
1003 int stt_get_state(stt_h stt, stt_state_e* state)
1005 stt_client_s* client = NULL;
1006 if (0 != __stt_get_feature_enabled()) {
1007 return STT_ERROR_NOT_SUPPORTED;
1009 if (0 != __stt_check_privilege()) {
1010 return STT_ERROR_PERMISSION_DENIED;
1012 if (0 != __stt_check_handle(stt, &client)) {
1013 return STT_ERROR_INVALID_PARAMETER;
1016 if (NULL == state) {
1017 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1018 return STT_ERROR_INVALID_PARAMETER;
1021 *state = client->current_state;
1024 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1025 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1026 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1027 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1028 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1031 return STT_ERROR_NONE;
1034 int stt_get_error_message(stt_h stt, char** err_msg)
1036 stt_client_s* client = NULL;
1037 if (0 != __stt_get_feature_enabled()) {
1038 return STT_ERROR_NOT_SUPPORTED;
1040 if (0 != __stt_check_privilege()) {
1041 return STT_ERROR_PERMISSION_DENIED;
1043 if (0 != __stt_check_handle(stt, &client)) {
1044 return STT_ERROR_INVALID_PARAMETER;
1047 if (NULL == err_msg) {
1048 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1049 return STT_ERROR_INVALID_PARAMETER;
1052 if (false == g_err_callback_status) {
1053 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1054 return STT_ERROR_OPERATION_FAILED;
1057 if (NULL != client->err_msg) {
1058 *err_msg = strdup(client->err_msg);
1059 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1061 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1064 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1065 SLOG(LOG_DEBUG, TAG_STTC, " ");
1067 return STT_ERROR_NONE;
1070 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1072 stt_client_s* client = NULL;
1073 if (0 != __stt_get_feature_enabled()) {
1074 return STT_ERROR_NOT_SUPPORTED;
1076 if (0 != __stt_check_privilege()) {
1077 return STT_ERROR_PERMISSION_DENIED;
1079 if (0 != __stt_check_handle(stt, &client)) {
1080 return STT_ERROR_INVALID_PARAMETER;
1083 if (NULL == type || NULL == support) {
1084 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1085 return STT_ERROR_INVALID_PARAMETER;
1089 if (client->current_state != STT_STATE_READY) {
1090 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1091 return STT_ERROR_INVALID_STATE;
1097 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1099 if (STT_ERROR_TIMED_OUT != ret) {
1100 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1103 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1106 if (STT_RETRY_COUNT == count) {
1107 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1112 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1117 return STT_ERROR_NONE;
1120 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1122 stt_client_s* client = NULL;
1123 if (0 != __stt_get_feature_enabled()) {
1124 return STT_ERROR_NOT_SUPPORTED;
1126 if (0 != __stt_check_privilege()) {
1127 return STT_ERROR_PERMISSION_DENIED;
1129 if (0 != __stt_check_handle(stt, &client)) {
1130 return STT_ERROR_INVALID_PARAMETER;
1134 if (client->current_state != STT_STATE_READY) {
1135 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1136 return STT_ERROR_INVALID_STATE;
1139 if (true == client->silence_supported) {
1140 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1141 client->silence = type;
1143 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1144 return STT_ERROR_INVALID_PARAMETER;
1147 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1150 return STT_ERROR_NONE;
1153 int stt_set_start_sound(stt_h stt, const char* filename)
1155 stt_client_s* client = NULL;
1156 if (0 != __stt_get_feature_enabled()) {
1157 return STT_ERROR_NOT_SUPPORTED;
1159 if (0 != __stt_check_privilege()) {
1160 return STT_ERROR_PERMISSION_DENIED;
1162 if (0 != __stt_check_handle(stt, &client)) {
1163 return STT_ERROR_INVALID_PARAMETER;
1166 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1168 if (NULL == filename) {
1169 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1170 return STT_ERROR_INVALID_PARAMETER;
1173 if (0 != access(filename, F_OK)) {
1174 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1175 return STT_ERROR_INVALID_PARAMETER;
1179 if (client->current_state != STT_STATE_READY) {
1180 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1181 return STT_ERROR_INVALID_STATE;
1187 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1189 if (STT_ERROR_TIMED_OUT != ret) {
1190 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1193 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1196 if (STT_RETRY_COUNT == count) {
1197 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1202 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1207 return STT_ERROR_NONE;
1210 int stt_unset_start_sound(stt_h stt)
1212 stt_client_s* client = NULL;
1213 if (0 != __stt_get_feature_enabled()) {
1214 return STT_ERROR_NOT_SUPPORTED;
1216 if (0 != __stt_check_privilege()) {
1217 return STT_ERROR_PERMISSION_DENIED;
1219 if (0 != __stt_check_handle(stt, &client)) {
1220 return STT_ERROR_INVALID_PARAMETER;
1223 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1226 if (client->current_state != STT_STATE_READY) {
1227 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1228 return STT_ERROR_INVALID_STATE;
1234 ret = stt_dbus_request_unset_start_sound(client->uid);
1236 if (STT_ERROR_TIMED_OUT != ret) {
1237 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1240 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1243 if (STT_RETRY_COUNT == count) {
1244 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1249 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1254 return STT_ERROR_NONE;
1257 int stt_set_stop_sound(stt_h stt, const char* filename)
1259 stt_client_s* client = NULL;
1260 if (0 != __stt_get_feature_enabled()) {
1261 return STT_ERROR_NOT_SUPPORTED;
1263 if (0 != __stt_check_privilege()) {
1264 return STT_ERROR_PERMISSION_DENIED;
1266 if (0 != __stt_check_handle(stt, &client)) {
1267 return STT_ERROR_INVALID_PARAMETER;
1270 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1272 if (NULL == filename) {
1273 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1274 return STT_ERROR_INVALID_PARAMETER;
1277 if (0 != access(filename, F_OK)) {
1278 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1279 return STT_ERROR_INVALID_PARAMETER;
1283 if (client->current_state != STT_STATE_READY) {
1284 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1285 return STT_ERROR_INVALID_STATE;
1291 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1293 if (STT_ERROR_TIMED_OUT != ret) {
1294 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1297 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1300 if (STT_RETRY_COUNT == count) {
1301 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1306 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1311 return STT_ERROR_NONE;
1314 int stt_unset_stop_sound(stt_h stt)
1316 stt_client_s* client = NULL;
1317 if (0 != __stt_get_feature_enabled()) {
1318 return STT_ERROR_NOT_SUPPORTED;
1320 if (0 != __stt_check_privilege()) {
1321 return STT_ERROR_PERMISSION_DENIED;
1323 if (0 != __stt_check_handle(stt, &client)) {
1324 return STT_ERROR_INVALID_PARAMETER;
1327 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1330 if (client->current_state != STT_STATE_READY) {
1331 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1332 return STT_ERROR_INVALID_STATE;
1338 ret = stt_dbus_request_unset_stop_sound(client->uid);
1340 if (STT_ERROR_TIMED_OUT != ret) {
1341 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1344 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1347 if (STT_RETRY_COUNT == count) {
1348 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1353 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1358 return STT_ERROR_NONE;
1361 int stt_start(stt_h stt, const char* language, const char* type)
1363 stt_client_s* client = NULL;
1364 if (0 != __stt_get_feature_enabled()) {
1365 return STT_ERROR_NOT_SUPPORTED;
1367 if (0 != __stt_check_privilege()) {
1368 return STT_ERROR_PERMISSION_DENIED;
1370 if (0 != __stt_check_handle(stt, &client)) {
1371 return STT_ERROR_INVALID_PARAMETER;
1374 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1377 if (client->current_state != STT_STATE_READY) {
1378 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1379 return STT_ERROR_INVALID_STATE;
1382 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1383 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1384 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1388 char appid[128] = {0, };
1389 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1391 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1392 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1394 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1398 if (NULL == language) {
1399 temp = strdup("default");
1401 temp = strdup(language);
1404 if (true == client->credential_needed && NULL == client->credential) {
1405 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1406 return STT_ERROR_PERMISSION_DENIED;
1409 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1411 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1413 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1414 client->internal_state = STT_INTERNAL_STATE_STARTING;
1417 if (NULL != temp) free(temp);
1419 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1420 SLOG(LOG_DEBUG, TAG_STTC, " ");
1425 int stt_stop(stt_h stt)
1427 stt_client_s* client = NULL;
1428 if (0 != __stt_get_feature_enabled()) {
1429 return STT_ERROR_NOT_SUPPORTED;
1431 if (0 != __stt_check_privilege()) {
1432 return STT_ERROR_PERMISSION_DENIED;
1434 if (0 != __stt_check_handle(stt, &client)) {
1435 return STT_ERROR_INVALID_PARAMETER;
1438 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1441 if (client->current_state != STT_STATE_RECORDING) {
1442 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1443 return STT_ERROR_INVALID_STATE;
1446 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1447 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1448 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1449 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1450 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1451 return STT_ERROR_IN_PROGRESS_TO_READY;
1452 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1453 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1454 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1457 int ret = stt_dbus_request_stop(client->uid);
1460 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1462 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1463 client->internal_state = STT_INTERNAL_STATE_STOPPING;
1466 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1467 SLOG(LOG_DEBUG, TAG_STTC, " ");
1473 int stt_cancel(stt_h stt)
1475 stt_client_s* client = NULL;
1476 if (0 != __stt_get_feature_enabled()) {
1477 return STT_ERROR_NOT_SUPPORTED;
1479 if (0 != __stt_check_privilege()) {
1480 return STT_ERROR_PERMISSION_DENIED;
1482 if (0 != __stt_check_handle(stt, &client)) {
1483 return STT_ERROR_INVALID_PARAMETER;
1486 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1489 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1490 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1491 return STT_ERROR_INVALID_STATE;
1494 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1495 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1496 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1497 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1498 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1499 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1500 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1501 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1502 return STT_ERROR_IN_PROGRESS_TO_READY;
1505 int ret = stt_dbus_request_cancel(client->uid);
1507 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1509 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1510 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1513 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1514 SLOG(LOG_DEBUG, TAG_STTC, " ");
1519 int __stt_cb_set_volume(int uid, float volume)
1521 stt_client_s* client = NULL;
1523 client = stt_client_get_by_uid(uid);
1524 if (NULL == client) {
1525 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1526 return STT_ERROR_INVALID_PARAMETER;
1529 if (STT_STATE_RECORDING != client->current_state) {
1530 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1531 return STT_ERROR_INVALID_STATE;
1534 g_volume_db = volume;
1535 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1540 int stt_get_recording_volume(stt_h stt, float* volume)
1542 stt_client_s* client = NULL;
1543 if (0 != __stt_get_feature_enabled()) {
1544 return STT_ERROR_NOT_SUPPORTED;
1546 if (0 != __stt_check_privilege()) {
1547 return STT_ERROR_PERMISSION_DENIED;
1549 if (0 != __stt_check_handle(stt, &client)) {
1550 return STT_ERROR_INVALID_PARAMETER;
1553 if (NULL == volume) {
1554 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1555 return STT_ERROR_INVALID_PARAMETER;
1558 if (STT_STATE_RECORDING != client->current_state) {
1559 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1560 return STT_ERROR_INVALID_STATE;
1563 *volume = g_volume_db;
1565 return STT_ERROR_NONE;
1568 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1570 stt_client_s* client = (stt_client_s*)user_data;
1573 if (NULL == client) {
1574 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1578 if (NULL != client->result_time_cb) {
1579 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1580 index, event, text, start_time, end_time);
1581 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1582 text, start_time, end_time, client->result_time_user_data);
1584 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1591 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1593 stt_client_s* client = NULL;
1594 if (0 != __stt_get_feature_enabled()) {
1595 return STT_ERROR_NOT_SUPPORTED;
1597 if (0 != __stt_check_privilege()) {
1598 return STT_ERROR_PERMISSION_DENIED;
1600 if (0 != __stt_check_handle(stt, &client)) {
1601 return STT_ERROR_INVALID_PARAMETER;
1604 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1606 if (NULL == callback) {
1607 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1608 return STT_ERROR_INVALID_PARAMETER;
1611 client->result_time_cb = callback;
1612 client->result_time_user_data = user_data;
1615 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1616 ret = __stt_convert_config_error_code(ret);
1618 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1621 client->result_time_cb = NULL;
1622 client->result_time_user_data = NULL;
1624 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1625 SLOG(LOG_DEBUG, TAG_STTC, " ");
1630 static Eina_Bool __stt_notify_error(void *data)
1632 stt_client_s* client = (stt_client_s*)data;
1634 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1637 if (NULL == client) {
1638 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1642 if (NULL == stt_client_get_by_uid(client->uid))
1645 if (NULL != client->error_cb) {
1646 stt_client_use_callback(client);
1647 g_err_callback_status = true;
1648 client->error_cb(client->stt, client->reason, client->error_user_data);
1649 g_err_callback_status = false;
1650 stt_client_not_use_callback(client);
1651 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1653 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1659 int __stt_cb_error(int uid, int reason, char* err_msg)
1661 stt_client_s* client = stt_client_get_by_uid(uid);
1662 if (NULL == client) {
1663 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1667 client->reason = reason;
1668 client->internal_state = STT_INTERNAL_STATE_NONE;
1669 if (NULL != client->err_msg) {
1670 free(client->err_msg);
1671 client->err_msg = NULL;
1673 client->err_msg = strdup(err_msg);
1675 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1677 if (NULL != client->error_cb) {
1678 ecore_timer_add(0, __stt_notify_error, client);
1680 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1683 if (STT_ERROR_SERVICE_RESET == reason) {
1684 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
1686 client->current_state = STT_STATE_CREATED;
1687 if (0 != stt_prepare(client->stt)) {
1688 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
1695 static void __stt_notify_state_changed(void *data)
1697 stt_client_s* client = (stt_client_s*)data;
1700 if (NULL == client) {
1701 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1705 if (NULL == stt_client_get_by_uid(client->uid)) {
1709 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1710 client->internal_state = STT_INTERNAL_STATE_NONE;
1711 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1712 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1713 client->internal_state = STT_INTERNAL_STATE_NONE;
1714 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1715 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1716 client->internal_state = STT_INTERNAL_STATE_NONE;
1717 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1720 if (NULL != client->state_changed_cb) {
1721 stt_client_use_callback(client);
1722 client->state_changed_cb(client->stt, client->before_state,
1723 client->current_state, client->state_changed_user_data);
1724 stt_client_not_use_callback(client);
1725 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1727 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1733 static Eina_Bool __stt_notify_result(void *data)
1735 stt_client_s* client = (stt_client_s*)data;
1738 if (NULL == client) {
1739 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1743 if (NULL == stt_client_get_by_uid(client->uid)) {
1747 if (NULL != client->recognition_result_cb) {
1748 stt_client_use_callback(client);
1749 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1750 client->msg, client->recognition_result_user_data);
1751 stt_client_not_use_callback(client);
1752 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1754 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1757 if (NULL != client->msg) {
1762 if (NULL != client->data_list) {
1764 temp = client->data_list;
1767 for (i = 0; i < client->data_count; i++) {
1768 if (NULL != temp[i]) {
1772 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1775 free(client->data_list);
1776 client->data_list = NULL;
1779 client->data_count = 0;
1781 stt_config_mgr_remove_time_info_file();
1783 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1784 client->before_state = client->current_state;
1785 client->current_state = STT_STATE_READY;
1787 if (NULL != client->state_changed_cb) {
1788 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1790 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1797 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1799 stt_client_s* client = NULL;
1801 client = stt_client_get_by_uid(uid);
1802 if (NULL == client) {
1803 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1804 return STT_ERROR_INVALID_PARAMETER;
1808 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1811 for (i = 0; i < data_count; i++) {
1812 if (NULL != data[i])
1813 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1816 if (NULL != client->recognition_result_cb) {
1817 client->event = event;
1819 client->msg = strdup(msg);
1822 client->data_count = data_count;
1824 if (data_count > 0) {
1826 temp = (char**)calloc(data_count, sizeof(char*));
1828 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1829 return STT_ERROR_OUT_OF_MEMORY;
1832 for (i = 0; i < data_count; i++) {
1833 if (NULL != data[i])
1834 temp[i] = strdup(data[i]);
1836 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1839 client->data_list = temp;
1842 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1845 ecore_timer_add(0, __stt_notify_result, client);
1847 return STT_ERROR_NONE;
1850 int __stt_cb_set_state(int uid, int state)
1852 stt_client_s* client = stt_client_get_by_uid(uid);
1853 if (NULL == client) {
1854 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1858 stt_state_e state_from_daemon = (stt_state_e)state;
1860 if (client->current_state == state_from_daemon) {
1861 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1865 client->before_state = client->current_state;
1866 client->current_state = state_from_daemon;
1868 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1872 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1874 stt_client_s* client = NULL;
1875 if (0 != __stt_get_feature_enabled()) {
1876 return STT_ERROR_NOT_SUPPORTED;
1878 if (0 != __stt_check_privilege()) {
1879 return STT_ERROR_PERMISSION_DENIED;
1881 if (0 != __stt_check_handle(stt, &client)) {
1882 return STT_ERROR_INVALID_PARAMETER;
1885 if (callback == NULL)
1886 return STT_ERROR_INVALID_PARAMETER;
1888 if (STT_STATE_CREATED != client->current_state) {
1889 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1890 return STT_ERROR_INVALID_STATE;
1893 client->recognition_result_cb = callback;
1894 client->recognition_result_user_data = user_data;
1899 int stt_unset_recognition_result_cb(stt_h stt)
1901 stt_client_s* client = NULL;
1902 if (0 != __stt_get_feature_enabled()) {
1903 return STT_ERROR_NOT_SUPPORTED;
1905 if (0 != __stt_check_privilege()) {
1906 return STT_ERROR_PERMISSION_DENIED;
1908 if (0 != __stt_check_handle(stt, &client)) {
1909 return STT_ERROR_INVALID_PARAMETER;
1912 if (STT_STATE_CREATED != client->current_state) {
1913 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1914 return STT_ERROR_INVALID_STATE;
1917 client->recognition_result_cb = NULL;
1918 client->recognition_result_user_data = NULL;
1923 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1925 stt_client_s* client = NULL;
1926 if (0 != __stt_get_feature_enabled()) {
1927 return STT_ERROR_NOT_SUPPORTED;
1929 if (0 != __stt_check_privilege()) {
1930 return STT_ERROR_PERMISSION_DENIED;
1932 if (0 != __stt_check_handle(stt, &client)) {
1933 return STT_ERROR_INVALID_PARAMETER;
1936 if (NULL == callback)
1937 return STT_ERROR_INVALID_PARAMETER;
1939 if (STT_STATE_CREATED != client->current_state) {
1940 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1941 return STT_ERROR_INVALID_STATE;
1944 client->state_changed_cb = callback;
1945 client->state_changed_user_data = user_data;
1950 int stt_unset_state_changed_cb(stt_h stt)
1952 stt_client_s* client = NULL;
1953 if (0 != __stt_get_feature_enabled()) {
1954 return STT_ERROR_NOT_SUPPORTED;
1956 if (0 != __stt_check_privilege()) {
1957 return STT_ERROR_PERMISSION_DENIED;
1959 if (0 != __stt_check_handle(stt, &client)) {
1960 return STT_ERROR_INVALID_PARAMETER;
1963 if (STT_STATE_CREATED != client->current_state) {
1964 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1965 return STT_ERROR_INVALID_STATE;
1968 client->state_changed_cb = NULL;
1969 client->state_changed_user_data = NULL;
1974 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1976 stt_client_s* client = NULL;
1977 if (0 != __stt_get_feature_enabled()) {
1978 return STT_ERROR_NOT_SUPPORTED;
1980 if (0 != __stt_check_privilege()) {
1981 return STT_ERROR_PERMISSION_DENIED;
1983 if (0 != __stt_check_handle(stt, &client)) {
1984 return STT_ERROR_INVALID_PARAMETER;
1987 if (NULL == callback)
1988 return STT_ERROR_INVALID_PARAMETER;
1990 if (STT_STATE_CREATED != client->current_state) {
1991 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1992 return STT_ERROR_INVALID_STATE;
1995 client->error_cb = callback;
1996 client->error_user_data = user_data;
2001 int stt_unset_error_cb(stt_h stt)
2003 stt_client_s* client = NULL;
2004 if (0 != __stt_get_feature_enabled()) {
2005 return STT_ERROR_NOT_SUPPORTED;
2007 if (0 != __stt_check_privilege()) {
2008 return STT_ERROR_PERMISSION_DENIED;
2010 if (0 != __stt_check_handle(stt, &client)) {
2011 return STT_ERROR_INVALID_PARAMETER;
2014 if (STT_STATE_CREATED != client->current_state) {
2015 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2016 return STT_ERROR_INVALID_STATE;
2019 client->error_cb = NULL;
2020 client->error_user_data = NULL;
2025 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2027 stt_client_s* client = NULL;
2028 if (0 != __stt_get_feature_enabled()) {
2029 return STT_ERROR_NOT_SUPPORTED;
2031 if (0 != __stt_check_privilege()) {
2032 return STT_ERROR_PERMISSION_DENIED;
2034 if (0 != __stt_check_handle(stt, &client)) {
2035 return STT_ERROR_INVALID_PARAMETER;
2038 if (NULL == callback)
2039 return STT_ERROR_INVALID_PARAMETER;
2041 if (STT_STATE_CREATED != client->current_state) {
2042 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2043 return STT_ERROR_INVALID_STATE;
2046 client->default_lang_changed_cb = callback;
2047 client->default_lang_changed_user_data = user_data;
2052 int stt_unset_default_language_changed_cb(stt_h stt)
2054 stt_client_s* client = NULL;
2055 if (0 != __stt_get_feature_enabled()) {
2056 return STT_ERROR_NOT_SUPPORTED;
2058 if (0 != __stt_check_privilege()) {
2059 return STT_ERROR_PERMISSION_DENIED;
2061 if (0 != __stt_check_handle(stt, &client)) {
2062 return STT_ERROR_INVALID_PARAMETER;
2065 if (STT_STATE_CREATED != client->current_state) {
2066 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2067 return STT_ERROR_INVALID_STATE;
2070 client->default_lang_changed_cb = NULL;
2071 client->default_lang_changed_user_data = NULL;
2076 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2078 stt_client_s* client = NULL;
2079 if (0 != __stt_get_feature_enabled()) {
2080 return STT_ERROR_NOT_SUPPORTED;
2082 if (0 != __stt_check_privilege()) {
2083 return STT_ERROR_PERMISSION_DENIED;
2085 if (0 != __stt_check_handle(stt, &client)) {
2086 return STT_ERROR_INVALID_PARAMETER;
2089 if (NULL == callback)
2090 return STT_ERROR_INVALID_PARAMETER;
2092 if (STT_STATE_CREATED != client->current_state) {
2093 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2094 return STT_ERROR_INVALID_STATE;
2097 client->engine_changed_cb = callback;
2098 client->engine_changed_user_data = user_data;
2103 int stt_unset_engine_changed_cb(stt_h stt)
2105 stt_client_s* client = NULL;
2106 if (0 != __stt_get_feature_enabled()) {
2107 return STT_ERROR_NOT_SUPPORTED;
2109 if (0 != __stt_check_privilege()) {
2110 return STT_ERROR_PERMISSION_DENIED;
2112 if (0 != __stt_check_handle(stt, &client)) {
2113 return STT_ERROR_INVALID_PARAMETER;
2116 if (STT_STATE_CREATED != client->current_state) {
2117 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2118 return STT_ERROR_INVALID_STATE;
2121 client->engine_changed_cb = NULL;
2122 client->engine_changed_user_data = NULL;