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");
116 if (ret != CYNARA_API_ACCESS_ALLOWED)
121 static void __check_privilege_deinitialize()
124 cynara_finish(p_cynara);
128 static int __stt_check_privilege()
132 if (0 == g_privilege_allowed) {
133 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
134 return STT_ERROR_PERMISSION_DENIED;
135 } else if (-1 == g_privilege_allowed) {
136 if (false == __check_privilege_initialize()){
137 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
138 return STT_ERROR_PERMISSION_DENIED;
140 snprintf(uid, 16, "%d", getuid());
141 if (false == __check_privilege(uid, STT_PRIVILEGE)) {
142 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
143 g_privilege_allowed = 0;
144 __check_privilege_deinitialize();
145 return STT_ERROR_PERMISSION_DENIED;
147 __check_privilege_deinitialize();
150 g_privilege_allowed = 1;
151 return STT_ERROR_NONE;
154 static const char* __stt_get_error_code(stt_error_e err)
157 case STT_ERROR_NONE: return "STT_ERROR_NONE";
158 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
159 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
160 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
161 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
162 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
163 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
164 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
165 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
166 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
167 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
168 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
169 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
170 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
172 return "Invalid error code";
176 static int __stt_convert_config_error_code(stt_config_error_e code)
178 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
179 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
180 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
181 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
182 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
183 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
184 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
185 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
186 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
187 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
192 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
194 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
195 before_language, current_language);
197 if (0 == strcmp(before_language, current_language)) {
201 GList* client_list = NULL;
202 client_list = stt_client_get_client_list();
205 stt_client_s *data = NULL;
207 if (g_list_length(client_list) > 0) {
208 /* Get a first item */
209 iter = g_list_first(client_list);
211 while (NULL != iter) {
213 if (NULL != data->default_lang_changed_cb) {
214 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
215 data->default_lang_changed_cb(data->stt, before_language, current_language,
216 data->default_lang_changed_user_data);
220 iter = g_list_next(iter);
227 void __stt_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, bool support_silence, bool need_credential, void* user_data)
229 stt_h stt = (stt_h)user_data;
231 stt_client_s* client = stt_client_get(stt);
232 if (NULL == client) {
233 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
237 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
238 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
239 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
240 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
242 /* call callback function */
243 if (NULL != client->engine_changed_cb) {
244 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
246 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
251 static int __stt_check_handle(stt_h stt, stt_client_s** client)
254 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
255 return STT_ERROR_INVALID_PARAMETER;
258 stt_client_s* temp = NULL;
259 temp = stt_client_get(stt);
263 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
264 return STT_ERROR_INVALID_PARAMETER;
268 return STT_ERROR_NONE;
271 int stt_create(stt_h* stt)
273 if (0 != __stt_get_feature_enabled()) {
274 return STT_ERROR_NOT_SUPPORTED;
276 if (0 != __stt_check_privilege()) {
277 return STT_ERROR_PERMISSION_DENIED;
280 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
283 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
284 return STT_ERROR_INVALID_PARAMETER;
287 if (0 == stt_client_get_size()) {
288 if (0 != stt_dbus_open_connection()) {
289 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
290 return STT_ERROR_OPERATION_FAILED;
294 if (0 != stt_client_new(stt)) {
295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
296 return STT_ERROR_OUT_OF_MEMORY;
299 stt_client_s* client = stt_client_get(*stt);
300 if (NULL == client) {
301 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
302 stt_client_destroy(*stt);
303 return STT_ERROR_OPERATION_FAILED;
306 int ret = stt_config_mgr_initialize(client->uid);
307 ret = __stt_convert_config_error_code(ret);
309 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
310 stt_client_destroy(*stt);
314 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
315 ret = __stt_convert_config_error_code(ret);
317 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
318 stt_client_destroy(*stt);
322 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
324 SLOG(LOG_DEBUG, TAG_STTC, "=====");
325 SLOG(LOG_DEBUG, TAG_STTC, " ");
327 return STT_ERROR_NONE;
330 int stt_destroy(stt_h stt)
332 stt_client_s* client = NULL;
333 if (0 != __stt_get_feature_enabled()) {
334 return STT_ERROR_NOT_SUPPORTED;
336 if (0 != __stt_check_privilege()) {
337 return STT_ERROR_PERMISSION_DENIED;
339 if (0 != __stt_check_handle(stt, &client)) {
340 return STT_ERROR_INVALID_PARAMETER;
343 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
345 /* check used callback */
346 if (0 != stt_client_get_use_callback(client)) {
347 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
348 return STT_ERROR_OPERATION_FAILED;
351 stt_config_mgr_finalize(client->uid);
356 switch (client->current_state) {
357 case STT_STATE_PROCESSING:
358 case STT_STATE_RECORDING:
359 case STT_STATE_READY:
360 ret = stt_dbus_request_finalize(client->uid);
362 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
364 case STT_STATE_CREATED:
365 if (NULL != g_connect_timer) {
366 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
367 ecore_timer_del(g_connect_timer);
368 g_connect_timer = NULL;
372 stt_client_destroy(stt);
378 if (0 == stt_client_get_size()) {
379 if (0 != stt_dbus_close_connection()) {
380 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
386 SLOG(LOG_DEBUG, TAG_STTC, "=====");
387 SLOG(LOG_DEBUG, TAG_STTC, " ");
389 return STT_ERROR_NONE;
392 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
393 const char* setting, bool support_silence, void* user_data)
395 stt_h stt = (stt_h)user_data;
397 stt_client_s* client = stt_client_get(stt);
398 if (NULL == client) {
399 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
403 /* call callback function */
404 if (NULL != client->supported_engine_cb) {
405 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
407 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
413 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
415 stt_client_s* client = NULL;
416 if (0 != __stt_get_feature_enabled()) {
417 return STT_ERROR_NOT_SUPPORTED;
419 if (0 != __stt_check_privilege()) {
420 return STT_ERROR_PERMISSION_DENIED;
422 if (0 != __stt_check_handle(stt, &client)) {
423 return STT_ERROR_INVALID_PARAMETER;
426 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
428 if (NULL == callback) {
429 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
430 return STT_ERROR_INVALID_PARAMETER;
433 if (client->current_state != STT_STATE_CREATED) {
434 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
435 return STT_ERROR_INVALID_STATE;
438 client->supported_engine_cb = callback;
439 client->supported_engine_user_data = user_data;
442 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
443 ret = __stt_convert_config_error_code(ret);
445 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
448 client->supported_engine_cb = NULL;
449 client->supported_engine_user_data = NULL;
451 SLOG(LOG_DEBUG, TAG_STTC, "=====");
452 SLOG(LOG_DEBUG, TAG_STTC, " ");
457 int stt_get_engine(stt_h stt, char** engine_id)
459 stt_client_s* client = NULL;
460 if (0 != __stt_get_feature_enabled()) {
461 return STT_ERROR_NOT_SUPPORTED;
463 if (0 != __stt_check_privilege()) {
464 return STT_ERROR_PERMISSION_DENIED;
466 if (0 != __stt_check_handle(stt, &client)) {
467 return STT_ERROR_INVALID_PARAMETER;
470 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
472 if (NULL == engine_id) {
473 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
474 return STT_ERROR_INVALID_PARAMETER;
477 if (client->current_state != STT_STATE_CREATED) {
478 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
479 return STT_ERROR_INVALID_STATE;
484 if (NULL != client->current_engine_id) {
485 *engine_id = strdup(client->current_engine_id);
486 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
489 ret = stt_config_mgr_get_engine(engine_id);
490 ret = __stt_convert_config_error_code(ret);
492 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
494 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
498 SLOG(LOG_DEBUG, TAG_STTC, "=====");
499 SLOG(LOG_DEBUG, TAG_STTC, " ");
504 int stt_set_engine(stt_h stt, const char* engine_id)
506 stt_client_s* client = NULL;
507 if (0 != __stt_get_feature_enabled()) {
508 return STT_ERROR_NOT_SUPPORTED;
510 if (0 != __stt_check_privilege()) {
511 return STT_ERROR_PERMISSION_DENIED;
513 if (0 != __stt_check_handle(stt, &client)) {
514 return STT_ERROR_INVALID_PARAMETER;
517 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
519 if (NULL == engine_id) {
520 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
521 return STT_ERROR_INVALID_PARAMETER;
525 if (client->current_state != STT_STATE_CREATED) {
526 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
527 return STT_ERROR_INVALID_STATE;
530 if (NULL != client->current_engine_id) {
531 free(client->current_engine_id);
534 client->current_engine_id = strdup(engine_id);
536 SLOG(LOG_DEBUG, TAG_STTC, "=====");
537 SLOG(LOG_DEBUG, TAG_STTC, " ");
542 int stt_set_credential(stt_h stt, const char* credential)
544 stt_client_s* client = NULL;
545 if (0 != __stt_get_feature_enabled()) {
546 return STT_ERROR_NOT_SUPPORTED;
548 if (0 != __stt_check_privilege()) {
549 return STT_ERROR_PERMISSION_DENIED;
551 if (0 != __stt_check_handle(stt, &client)) {
552 return STT_ERROR_INVALID_PARAMETER;
555 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
557 if (NULL == credential) {
558 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
559 return STT_ERROR_INVALID_PARAMETER;
563 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
564 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
565 return STT_ERROR_INVALID_STATE;
568 client->credential = strdup(credential);
570 SLOG(LOG_DEBUG, TAG_STTC, "=====");
571 SLOG(LOG_DEBUG, TAG_STTC, " ");
573 return STT_ERROR_NONE;
576 int stt_set_private_data(stt_h stt, const char* key, const char* data)
578 stt_client_s* client = NULL;
579 if (0 != __stt_get_feature_enabled()) {
580 return STT_ERROR_NOT_SUPPORTED;
582 if (0 != __stt_check_privilege()) {
583 return STT_ERROR_PERMISSION_DENIED;
585 if (0 != __stt_check_handle(stt, &client)) {
586 return STT_ERROR_INVALID_PARAMETER;
589 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
591 if (NULL == key || NULL == data) {
592 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
593 return STT_ERROR_INVALID_PARAMETER;
597 if (STT_STATE_READY != client->current_state) {
598 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
599 return STT_ERROR_INVALID_STATE;
605 ret = stt_dbus_request_set_private_data(client->uid, key, data);
607 if (STT_ERROR_TIMED_OUT != ret) {
608 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
611 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
614 if (STT_RETRY_COUNT == count) {
615 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
622 SLOG(LOG_DEBUG, TAG_STTC, "=====");
623 SLOG(LOG_DEBUG, TAG_STTC, "");
625 return STT_ERROR_NONE;
628 int stt_get_private_data(stt_h stt, const char* key, char** data)
630 stt_client_s* client = NULL;
631 if (0 != __stt_get_feature_enabled()) {
632 return STT_ERROR_NOT_SUPPORTED;
634 if (0 != __stt_check_privilege()) {
635 return STT_ERROR_PERMISSION_DENIED;
637 if (0 != __stt_check_handle(stt, &client)) {
638 return STT_ERROR_INVALID_PARAMETER;
641 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
643 if (NULL == key || NULL == data) {
644 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
645 return STT_ERROR_INVALID_PARAMETER;
649 if (STT_STATE_READY != client->current_state) {
650 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
651 return STT_ERROR_INVALID_STATE;
657 ret = stt_dbus_request_get_private_data(client->uid, key, data);
659 if (STT_ERROR_TIMED_OUT != ret) {
660 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
663 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
666 if (STT_RETRY_COUNT == count) {
667 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
674 SLOG(LOG_DEBUG, TAG_STTC, "=====");
675 SLOG(LOG_DEBUG, TAG_STTC, "");
677 return STT_ERROR_NONE;
679 static Eina_Bool __stt_connect_daemon(void *data)
681 stt_client_s* client = (stt_client_s*)data;
683 if (NULL == client) {
684 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
685 g_connect_timer = NULL;
691 ret = stt_dbus_request_hello();
694 if (STT_ERROR_INVALID_STATE == ret) {
695 g_connect_timer = NULL;
701 g_connect_timer = NULL;
702 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
704 /* request initialization */
705 bool silence_supported = false;
706 bool credential_needed = false;
708 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
710 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
711 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
713 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
714 ecore_timer_add(0, __stt_notify_error, (void*)client);
718 } else if (STT_ERROR_NONE != ret) {
719 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
722 /* success to connect stt-daemon */
723 client->silence_supported = silence_supported;
724 client->credential_needed = credential_needed;
725 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
728 if (NULL != client->current_engine_id) {
731 silence_supported = false;
732 credential_needed = false;
734 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
736 if (STT_ERROR_TIMED_OUT != ret) {
737 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
740 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
743 if (STT_RETRY_COUNT == count) {
744 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
749 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
751 /* success to change engine */
752 client->silence_supported = silence_supported;
753 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
758 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
760 client->before_state = client->current_state;
761 client->current_state = STT_STATE_READY;
763 if (NULL != client->state_changed_cb) {
764 stt_client_use_callback(client);
765 client->state_changed_cb(client->stt, client->before_state,
766 client->current_state, client->state_changed_user_data);
767 stt_client_not_use_callback(client);
768 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
770 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
773 SLOG(LOG_DEBUG, TAG_STTC, "=====");
774 SLOG(LOG_DEBUG, TAG_STTC, " ");
779 int stt_prepare(stt_h stt)
781 stt_client_s* client = NULL;
782 if (0 != __stt_get_feature_enabled()) {
783 return STT_ERROR_NOT_SUPPORTED;
785 if (0 != __stt_check_privilege()) {
786 return STT_ERROR_PERMISSION_DENIED;
788 if (0 != __stt_check_handle(stt, &client)) {
789 return STT_ERROR_INVALID_PARAMETER;
793 if (client->current_state != STT_STATE_CREATED) {
794 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
795 return STT_ERROR_INVALID_STATE;
798 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
800 SLOG(LOG_DEBUG, TAG_STTC, "=====");
801 SLOG(LOG_DEBUG, TAG_STTC, " ");
803 return STT_ERROR_NONE;
806 int stt_unprepare(stt_h stt)
808 stt_client_s* client = NULL;
809 if (0 != __stt_get_feature_enabled()) {
810 return STT_ERROR_NOT_SUPPORTED;
812 if (0 != __stt_check_privilege()) {
813 return STT_ERROR_PERMISSION_DENIED;
815 if (0 != __stt_check_handle(stt, &client)) {
816 return STT_ERROR_INVALID_PARAMETER;
819 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
822 if (client->current_state != STT_STATE_READY) {
823 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
824 return STT_ERROR_INVALID_STATE;
830 ret = stt_dbus_request_finalize(client->uid);
832 if (STT_ERROR_TIMED_OUT != ret) {
833 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
836 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
839 if (STT_RETRY_COUNT == count) {
840 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
847 client->internal_state = STT_INTERNAL_STATE_NONE;
849 client->before_state = client->current_state;
850 client->current_state = STT_STATE_CREATED;
852 if (NULL != client->state_changed_cb) {
853 stt_client_use_callback(client);
854 client->state_changed_cb(client->stt, client->before_state,
855 client->current_state, client->state_changed_user_data);
856 stt_client_not_use_callback(client);
858 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
861 if (g_connect_timer) {
862 ecore_timer_del(g_connect_timer);
863 g_connect_timer = NULL;
866 SLOG(LOG_DEBUG, TAG_STTC, "=====");
867 SLOG(LOG_DEBUG, TAG_STTC, " ");
869 return STT_ERROR_NONE;
872 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
874 stt_h stt = (stt_h)user_data;
876 stt_client_s* client = stt_client_get(stt);
877 if (NULL == client) {
878 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
882 /* call callback function */
883 if (NULL != client->supported_lang_cb) {
884 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
886 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
892 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
894 stt_client_s* client = NULL;
895 if (0 != __stt_get_feature_enabled()) {
896 return STT_ERROR_NOT_SUPPORTED;
898 if (0 != __stt_check_privilege()) {
899 return STT_ERROR_PERMISSION_DENIED;
901 if (0 != __stt_check_handle(stt, &client)) {
902 return STT_ERROR_INVALID_PARAMETER;
905 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
907 if (NULL == callback) {
908 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
909 return STT_ERROR_INVALID_PARAMETER;
913 char* current_engine_id = NULL;
915 if (NULL == client->current_engine_id) {
916 ret = stt_config_mgr_get_engine(¤t_engine_id);
917 ret = __stt_convert_config_error_code(ret);
919 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
923 current_engine_id = strdup(client->current_engine_id);
924 if (NULL == current_engine_id) {
925 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
926 return STT_ERROR_OUT_OF_MEMORY;
930 client->supported_lang_cb = callback;
931 client->supported_lang_user_data = user_data;
933 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
934 ret = __stt_convert_config_error_code(ret);
936 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
939 if (NULL != current_engine_id) {
940 free(current_engine_id);
943 client->supported_lang_cb = NULL;
944 client->supported_lang_user_data = NULL;
946 SLOG(LOG_DEBUG, TAG_STTC, "=====");
947 SLOG(LOG_DEBUG, TAG_STTC, " ");
952 int stt_get_default_language(stt_h stt, char** language)
954 stt_client_s* client = NULL;
955 if (0 != __stt_get_feature_enabled()) {
956 return STT_ERROR_NOT_SUPPORTED;
958 if (0 != __stt_check_privilege()) {
959 return STT_ERROR_PERMISSION_DENIED;
961 if (0 != __stt_check_handle(stt, &client)) {
962 return STT_ERROR_INVALID_PARAMETER;
965 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
967 if (NULL == language) {
968 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
969 return STT_ERROR_INVALID_PARAMETER;
973 ret = stt_config_mgr_get_default_language(language);
974 ret = __stt_convert_config_error_code(ret);
976 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
978 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
981 SLOG(LOG_DEBUG, TAG_STTC, "=====");
982 SLOG(LOG_DEBUG, TAG_STTC, " ");
987 int stt_get_state(stt_h stt, stt_state_e* state)
989 stt_client_s* client = NULL;
990 if (0 != __stt_get_feature_enabled()) {
991 return STT_ERROR_NOT_SUPPORTED;
993 if (0 != __stt_check_privilege()) {
994 return STT_ERROR_PERMISSION_DENIED;
996 if (0 != __stt_check_handle(stt, &client)) {
997 return STT_ERROR_INVALID_PARAMETER;
1000 if (NULL == state) {
1001 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1002 return STT_ERROR_INVALID_PARAMETER;
1005 *state = client->current_state;
1008 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1009 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1010 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1011 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1012 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1015 return STT_ERROR_NONE;
1018 int stt_get_error_message(stt_h stt, char** err_msg)
1020 stt_client_s* client = NULL;
1021 if (0 != __stt_get_feature_enabled()) {
1022 return STT_ERROR_NOT_SUPPORTED;
1024 if (0 != __stt_check_privilege()) {
1025 return STT_ERROR_PERMISSION_DENIED;
1027 if (0 != __stt_check_handle(stt, &client)) {
1028 return STT_ERROR_INVALID_PARAMETER;
1031 if (NULL == err_msg) {
1032 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1033 return STT_ERROR_INVALID_PARAMETER;
1036 if (false == g_err_callback_status) {
1037 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1038 return STT_ERROR_OPERATION_FAILED;
1041 if (NULL != client->err_msg) {
1042 *err_msg = strdup(client->err_msg);
1043 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1045 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1048 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1049 SLOG(LOG_DEBUG, TAG_STTC, " ");
1051 return STT_ERROR_NONE;
1054 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1056 stt_client_s* client = NULL;
1057 if (0 != __stt_get_feature_enabled()) {
1058 return STT_ERROR_NOT_SUPPORTED;
1060 if (0 != __stt_check_privilege()) {
1061 return STT_ERROR_PERMISSION_DENIED;
1063 if (0 != __stt_check_handle(stt, &client)) {
1064 return STT_ERROR_INVALID_PARAMETER;
1067 if (NULL == type || NULL == support) {
1068 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1069 return STT_ERROR_INVALID_PARAMETER;
1073 if (client->current_state != STT_STATE_READY) {
1074 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1075 return STT_ERROR_INVALID_STATE;
1081 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1083 if (STT_ERROR_TIMED_OUT != ret) {
1084 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1087 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1090 if (STT_RETRY_COUNT == count) {
1091 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1096 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1101 return STT_ERROR_NONE;
1104 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1106 stt_client_s* client = NULL;
1107 if (0 != __stt_get_feature_enabled()) {
1108 return STT_ERROR_NOT_SUPPORTED;
1110 if (0 != __stt_check_privilege()) {
1111 return STT_ERROR_PERMISSION_DENIED;
1113 if (0 != __stt_check_handle(stt, &client)) {
1114 return STT_ERROR_INVALID_PARAMETER;
1118 if (client->current_state != STT_STATE_READY) {
1119 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1120 return STT_ERROR_INVALID_STATE;
1123 if (true == client->silence_supported) {
1124 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1125 client->silence = type;
1127 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1128 return STT_ERROR_INVALID_PARAMETER;
1131 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1134 return STT_ERROR_NONE;
1137 int stt_set_start_sound(stt_h stt, const char* filename)
1139 stt_client_s* client = NULL;
1140 if (0 != __stt_get_feature_enabled()) {
1141 return STT_ERROR_NOT_SUPPORTED;
1143 if (0 != __stt_check_privilege()) {
1144 return STT_ERROR_PERMISSION_DENIED;
1146 if (0 != __stt_check_handle(stt, &client)) {
1147 return STT_ERROR_INVALID_PARAMETER;
1150 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1152 if (NULL == filename) {
1153 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1154 return STT_ERROR_INVALID_PARAMETER;
1157 if (0 != access(filename, F_OK)) {
1158 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1159 return STT_ERROR_INVALID_PARAMETER;
1163 if (client->current_state != STT_STATE_READY) {
1164 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1165 return STT_ERROR_INVALID_STATE;
1171 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1173 if (STT_ERROR_TIMED_OUT != ret) {
1174 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1177 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1180 if (STT_RETRY_COUNT == count) {
1181 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1186 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1191 return STT_ERROR_NONE;
1194 int stt_unset_start_sound(stt_h stt)
1196 stt_client_s* client = NULL;
1197 if (0 != __stt_get_feature_enabled()) {
1198 return STT_ERROR_NOT_SUPPORTED;
1200 if (0 != __stt_check_privilege()) {
1201 return STT_ERROR_PERMISSION_DENIED;
1203 if (0 != __stt_check_handle(stt, &client)) {
1204 return STT_ERROR_INVALID_PARAMETER;
1207 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1210 if (client->current_state != STT_STATE_READY) {
1211 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1212 return STT_ERROR_INVALID_STATE;
1218 ret = stt_dbus_request_unset_start_sound(client->uid);
1220 if (STT_ERROR_TIMED_OUT != ret) {
1221 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1224 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1227 if (STT_RETRY_COUNT == count) {
1228 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1233 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1238 return STT_ERROR_NONE;
1241 int stt_set_stop_sound(stt_h stt, const char* filename)
1243 stt_client_s* client = NULL;
1244 if (0 != __stt_get_feature_enabled()) {
1245 return STT_ERROR_NOT_SUPPORTED;
1247 if (0 != __stt_check_privilege()) {
1248 return STT_ERROR_PERMISSION_DENIED;
1250 if (0 != __stt_check_handle(stt, &client)) {
1251 return STT_ERROR_INVALID_PARAMETER;
1254 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1256 if (NULL == filename) {
1257 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1258 return STT_ERROR_INVALID_PARAMETER;
1261 if (0 != access(filename, F_OK)) {
1262 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1263 return STT_ERROR_INVALID_PARAMETER;
1267 if (client->current_state != STT_STATE_READY) {
1268 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1269 return STT_ERROR_INVALID_STATE;
1275 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1277 if (STT_ERROR_TIMED_OUT != ret) {
1278 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1281 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1284 if (STT_RETRY_COUNT == count) {
1285 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1290 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1295 return STT_ERROR_NONE;
1298 int stt_unset_stop_sound(stt_h stt)
1300 stt_client_s* client = NULL;
1301 if (0 != __stt_get_feature_enabled()) {
1302 return STT_ERROR_NOT_SUPPORTED;
1304 if (0 != __stt_check_privilege()) {
1305 return STT_ERROR_PERMISSION_DENIED;
1307 if (0 != __stt_check_handle(stt, &client)) {
1308 return STT_ERROR_INVALID_PARAMETER;
1311 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1314 if (client->current_state != STT_STATE_READY) {
1315 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1316 return STT_ERROR_INVALID_STATE;
1322 ret = stt_dbus_request_unset_stop_sound(client->uid);
1324 if (STT_ERROR_TIMED_OUT != ret) {
1325 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1328 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1331 if (STT_RETRY_COUNT == count) {
1332 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1337 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1342 return STT_ERROR_NONE;
1345 int stt_start(stt_h stt, const char* language, const char* type)
1347 stt_client_s* client = NULL;
1348 if (0 != __stt_get_feature_enabled()) {
1349 return STT_ERROR_NOT_SUPPORTED;
1351 if (0 != __stt_check_privilege()) {
1352 return STT_ERROR_PERMISSION_DENIED;
1354 if (0 != __stt_check_handle(stt, &client)) {
1355 return STT_ERROR_INVALID_PARAMETER;
1358 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1361 if (client->current_state != STT_STATE_READY) {
1362 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1363 return STT_ERROR_INVALID_STATE;
1366 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1367 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1368 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1372 char appid[128] = {0, };
1373 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1375 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1376 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1378 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1382 if (NULL == language) {
1383 temp = strdup("default");
1385 temp = strdup(language);
1388 if (true == client->credential_needed && NULL == client->credential) {
1389 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1390 return STT_ERROR_PERMISSION_DENIED;
1393 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1395 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1397 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1398 client->internal_state = STT_INTERNAL_STATE_STARTING;
1401 if (NULL != temp) free(temp);
1403 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1404 SLOG(LOG_DEBUG, TAG_STTC, " ");
1409 int stt_stop(stt_h stt)
1411 stt_client_s* client = NULL;
1412 if (0 != __stt_get_feature_enabled()) {
1413 return STT_ERROR_NOT_SUPPORTED;
1415 if (0 != __stt_check_privilege()) {
1416 return STT_ERROR_PERMISSION_DENIED;
1418 if (0 != __stt_check_handle(stt, &client)) {
1419 return STT_ERROR_INVALID_PARAMETER;
1422 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1425 if (client->current_state != STT_STATE_RECORDING) {
1426 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1427 return STT_ERROR_INVALID_STATE;
1430 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1431 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1432 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1433 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1434 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1435 return STT_ERROR_IN_PROGRESS_TO_READY;
1436 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1437 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1438 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1441 int ret = stt_dbus_request_stop(client->uid);
1444 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1446 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1447 client->internal_state = STT_INTERNAL_STATE_STOPPING;
1450 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1451 SLOG(LOG_DEBUG, TAG_STTC, " ");
1457 int stt_cancel(stt_h stt)
1459 stt_client_s* client = NULL;
1460 if (0 != __stt_get_feature_enabled()) {
1461 return STT_ERROR_NOT_SUPPORTED;
1463 if (0 != __stt_check_privilege()) {
1464 return STT_ERROR_PERMISSION_DENIED;
1466 if (0 != __stt_check_handle(stt, &client)) {
1467 return STT_ERROR_INVALID_PARAMETER;
1470 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1473 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1474 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1475 return STT_ERROR_INVALID_STATE;
1478 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1479 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1480 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1481 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1482 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1483 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1484 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1485 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1486 return STT_ERROR_IN_PROGRESS_TO_READY;
1489 int ret = stt_dbus_request_cancel(client->uid);
1491 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1493 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1494 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1497 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1498 SLOG(LOG_DEBUG, TAG_STTC, " ");
1503 int __stt_cb_set_volume(int uid, float volume)
1505 stt_client_s* client = NULL;
1507 client = stt_client_get_by_uid(uid);
1508 if (NULL == client) {
1509 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1510 return STT_ERROR_INVALID_PARAMETER;
1513 if (STT_STATE_RECORDING != client->current_state) {
1514 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1515 return STT_ERROR_INVALID_STATE;
1518 g_volume_db = volume;
1519 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1524 int stt_get_recording_volume(stt_h stt, float* volume)
1526 stt_client_s* client = NULL;
1527 if (0 != __stt_get_feature_enabled()) {
1528 return STT_ERROR_NOT_SUPPORTED;
1530 if (0 != __stt_check_privilege()) {
1531 return STT_ERROR_PERMISSION_DENIED;
1533 if (0 != __stt_check_handle(stt, &client)) {
1534 return STT_ERROR_INVALID_PARAMETER;
1537 if (NULL == volume) {
1538 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1539 return STT_ERROR_INVALID_PARAMETER;
1542 if (STT_STATE_RECORDING != client->current_state) {
1543 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1544 return STT_ERROR_INVALID_STATE;
1547 *volume = g_volume_db;
1549 return STT_ERROR_NONE;
1552 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1554 stt_client_s* client = (stt_client_s*)user_data;
1557 if (NULL == client) {
1558 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1562 if (NULL != client->result_time_cb) {
1563 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1564 index, event, text, start_time, end_time);
1565 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1566 text, start_time, end_time, client->result_time_user_data);
1568 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1575 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1577 stt_client_s* client = NULL;
1578 if (0 != __stt_get_feature_enabled()) {
1579 return STT_ERROR_NOT_SUPPORTED;
1581 if (0 != __stt_check_privilege()) {
1582 return STT_ERROR_PERMISSION_DENIED;
1584 if (0 != __stt_check_handle(stt, &client)) {
1585 return STT_ERROR_INVALID_PARAMETER;
1588 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1590 if (NULL == callback) {
1591 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1592 return STT_ERROR_INVALID_PARAMETER;
1595 client->result_time_cb = callback;
1596 client->result_time_user_data = user_data;
1599 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1600 ret = __stt_convert_config_error_code(ret);
1602 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1605 client->result_time_cb = NULL;
1606 client->result_time_user_data = NULL;
1608 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1609 SLOG(LOG_DEBUG, TAG_STTC, " ");
1614 static Eina_Bool __stt_notify_error(void *data)
1616 stt_client_s* client = (stt_client_s*)data;
1618 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1621 if (NULL == client) {
1622 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1626 if (NULL == stt_client_get_by_uid(client->uid))
1629 if (NULL != client->error_cb) {
1630 stt_client_use_callback(client);
1631 g_err_callback_status = true;
1632 client->error_cb(client->stt, client->reason, client->error_user_data);
1633 g_err_callback_status = false;
1634 stt_client_not_use_callback(client);
1635 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1637 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1643 int __stt_cb_error(int uid, int reason, char* err_msg)
1645 stt_client_s* client = stt_client_get_by_uid(uid);
1646 if (NULL == client) {
1647 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1651 client->reason = reason;
1652 client->internal_state = STT_INTERNAL_STATE_NONE;
1653 if (NULL != client->err_msg) {
1654 free(client->err_msg);
1655 client->err_msg = NULL;
1657 client->err_msg = strdup(err_msg);
1659 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1661 if (NULL != client->error_cb) {
1662 ecore_timer_add(0, __stt_notify_error, client);
1664 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1670 static void __stt_notify_state_changed(void *data)
1672 stt_client_s* client = (stt_client_s*)data;
1675 if (NULL == client) {
1676 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1680 if (NULL == stt_client_get_by_uid(client->uid)) {
1684 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1685 client->internal_state = STT_INTERNAL_STATE_NONE;
1686 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1687 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1688 client->internal_state = STT_INTERNAL_STATE_NONE;
1689 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1690 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1691 client->internal_state = STT_INTERNAL_STATE_NONE;
1692 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1695 if (NULL != client->state_changed_cb) {
1696 stt_client_use_callback(client);
1697 client->state_changed_cb(client->stt, client->before_state,
1698 client->current_state, client->state_changed_user_data);
1699 stt_client_not_use_callback(client);
1700 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1702 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1708 static Eina_Bool __stt_notify_result(void *data)
1710 stt_client_s* client = (stt_client_s*)data;
1713 if (NULL == client) {
1714 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1718 if (NULL == stt_client_get_by_uid(client->uid)) {
1722 if (NULL != client->recognition_result_cb) {
1723 stt_client_use_callback(client);
1724 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1725 client->msg, client->recognition_result_user_data);
1726 stt_client_not_use_callback(client);
1727 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1729 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1732 if (NULL != client->msg) {
1737 if (NULL != client->data_list) {
1739 temp = client->data_list;
1742 for (i = 0; i < client->data_count; i++) {
1743 if (NULL != temp[i]) {
1747 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1750 free(client->data_list);
1751 client->data_list = NULL;
1754 client->data_count = 0;
1756 stt_config_mgr_remove_time_info_file();
1758 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1759 client->before_state = client->current_state;
1760 client->current_state = STT_STATE_READY;
1762 if (NULL != client->state_changed_cb) {
1763 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1765 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1772 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1774 stt_client_s* client = NULL;
1776 client = stt_client_get_by_uid(uid);
1777 if (NULL == client) {
1778 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1779 return STT_ERROR_INVALID_PARAMETER;
1783 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1786 for (i = 0; i < data_count; i++) {
1787 if (NULL != data[i])
1788 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1791 if (NULL != client->recognition_result_cb) {
1792 client->event = event;
1794 client->msg = strdup(msg);
1797 client->data_count = data_count;
1799 if (data_count > 0) {
1801 temp = (char**)calloc(data_count, sizeof(char*));
1803 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1804 return STT_ERROR_OUT_OF_MEMORY;
1807 for (i = 0; i < data_count; i++) {
1808 if (NULL != data[i])
1809 temp[i] = strdup(data[i]);
1811 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1814 client->data_list = temp;
1817 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1820 ecore_timer_add(0, __stt_notify_result, client);
1822 return STT_ERROR_NONE;
1825 int __stt_cb_set_state(int uid, int state)
1827 stt_client_s* client = stt_client_get_by_uid(uid);
1828 if (NULL == client) {
1829 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1833 stt_state_e state_from_daemon = (stt_state_e)state;
1835 if (client->current_state == state_from_daemon) {
1836 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1840 client->before_state = client->current_state;
1841 client->current_state = state_from_daemon;
1843 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1847 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1849 stt_client_s* client = NULL;
1850 if (0 != __stt_get_feature_enabled()) {
1851 return STT_ERROR_NOT_SUPPORTED;
1853 if (0 != __stt_check_privilege()) {
1854 return STT_ERROR_PERMISSION_DENIED;
1856 if (0 != __stt_check_handle(stt, &client)) {
1857 return STT_ERROR_INVALID_PARAMETER;
1860 if (callback == NULL)
1861 return STT_ERROR_INVALID_PARAMETER;
1863 if (STT_STATE_CREATED != client->current_state) {
1864 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1865 return STT_ERROR_INVALID_STATE;
1868 client->recognition_result_cb = callback;
1869 client->recognition_result_user_data = user_data;
1874 int stt_unset_recognition_result_cb(stt_h stt)
1876 stt_client_s* client = NULL;
1877 if (0 != __stt_get_feature_enabled()) {
1878 return STT_ERROR_NOT_SUPPORTED;
1880 if (0 != __stt_check_privilege()) {
1881 return STT_ERROR_PERMISSION_DENIED;
1883 if (0 != __stt_check_handle(stt, &client)) {
1884 return STT_ERROR_INVALID_PARAMETER;
1887 if (STT_STATE_CREATED != client->current_state) {
1888 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1889 return STT_ERROR_INVALID_STATE;
1892 client->recognition_result_cb = NULL;
1893 client->recognition_result_user_data = NULL;
1898 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1900 stt_client_s* client = NULL;
1901 if (0 != __stt_get_feature_enabled()) {
1902 return STT_ERROR_NOT_SUPPORTED;
1904 if (0 != __stt_check_privilege()) {
1905 return STT_ERROR_PERMISSION_DENIED;
1907 if (0 != __stt_check_handle(stt, &client)) {
1908 return STT_ERROR_INVALID_PARAMETER;
1911 if (NULL == callback)
1912 return STT_ERROR_INVALID_PARAMETER;
1914 if (STT_STATE_CREATED != client->current_state) {
1915 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1916 return STT_ERROR_INVALID_STATE;
1919 client->state_changed_cb = callback;
1920 client->state_changed_user_data = user_data;
1925 int stt_unset_state_changed_cb(stt_h stt)
1927 stt_client_s* client = NULL;
1928 if (0 != __stt_get_feature_enabled()) {
1929 return STT_ERROR_NOT_SUPPORTED;
1931 if (0 != __stt_check_privilege()) {
1932 return STT_ERROR_PERMISSION_DENIED;
1934 if (0 != __stt_check_handle(stt, &client)) {
1935 return STT_ERROR_INVALID_PARAMETER;
1938 if (STT_STATE_CREATED != client->current_state) {
1939 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1940 return STT_ERROR_INVALID_STATE;
1943 client->state_changed_cb = NULL;
1944 client->state_changed_user_data = NULL;
1949 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1951 stt_client_s* client = NULL;
1952 if (0 != __stt_get_feature_enabled()) {
1953 return STT_ERROR_NOT_SUPPORTED;
1955 if (0 != __stt_check_privilege()) {
1956 return STT_ERROR_PERMISSION_DENIED;
1958 if (0 != __stt_check_handle(stt, &client)) {
1959 return STT_ERROR_INVALID_PARAMETER;
1962 if (NULL == callback)
1963 return STT_ERROR_INVALID_PARAMETER;
1965 if (STT_STATE_CREATED != client->current_state) {
1966 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1967 return STT_ERROR_INVALID_STATE;
1970 client->error_cb = callback;
1971 client->error_user_data = user_data;
1976 int stt_unset_error_cb(stt_h stt)
1978 stt_client_s* client = NULL;
1979 if (0 != __stt_get_feature_enabled()) {
1980 return STT_ERROR_NOT_SUPPORTED;
1982 if (0 != __stt_check_privilege()) {
1983 return STT_ERROR_PERMISSION_DENIED;
1985 if (0 != __stt_check_handle(stt, &client)) {
1986 return STT_ERROR_INVALID_PARAMETER;
1989 if (STT_STATE_CREATED != client->current_state) {
1990 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1991 return STT_ERROR_INVALID_STATE;
1994 client->error_cb = NULL;
1995 client->error_user_data = NULL;
2000 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2002 stt_client_s* client = NULL;
2003 if (0 != __stt_get_feature_enabled()) {
2004 return STT_ERROR_NOT_SUPPORTED;
2006 if (0 != __stt_check_privilege()) {
2007 return STT_ERROR_PERMISSION_DENIED;
2009 if (0 != __stt_check_handle(stt, &client)) {
2010 return STT_ERROR_INVALID_PARAMETER;
2013 if (NULL == callback)
2014 return STT_ERROR_INVALID_PARAMETER;
2016 if (STT_STATE_CREATED != client->current_state) {
2017 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2018 return STT_ERROR_INVALID_STATE;
2021 client->default_lang_changed_cb = callback;
2022 client->default_lang_changed_user_data = user_data;
2027 int stt_unset_default_language_changed_cb(stt_h stt)
2029 stt_client_s* client = NULL;
2030 if (0 != __stt_get_feature_enabled()) {
2031 return STT_ERROR_NOT_SUPPORTED;
2033 if (0 != __stt_check_privilege()) {
2034 return STT_ERROR_PERMISSION_DENIED;
2036 if (0 != __stt_check_handle(stt, &client)) {
2037 return STT_ERROR_INVALID_PARAMETER;
2040 if (STT_STATE_CREATED != client->current_state) {
2041 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2042 return STT_ERROR_INVALID_STATE;
2045 client->default_lang_changed_cb = NULL;
2046 client->default_lang_changed_user_data = NULL;
2051 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2053 stt_client_s* client = NULL;
2054 if (0 != __stt_get_feature_enabled()) {
2055 return STT_ERROR_NOT_SUPPORTED;
2057 if (0 != __stt_check_privilege()) {
2058 return STT_ERROR_PERMISSION_DENIED;
2060 if (0 != __stt_check_handle(stt, &client)) {
2061 return STT_ERROR_INVALID_PARAMETER;
2064 if (NULL == callback)
2065 return STT_ERROR_INVALID_PARAMETER;
2067 if (STT_STATE_CREATED != client->current_state) {
2068 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2069 return STT_ERROR_INVALID_STATE;
2072 client->engine_changed_cb = callback;
2073 client->engine_changed_user_data = user_data;
2078 int stt_unset_engine_changed_cb(stt_h stt)
2080 stt_client_s* client = NULL;
2081 if (0 != __stt_get_feature_enabled()) {
2082 return STT_ERROR_NOT_SUPPORTED;
2084 if (0 != __stt_check_privilege()) {
2085 return STT_ERROR_PERMISSION_DENIED;
2087 if (0 != __stt_check_handle(stt, &client)) {
2088 return STT_ERROR_INVALID_PARAMETER;
2091 if (STT_STATE_CREATED != client->current_state) {
2092 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2093 return STT_ERROR_INVALID_STATE;
2096 client->engine_changed_cb = NULL;
2097 client->engine_changed_user_data = NULL;