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";
171 case STT_ERROR_SERVICE_RESET: return "STT_ERROR_SERVICE_RESET";
173 return "Invalid error code";
177 static int __stt_convert_config_error_code(stt_config_error_e code)
179 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
180 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
181 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
182 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
183 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
184 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
185 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
186 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
187 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
188 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
193 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
195 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
196 before_language, current_language);
198 if (0 == strcmp(before_language, current_language)) {
202 GList* client_list = NULL;
203 client_list = stt_client_get_client_list();
206 stt_client_s *data = NULL;
208 if (g_list_length(client_list) > 0) {
209 /* Get a first item */
210 iter = g_list_first(client_list);
212 while (NULL != iter) {
214 if (NULL != data->default_lang_changed_cb) {
215 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
216 data->default_lang_changed_cb(data->stt, before_language, current_language,
217 data->default_lang_changed_user_data);
221 iter = g_list_next(iter);
228 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)
230 stt_h stt = (stt_h)user_data;
232 stt_client_s* client = stt_client_get(stt);
233 if (NULL == client) {
234 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
238 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
239 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
240 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
241 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
243 /* call callback function */
244 if (NULL != client->engine_changed_cb) {
245 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
247 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
252 static int __stt_check_handle(stt_h stt, stt_client_s** client)
255 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
256 return STT_ERROR_INVALID_PARAMETER;
259 stt_client_s* temp = NULL;
260 temp = stt_client_get(stt);
264 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
265 return STT_ERROR_INVALID_PARAMETER;
269 return STT_ERROR_NONE;
272 int stt_create(stt_h* stt)
274 if (0 != __stt_get_feature_enabled()) {
275 return STT_ERROR_NOT_SUPPORTED;
277 if (0 != __stt_check_privilege()) {
278 return STT_ERROR_PERMISSION_DENIED;
281 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
284 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
285 return STT_ERROR_INVALID_PARAMETER;
288 if (0 == stt_client_get_size()) {
289 if (0 != stt_dbus_open_connection()) {
290 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
291 return STT_ERROR_OPERATION_FAILED;
295 if (0 != stt_client_new(stt)) {
296 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
297 return STT_ERROR_OUT_OF_MEMORY;
300 stt_client_s* client = stt_client_get(*stt);
301 if (NULL == client) {
302 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
303 stt_client_destroy(*stt);
304 return STT_ERROR_OPERATION_FAILED;
307 int ret = stt_config_mgr_initialize(client->uid);
308 ret = __stt_convert_config_error_code(ret);
310 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
311 stt_client_destroy(*stt);
315 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
316 ret = __stt_convert_config_error_code(ret);
318 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
319 stt_client_destroy(*stt);
323 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
325 SLOG(LOG_DEBUG, TAG_STTC, "=====");
326 SLOG(LOG_DEBUG, TAG_STTC, " ");
328 return STT_ERROR_NONE;
331 int stt_destroy(stt_h stt)
333 stt_client_s* client = NULL;
334 if (0 != __stt_get_feature_enabled()) {
335 return STT_ERROR_NOT_SUPPORTED;
337 if (0 != __stt_check_privilege()) {
338 return STT_ERROR_PERMISSION_DENIED;
340 if (0 != __stt_check_handle(stt, &client)) {
341 return STT_ERROR_INVALID_PARAMETER;
344 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
346 /* check used callback */
347 if (0 != stt_client_get_use_callback(client)) {
348 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
349 return STT_ERROR_OPERATION_FAILED;
352 stt_config_mgr_finalize(client->uid);
357 switch (client->current_state) {
358 case STT_STATE_PROCESSING:
359 case STT_STATE_RECORDING:
360 case STT_STATE_READY:
361 ret = stt_dbus_request_finalize(client->uid);
363 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
365 case STT_STATE_CREATED:
366 if (NULL != g_connect_timer) {
367 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
368 ecore_timer_del(g_connect_timer);
369 g_connect_timer = NULL;
373 stt_client_destroy(stt);
379 if (0 == stt_client_get_size()) {
380 if (0 != stt_dbus_close_connection()) {
381 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
387 SLOG(LOG_DEBUG, TAG_STTC, "=====");
388 SLOG(LOG_DEBUG, TAG_STTC, " ");
390 return STT_ERROR_NONE;
393 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
394 const char* setting, bool support_silence, void* user_data)
396 stt_h stt = (stt_h)user_data;
398 stt_client_s* client = stt_client_get(stt);
399 if (NULL == client) {
400 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
404 /* call callback function */
405 if (NULL != client->supported_engine_cb) {
406 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
408 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
414 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
416 stt_client_s* client = NULL;
417 if (0 != __stt_get_feature_enabled()) {
418 return STT_ERROR_NOT_SUPPORTED;
420 if (0 != __stt_check_privilege()) {
421 return STT_ERROR_PERMISSION_DENIED;
423 if (0 != __stt_check_handle(stt, &client)) {
424 return STT_ERROR_INVALID_PARAMETER;
427 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
429 if (NULL == callback) {
430 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
431 return STT_ERROR_INVALID_PARAMETER;
434 if (client->current_state != STT_STATE_CREATED) {
435 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
436 return STT_ERROR_INVALID_STATE;
439 client->supported_engine_cb = callback;
440 client->supported_engine_user_data = user_data;
443 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
444 ret = __stt_convert_config_error_code(ret);
446 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
449 client->supported_engine_cb = NULL;
450 client->supported_engine_user_data = NULL;
452 SLOG(LOG_DEBUG, TAG_STTC, "=====");
453 SLOG(LOG_DEBUG, TAG_STTC, " ");
458 int stt_get_engine(stt_h stt, char** engine_id)
460 stt_client_s* client = NULL;
461 if (0 != __stt_get_feature_enabled()) {
462 return STT_ERROR_NOT_SUPPORTED;
464 if (0 != __stt_check_privilege()) {
465 return STT_ERROR_PERMISSION_DENIED;
467 if (0 != __stt_check_handle(stt, &client)) {
468 return STT_ERROR_INVALID_PARAMETER;
471 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
473 if (NULL == engine_id) {
474 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
475 return STT_ERROR_INVALID_PARAMETER;
478 if (client->current_state != STT_STATE_CREATED) {
479 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
480 return STT_ERROR_INVALID_STATE;
485 if (NULL != client->current_engine_id) {
486 *engine_id = strdup(client->current_engine_id);
487 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
490 ret = stt_config_mgr_get_engine(engine_id);
491 ret = __stt_convert_config_error_code(ret);
493 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
495 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
499 SLOG(LOG_DEBUG, TAG_STTC, "=====");
500 SLOG(LOG_DEBUG, TAG_STTC, " ");
505 int stt_set_engine(stt_h stt, const char* engine_id)
507 stt_client_s* client = NULL;
508 if (0 != __stt_get_feature_enabled()) {
509 return STT_ERROR_NOT_SUPPORTED;
511 if (0 != __stt_check_privilege()) {
512 return STT_ERROR_PERMISSION_DENIED;
514 if (0 != __stt_check_handle(stt, &client)) {
515 return STT_ERROR_INVALID_PARAMETER;
518 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
520 if (NULL == engine_id) {
521 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
522 return STT_ERROR_INVALID_PARAMETER;
526 if (client->current_state != STT_STATE_CREATED) {
527 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
528 return STT_ERROR_INVALID_STATE;
531 if (NULL != client->current_engine_id) {
532 free(client->current_engine_id);
535 client->current_engine_id = strdup(engine_id);
537 SLOG(LOG_DEBUG, TAG_STTC, "=====");
538 SLOG(LOG_DEBUG, TAG_STTC, " ");
543 int stt_set_credential(stt_h stt, const char* credential)
545 stt_client_s* client = NULL;
546 if (0 != __stt_get_feature_enabled()) {
547 return STT_ERROR_NOT_SUPPORTED;
549 if (0 != __stt_check_privilege()) {
550 return STT_ERROR_PERMISSION_DENIED;
552 if (0 != __stt_check_handle(stt, &client)) {
553 return STT_ERROR_INVALID_PARAMETER;
556 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
558 if (NULL == credential) {
559 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
560 return STT_ERROR_INVALID_PARAMETER;
564 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
565 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
566 return STT_ERROR_INVALID_STATE;
569 client->credential = strdup(credential);
571 SLOG(LOG_DEBUG, TAG_STTC, "=====");
572 SLOG(LOG_DEBUG, TAG_STTC, " ");
574 return STT_ERROR_NONE;
577 int stt_set_private_data(stt_h stt, const char* key, const char* data)
579 stt_client_s* client = NULL;
580 if (0 != __stt_get_feature_enabled()) {
581 return STT_ERROR_NOT_SUPPORTED;
583 if (0 != __stt_check_privilege()) {
584 return STT_ERROR_PERMISSION_DENIED;
586 if (0 != __stt_check_handle(stt, &client)) {
587 return STT_ERROR_INVALID_PARAMETER;
590 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
592 if (NULL == key || NULL == data) {
593 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
594 return STT_ERROR_INVALID_PARAMETER;
598 if (STT_STATE_READY != client->current_state) {
599 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
600 return STT_ERROR_INVALID_STATE;
606 ret = stt_dbus_request_set_private_data(client->uid, key, data);
608 if (STT_ERROR_TIMED_OUT != ret) {
609 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
612 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
615 if (STT_RETRY_COUNT == count) {
616 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
623 SLOG(LOG_DEBUG, TAG_STTC, "=====");
624 SLOG(LOG_DEBUG, TAG_STTC, "");
626 return STT_ERROR_NONE;
629 int stt_get_private_data(stt_h stt, const char* key, char** data)
631 stt_client_s* client = NULL;
632 if (0 != __stt_get_feature_enabled()) {
633 return STT_ERROR_NOT_SUPPORTED;
635 if (0 != __stt_check_privilege()) {
636 return STT_ERROR_PERMISSION_DENIED;
638 if (0 != __stt_check_handle(stt, &client)) {
639 return STT_ERROR_INVALID_PARAMETER;
642 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
644 if (NULL == key || NULL == data) {
645 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
646 return STT_ERROR_INVALID_PARAMETER;
650 if (STT_STATE_READY != client->current_state) {
651 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
652 return STT_ERROR_INVALID_STATE;
658 ret = stt_dbus_request_get_private_data(client->uid, key, data);
660 if (STT_ERROR_TIMED_OUT != ret) {
661 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
664 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
667 if (STT_RETRY_COUNT == count) {
668 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
675 SLOG(LOG_DEBUG, TAG_STTC, "=====");
676 SLOG(LOG_DEBUG, TAG_STTC, "");
678 return STT_ERROR_NONE;
680 static Eina_Bool __stt_connect_daemon(void *data)
682 stt_client_s* client = (stt_client_s*)data;
684 if (NULL == client) {
685 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
686 g_connect_timer = NULL;
692 ret = stt_dbus_request_hello();
695 if (STT_ERROR_INVALID_STATE == ret) {
696 g_connect_timer = NULL;
702 g_connect_timer = NULL;
703 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
705 /* request initialization */
706 bool silence_supported = false;
707 bool credential_needed = false;
709 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
711 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
712 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
714 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
715 ecore_timer_add(0, __stt_notify_error, (void*)client);
719 } else if (STT_ERROR_NONE != ret) {
720 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
723 /* success to connect stt-daemon */
724 client->silence_supported = silence_supported;
725 client->credential_needed = credential_needed;
726 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
729 if (NULL != client->current_engine_id) {
732 silence_supported = false;
733 credential_needed = false;
735 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
737 if (STT_ERROR_TIMED_OUT != ret) {
738 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
741 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
744 if (STT_RETRY_COUNT == count) {
745 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
750 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
752 /* success to change engine */
753 client->silence_supported = silence_supported;
754 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
759 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
761 client->before_state = client->current_state;
762 client->current_state = STT_STATE_READY;
764 if (NULL != client->state_changed_cb) {
765 stt_client_use_callback(client);
766 client->state_changed_cb(client->stt, client->before_state,
767 client->current_state, client->state_changed_user_data);
768 stt_client_not_use_callback(client);
769 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
771 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
774 SLOG(LOG_DEBUG, TAG_STTC, "=====");
775 SLOG(LOG_DEBUG, TAG_STTC, " ");
780 int stt_prepare(stt_h stt)
782 stt_client_s* client = NULL;
783 if (0 != __stt_get_feature_enabled()) {
784 return STT_ERROR_NOT_SUPPORTED;
786 if (0 != __stt_check_privilege()) {
787 return STT_ERROR_PERMISSION_DENIED;
789 if (0 != __stt_check_handle(stt, &client)) {
790 return STT_ERROR_INVALID_PARAMETER;
794 if (client->current_state != STT_STATE_CREATED) {
795 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
796 return STT_ERROR_INVALID_STATE;
799 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
801 SLOG(LOG_DEBUG, TAG_STTC, "=====");
802 SLOG(LOG_DEBUG, TAG_STTC, " ");
804 return STT_ERROR_NONE;
807 int stt_unprepare(stt_h stt)
809 stt_client_s* client = NULL;
810 if (0 != __stt_get_feature_enabled()) {
811 return STT_ERROR_NOT_SUPPORTED;
813 if (0 != __stt_check_privilege()) {
814 return STT_ERROR_PERMISSION_DENIED;
816 if (0 != __stt_check_handle(stt, &client)) {
817 return STT_ERROR_INVALID_PARAMETER;
820 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
823 if (client->current_state != STT_STATE_READY) {
824 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
825 return STT_ERROR_INVALID_STATE;
831 ret = stt_dbus_request_finalize(client->uid);
833 if (STT_ERROR_TIMED_OUT != ret) {
834 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
837 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
840 if (STT_RETRY_COUNT == count) {
841 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
848 client->internal_state = STT_INTERNAL_STATE_NONE;
850 client->before_state = client->current_state;
851 client->current_state = STT_STATE_CREATED;
853 if (NULL != client->state_changed_cb) {
854 stt_client_use_callback(client);
855 client->state_changed_cb(client->stt, client->before_state,
856 client->current_state, client->state_changed_user_data);
857 stt_client_not_use_callback(client);
859 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
862 if (g_connect_timer) {
863 ecore_timer_del(g_connect_timer);
864 g_connect_timer = NULL;
867 SLOG(LOG_DEBUG, TAG_STTC, "=====");
868 SLOG(LOG_DEBUG, TAG_STTC, " ");
870 return STT_ERROR_NONE;
873 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
875 stt_h stt = (stt_h)user_data;
877 stt_client_s* client = stt_client_get(stt);
878 if (NULL == client) {
879 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
883 /* call callback function */
884 if (NULL != client->supported_lang_cb) {
885 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
887 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
893 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
895 stt_client_s* client = NULL;
896 if (0 != __stt_get_feature_enabled()) {
897 return STT_ERROR_NOT_SUPPORTED;
899 if (0 != __stt_check_privilege()) {
900 return STT_ERROR_PERMISSION_DENIED;
902 if (0 != __stt_check_handle(stt, &client)) {
903 return STT_ERROR_INVALID_PARAMETER;
906 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
908 if (NULL == callback) {
909 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
910 return STT_ERROR_INVALID_PARAMETER;
914 char* current_engine_id = NULL;
916 if (NULL == client->current_engine_id) {
917 ret = stt_config_mgr_get_engine(¤t_engine_id);
918 ret = __stt_convert_config_error_code(ret);
920 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
924 current_engine_id = strdup(client->current_engine_id);
925 if (NULL == current_engine_id) {
926 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
927 return STT_ERROR_OUT_OF_MEMORY;
931 client->supported_lang_cb = callback;
932 client->supported_lang_user_data = user_data;
934 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
935 ret = __stt_convert_config_error_code(ret);
937 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
940 if (NULL != current_engine_id) {
941 free(current_engine_id);
944 client->supported_lang_cb = NULL;
945 client->supported_lang_user_data = NULL;
947 SLOG(LOG_DEBUG, TAG_STTC, "=====");
948 SLOG(LOG_DEBUG, TAG_STTC, " ");
953 int stt_get_default_language(stt_h stt, char** language)
955 stt_client_s* client = NULL;
956 if (0 != __stt_get_feature_enabled()) {
957 return STT_ERROR_NOT_SUPPORTED;
959 if (0 != __stt_check_privilege()) {
960 return STT_ERROR_PERMISSION_DENIED;
962 if (0 != __stt_check_handle(stt, &client)) {
963 return STT_ERROR_INVALID_PARAMETER;
966 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
968 if (NULL == language) {
969 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
970 return STT_ERROR_INVALID_PARAMETER;
974 ret = stt_config_mgr_get_default_language(language);
975 ret = __stt_convert_config_error_code(ret);
977 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
979 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
982 SLOG(LOG_DEBUG, TAG_STTC, "=====");
983 SLOG(LOG_DEBUG, TAG_STTC, " ");
988 int stt_get_state(stt_h stt, stt_state_e* state)
990 stt_client_s* client = NULL;
991 if (0 != __stt_get_feature_enabled()) {
992 return STT_ERROR_NOT_SUPPORTED;
994 if (0 != __stt_check_privilege()) {
995 return STT_ERROR_PERMISSION_DENIED;
997 if (0 != __stt_check_handle(stt, &client)) {
998 return STT_ERROR_INVALID_PARAMETER;
1001 if (NULL == state) {
1002 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1003 return STT_ERROR_INVALID_PARAMETER;
1006 *state = client->current_state;
1009 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1010 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1011 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1012 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1013 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1016 return STT_ERROR_NONE;
1019 int stt_get_error_message(stt_h stt, char** err_msg)
1021 stt_client_s* client = NULL;
1022 if (0 != __stt_get_feature_enabled()) {
1023 return STT_ERROR_NOT_SUPPORTED;
1025 if (0 != __stt_check_privilege()) {
1026 return STT_ERROR_PERMISSION_DENIED;
1028 if (0 != __stt_check_handle(stt, &client)) {
1029 return STT_ERROR_INVALID_PARAMETER;
1032 if (NULL == err_msg) {
1033 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1034 return STT_ERROR_INVALID_PARAMETER;
1037 if (false == g_err_callback_status) {
1038 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1039 return STT_ERROR_OPERATION_FAILED;
1042 if (NULL != client->err_msg) {
1043 *err_msg = strdup(client->err_msg);
1044 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1046 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1049 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1050 SLOG(LOG_DEBUG, TAG_STTC, " ");
1052 return STT_ERROR_NONE;
1055 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1057 stt_client_s* client = NULL;
1058 if (0 != __stt_get_feature_enabled()) {
1059 return STT_ERROR_NOT_SUPPORTED;
1061 if (0 != __stt_check_privilege()) {
1062 return STT_ERROR_PERMISSION_DENIED;
1064 if (0 != __stt_check_handle(stt, &client)) {
1065 return STT_ERROR_INVALID_PARAMETER;
1068 if (NULL == type || NULL == support) {
1069 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1070 return STT_ERROR_INVALID_PARAMETER;
1074 if (client->current_state != STT_STATE_READY) {
1075 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1076 return STT_ERROR_INVALID_STATE;
1082 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1084 if (STT_ERROR_TIMED_OUT != ret) {
1085 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1088 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1091 if (STT_RETRY_COUNT == count) {
1092 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1097 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1102 return STT_ERROR_NONE;
1105 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1107 stt_client_s* client = NULL;
1108 if (0 != __stt_get_feature_enabled()) {
1109 return STT_ERROR_NOT_SUPPORTED;
1111 if (0 != __stt_check_privilege()) {
1112 return STT_ERROR_PERMISSION_DENIED;
1114 if (0 != __stt_check_handle(stt, &client)) {
1115 return STT_ERROR_INVALID_PARAMETER;
1119 if (client->current_state != STT_STATE_READY) {
1120 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1121 return STT_ERROR_INVALID_STATE;
1124 if (true == client->silence_supported) {
1125 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1126 client->silence = type;
1128 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1129 return STT_ERROR_INVALID_PARAMETER;
1132 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1135 return STT_ERROR_NONE;
1138 int stt_set_start_sound(stt_h stt, const char* filename)
1140 stt_client_s* client = NULL;
1141 if (0 != __stt_get_feature_enabled()) {
1142 return STT_ERROR_NOT_SUPPORTED;
1144 if (0 != __stt_check_privilege()) {
1145 return STT_ERROR_PERMISSION_DENIED;
1147 if (0 != __stt_check_handle(stt, &client)) {
1148 return STT_ERROR_INVALID_PARAMETER;
1151 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1153 if (NULL == filename) {
1154 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1155 return STT_ERROR_INVALID_PARAMETER;
1158 if (0 != access(filename, F_OK)) {
1159 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1160 return STT_ERROR_INVALID_PARAMETER;
1164 if (client->current_state != STT_STATE_READY) {
1165 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1166 return STT_ERROR_INVALID_STATE;
1172 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1174 if (STT_ERROR_TIMED_OUT != ret) {
1175 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1178 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1181 if (STT_RETRY_COUNT == count) {
1182 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1187 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1192 return STT_ERROR_NONE;
1195 int stt_unset_start_sound(stt_h stt)
1197 stt_client_s* client = NULL;
1198 if (0 != __stt_get_feature_enabled()) {
1199 return STT_ERROR_NOT_SUPPORTED;
1201 if (0 != __stt_check_privilege()) {
1202 return STT_ERROR_PERMISSION_DENIED;
1204 if (0 != __stt_check_handle(stt, &client)) {
1205 return STT_ERROR_INVALID_PARAMETER;
1208 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1211 if (client->current_state != STT_STATE_READY) {
1212 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1213 return STT_ERROR_INVALID_STATE;
1219 ret = stt_dbus_request_unset_start_sound(client->uid);
1221 if (STT_ERROR_TIMED_OUT != ret) {
1222 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1225 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1228 if (STT_RETRY_COUNT == count) {
1229 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1234 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1239 return STT_ERROR_NONE;
1242 int stt_set_stop_sound(stt_h stt, const char* filename)
1244 stt_client_s* client = NULL;
1245 if (0 != __stt_get_feature_enabled()) {
1246 return STT_ERROR_NOT_SUPPORTED;
1248 if (0 != __stt_check_privilege()) {
1249 return STT_ERROR_PERMISSION_DENIED;
1251 if (0 != __stt_check_handle(stt, &client)) {
1252 return STT_ERROR_INVALID_PARAMETER;
1255 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1257 if (NULL == filename) {
1258 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1259 return STT_ERROR_INVALID_PARAMETER;
1262 if (0 != access(filename, F_OK)) {
1263 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1264 return STT_ERROR_INVALID_PARAMETER;
1268 if (client->current_state != STT_STATE_READY) {
1269 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1270 return STT_ERROR_INVALID_STATE;
1276 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1278 if (STT_ERROR_TIMED_OUT != ret) {
1279 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1282 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1285 if (STT_RETRY_COUNT == count) {
1286 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1291 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1296 return STT_ERROR_NONE;
1299 int stt_unset_stop_sound(stt_h stt)
1301 stt_client_s* client = NULL;
1302 if (0 != __stt_get_feature_enabled()) {
1303 return STT_ERROR_NOT_SUPPORTED;
1305 if (0 != __stt_check_privilege()) {
1306 return STT_ERROR_PERMISSION_DENIED;
1308 if (0 != __stt_check_handle(stt, &client)) {
1309 return STT_ERROR_INVALID_PARAMETER;
1312 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1315 if (client->current_state != STT_STATE_READY) {
1316 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1317 return STT_ERROR_INVALID_STATE;
1323 ret = stt_dbus_request_unset_stop_sound(client->uid);
1325 if (STT_ERROR_TIMED_OUT != ret) {
1326 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1329 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1332 if (STT_RETRY_COUNT == count) {
1333 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1338 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1343 return STT_ERROR_NONE;
1346 int stt_start(stt_h stt, const char* language, const char* type)
1348 stt_client_s* client = NULL;
1349 if (0 != __stt_get_feature_enabled()) {
1350 return STT_ERROR_NOT_SUPPORTED;
1352 if (0 != __stt_check_privilege()) {
1353 return STT_ERROR_PERMISSION_DENIED;
1355 if (0 != __stt_check_handle(stt, &client)) {
1356 return STT_ERROR_INVALID_PARAMETER;
1359 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1362 if (client->current_state != STT_STATE_READY) {
1363 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1364 return STT_ERROR_INVALID_STATE;
1367 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1368 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1369 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1373 char appid[128] = {0, };
1374 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1376 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1377 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1379 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1383 if (NULL == language) {
1384 temp = strdup("default");
1386 temp = strdup(language);
1389 if (true == client->credential_needed && NULL == client->credential) {
1390 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1391 return STT_ERROR_PERMISSION_DENIED;
1394 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1396 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1398 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1399 client->internal_state = STT_INTERNAL_STATE_STARTING;
1402 if (NULL != temp) free(temp);
1404 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1405 SLOG(LOG_DEBUG, TAG_STTC, " ");
1410 int stt_stop(stt_h stt)
1412 stt_client_s* client = NULL;
1413 if (0 != __stt_get_feature_enabled()) {
1414 return STT_ERROR_NOT_SUPPORTED;
1416 if (0 != __stt_check_privilege()) {
1417 return STT_ERROR_PERMISSION_DENIED;
1419 if (0 != __stt_check_handle(stt, &client)) {
1420 return STT_ERROR_INVALID_PARAMETER;
1423 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1426 if (client->current_state != STT_STATE_RECORDING) {
1427 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1428 return STT_ERROR_INVALID_STATE;
1431 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1432 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1433 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1434 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1435 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1436 return STT_ERROR_IN_PROGRESS_TO_READY;
1437 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1438 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1439 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1442 int ret = stt_dbus_request_stop(client->uid);
1445 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1447 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1448 client->internal_state = STT_INTERNAL_STATE_STOPPING;
1451 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1452 SLOG(LOG_DEBUG, TAG_STTC, " ");
1458 int stt_cancel(stt_h stt)
1460 stt_client_s* client = NULL;
1461 if (0 != __stt_get_feature_enabled()) {
1462 return STT_ERROR_NOT_SUPPORTED;
1464 if (0 != __stt_check_privilege()) {
1465 return STT_ERROR_PERMISSION_DENIED;
1467 if (0 != __stt_check_handle(stt, &client)) {
1468 return STT_ERROR_INVALID_PARAMETER;
1471 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1474 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1475 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1476 return STT_ERROR_INVALID_STATE;
1479 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1480 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1481 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1482 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1483 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1484 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1485 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1486 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1487 return STT_ERROR_IN_PROGRESS_TO_READY;
1490 int ret = stt_dbus_request_cancel(client->uid);
1492 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1494 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1495 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1498 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1499 SLOG(LOG_DEBUG, TAG_STTC, " ");
1504 int __stt_cb_set_volume(int uid, float volume)
1506 stt_client_s* client = NULL;
1508 client = stt_client_get_by_uid(uid);
1509 if (NULL == client) {
1510 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1511 return STT_ERROR_INVALID_PARAMETER;
1514 if (STT_STATE_RECORDING != client->current_state) {
1515 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1516 return STT_ERROR_INVALID_STATE;
1519 g_volume_db = volume;
1520 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1525 int stt_get_recording_volume(stt_h stt, float* volume)
1527 stt_client_s* client = NULL;
1528 if (0 != __stt_get_feature_enabled()) {
1529 return STT_ERROR_NOT_SUPPORTED;
1531 if (0 != __stt_check_privilege()) {
1532 return STT_ERROR_PERMISSION_DENIED;
1534 if (0 != __stt_check_handle(stt, &client)) {
1535 return STT_ERROR_INVALID_PARAMETER;
1538 if (NULL == volume) {
1539 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1540 return STT_ERROR_INVALID_PARAMETER;
1543 if (STT_STATE_RECORDING != client->current_state) {
1544 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1545 return STT_ERROR_INVALID_STATE;
1548 *volume = g_volume_db;
1550 return STT_ERROR_NONE;
1553 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1555 stt_client_s* client = (stt_client_s*)user_data;
1558 if (NULL == client) {
1559 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1563 if (NULL != client->result_time_cb) {
1564 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1565 index, event, text, start_time, end_time);
1566 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1567 text, start_time, end_time, client->result_time_user_data);
1569 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1576 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1578 stt_client_s* client = NULL;
1579 if (0 != __stt_get_feature_enabled()) {
1580 return STT_ERROR_NOT_SUPPORTED;
1582 if (0 != __stt_check_privilege()) {
1583 return STT_ERROR_PERMISSION_DENIED;
1585 if (0 != __stt_check_handle(stt, &client)) {
1586 return STT_ERROR_INVALID_PARAMETER;
1589 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1591 if (NULL == callback) {
1592 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1593 return STT_ERROR_INVALID_PARAMETER;
1596 client->result_time_cb = callback;
1597 client->result_time_user_data = user_data;
1600 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1601 ret = __stt_convert_config_error_code(ret);
1603 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1606 client->result_time_cb = NULL;
1607 client->result_time_user_data = NULL;
1609 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1610 SLOG(LOG_DEBUG, TAG_STTC, " ");
1615 static Eina_Bool __stt_notify_error(void *data)
1617 stt_client_s* client = (stt_client_s*)data;
1619 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1622 if (NULL == client) {
1623 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1627 if (NULL == stt_client_get_by_uid(client->uid))
1630 if (NULL != client->error_cb) {
1631 stt_client_use_callback(client);
1632 g_err_callback_status = true;
1633 client->error_cb(client->stt, client->reason, client->error_user_data);
1634 g_err_callback_status = false;
1635 stt_client_not_use_callback(client);
1636 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1638 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1644 int __stt_cb_error(int uid, int reason, char* err_msg)
1646 stt_client_s* client = stt_client_get_by_uid(uid);
1647 if (NULL == client) {
1648 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1652 client->reason = reason;
1653 client->internal_state = STT_INTERNAL_STATE_NONE;
1654 if (NULL != client->err_msg) {
1655 free(client->err_msg);
1656 client->err_msg = NULL;
1658 client->err_msg = strdup(err_msg);
1660 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1662 if (NULL != client->error_cb) {
1663 ecore_timer_add(0, __stt_notify_error, client);
1665 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1668 if (STT_ERROR_SERVICE_RESET == reason) {
1669 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
1671 client->current_state = STT_STATE_CREATED;
1672 if (0 != stt_prepare(client->stt)) {
1673 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
1680 static void __stt_notify_state_changed(void *data)
1682 stt_client_s* client = (stt_client_s*)data;
1685 if (NULL == client) {
1686 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1690 if (NULL == stt_client_get_by_uid(client->uid)) {
1694 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1695 client->internal_state = STT_INTERNAL_STATE_NONE;
1696 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1697 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1698 client->internal_state = STT_INTERNAL_STATE_NONE;
1699 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1700 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1701 client->internal_state = STT_INTERNAL_STATE_NONE;
1702 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1705 if (NULL != client->state_changed_cb) {
1706 stt_client_use_callback(client);
1707 client->state_changed_cb(client->stt, client->before_state,
1708 client->current_state, client->state_changed_user_data);
1709 stt_client_not_use_callback(client);
1710 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1712 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1718 static Eina_Bool __stt_notify_result(void *data)
1720 stt_client_s* client = (stt_client_s*)data;
1723 if (NULL == client) {
1724 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1728 if (NULL == stt_client_get_by_uid(client->uid)) {
1732 if (NULL != client->recognition_result_cb) {
1733 stt_client_use_callback(client);
1734 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1735 client->msg, client->recognition_result_user_data);
1736 stt_client_not_use_callback(client);
1737 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1739 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1742 if (NULL != client->msg) {
1747 if (NULL != client->data_list) {
1749 temp = client->data_list;
1752 for (i = 0; i < client->data_count; i++) {
1753 if (NULL != temp[i]) {
1757 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1760 free(client->data_list);
1761 client->data_list = NULL;
1764 client->data_count = 0;
1766 stt_config_mgr_remove_time_info_file();
1768 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1769 client->before_state = client->current_state;
1770 client->current_state = STT_STATE_READY;
1772 if (NULL != client->state_changed_cb) {
1773 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1775 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1782 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1784 stt_client_s* client = NULL;
1786 client = stt_client_get_by_uid(uid);
1787 if (NULL == client) {
1788 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1789 return STT_ERROR_INVALID_PARAMETER;
1793 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1796 for (i = 0; i < data_count; i++) {
1797 if (NULL != data[i])
1798 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1801 if (NULL != client->recognition_result_cb) {
1802 client->event = event;
1804 client->msg = strdup(msg);
1807 client->data_count = data_count;
1809 if (data_count > 0) {
1811 temp = (char**)calloc(data_count, sizeof(char*));
1813 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1814 return STT_ERROR_OUT_OF_MEMORY;
1817 for (i = 0; i < data_count; i++) {
1818 if (NULL != data[i])
1819 temp[i] = strdup(data[i]);
1821 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1824 client->data_list = temp;
1827 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1830 ecore_timer_add(0, __stt_notify_result, client);
1832 return STT_ERROR_NONE;
1835 int __stt_cb_set_state(int uid, int state)
1837 stt_client_s* client = stt_client_get_by_uid(uid);
1838 if (NULL == client) {
1839 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1843 stt_state_e state_from_daemon = (stt_state_e)state;
1845 if (client->current_state == state_from_daemon) {
1846 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1850 client->before_state = client->current_state;
1851 client->current_state = state_from_daemon;
1853 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1857 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1859 stt_client_s* client = NULL;
1860 if (0 != __stt_get_feature_enabled()) {
1861 return STT_ERROR_NOT_SUPPORTED;
1863 if (0 != __stt_check_privilege()) {
1864 return STT_ERROR_PERMISSION_DENIED;
1866 if (0 != __stt_check_handle(stt, &client)) {
1867 return STT_ERROR_INVALID_PARAMETER;
1870 if (callback == NULL)
1871 return STT_ERROR_INVALID_PARAMETER;
1873 if (STT_STATE_CREATED != client->current_state) {
1874 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1875 return STT_ERROR_INVALID_STATE;
1878 client->recognition_result_cb = callback;
1879 client->recognition_result_user_data = user_data;
1884 int stt_unset_recognition_result_cb(stt_h stt)
1886 stt_client_s* client = NULL;
1887 if (0 != __stt_get_feature_enabled()) {
1888 return STT_ERROR_NOT_SUPPORTED;
1890 if (0 != __stt_check_privilege()) {
1891 return STT_ERROR_PERMISSION_DENIED;
1893 if (0 != __stt_check_handle(stt, &client)) {
1894 return STT_ERROR_INVALID_PARAMETER;
1897 if (STT_STATE_CREATED != client->current_state) {
1898 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1899 return STT_ERROR_INVALID_STATE;
1902 client->recognition_result_cb = NULL;
1903 client->recognition_result_user_data = NULL;
1908 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1910 stt_client_s* client = NULL;
1911 if (0 != __stt_get_feature_enabled()) {
1912 return STT_ERROR_NOT_SUPPORTED;
1914 if (0 != __stt_check_privilege()) {
1915 return STT_ERROR_PERMISSION_DENIED;
1917 if (0 != __stt_check_handle(stt, &client)) {
1918 return STT_ERROR_INVALID_PARAMETER;
1921 if (NULL == callback)
1922 return STT_ERROR_INVALID_PARAMETER;
1924 if (STT_STATE_CREATED != client->current_state) {
1925 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1926 return STT_ERROR_INVALID_STATE;
1929 client->state_changed_cb = callback;
1930 client->state_changed_user_data = user_data;
1935 int stt_unset_state_changed_cb(stt_h stt)
1937 stt_client_s* client = NULL;
1938 if (0 != __stt_get_feature_enabled()) {
1939 return STT_ERROR_NOT_SUPPORTED;
1941 if (0 != __stt_check_privilege()) {
1942 return STT_ERROR_PERMISSION_DENIED;
1944 if (0 != __stt_check_handle(stt, &client)) {
1945 return STT_ERROR_INVALID_PARAMETER;
1948 if (STT_STATE_CREATED != client->current_state) {
1949 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1950 return STT_ERROR_INVALID_STATE;
1953 client->state_changed_cb = NULL;
1954 client->state_changed_user_data = NULL;
1959 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1961 stt_client_s* client = NULL;
1962 if (0 != __stt_get_feature_enabled()) {
1963 return STT_ERROR_NOT_SUPPORTED;
1965 if (0 != __stt_check_privilege()) {
1966 return STT_ERROR_PERMISSION_DENIED;
1968 if (0 != __stt_check_handle(stt, &client)) {
1969 return STT_ERROR_INVALID_PARAMETER;
1972 if (NULL == callback)
1973 return STT_ERROR_INVALID_PARAMETER;
1975 if (STT_STATE_CREATED != client->current_state) {
1976 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1977 return STT_ERROR_INVALID_STATE;
1980 client->error_cb = callback;
1981 client->error_user_data = user_data;
1986 int stt_unset_error_cb(stt_h stt)
1988 stt_client_s* client = NULL;
1989 if (0 != __stt_get_feature_enabled()) {
1990 return STT_ERROR_NOT_SUPPORTED;
1992 if (0 != __stt_check_privilege()) {
1993 return STT_ERROR_PERMISSION_DENIED;
1995 if (0 != __stt_check_handle(stt, &client)) {
1996 return STT_ERROR_INVALID_PARAMETER;
1999 if (STT_STATE_CREATED != client->current_state) {
2000 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2001 return STT_ERROR_INVALID_STATE;
2004 client->error_cb = NULL;
2005 client->error_user_data = NULL;
2010 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2012 stt_client_s* client = NULL;
2013 if (0 != __stt_get_feature_enabled()) {
2014 return STT_ERROR_NOT_SUPPORTED;
2016 if (0 != __stt_check_privilege()) {
2017 return STT_ERROR_PERMISSION_DENIED;
2019 if (0 != __stt_check_handle(stt, &client)) {
2020 return STT_ERROR_INVALID_PARAMETER;
2023 if (NULL == callback)
2024 return STT_ERROR_INVALID_PARAMETER;
2026 if (STT_STATE_CREATED != client->current_state) {
2027 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2028 return STT_ERROR_INVALID_STATE;
2031 client->default_lang_changed_cb = callback;
2032 client->default_lang_changed_user_data = user_data;
2037 int stt_unset_default_language_changed_cb(stt_h stt)
2039 stt_client_s* client = NULL;
2040 if (0 != __stt_get_feature_enabled()) {
2041 return STT_ERROR_NOT_SUPPORTED;
2043 if (0 != __stt_check_privilege()) {
2044 return STT_ERROR_PERMISSION_DENIED;
2046 if (0 != __stt_check_handle(stt, &client)) {
2047 return STT_ERROR_INVALID_PARAMETER;
2050 if (STT_STATE_CREATED != client->current_state) {
2051 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2052 return STT_ERROR_INVALID_STATE;
2055 client->default_lang_changed_cb = NULL;
2056 client->default_lang_changed_user_data = NULL;
2061 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2063 stt_client_s* client = NULL;
2064 if (0 != __stt_get_feature_enabled()) {
2065 return STT_ERROR_NOT_SUPPORTED;
2067 if (0 != __stt_check_privilege()) {
2068 return STT_ERROR_PERMISSION_DENIED;
2070 if (0 != __stt_check_handle(stt, &client)) {
2071 return STT_ERROR_INVALID_PARAMETER;
2074 if (NULL == callback)
2075 return STT_ERROR_INVALID_PARAMETER;
2077 if (STT_STATE_CREATED != client->current_state) {
2078 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2079 return STT_ERROR_INVALID_STATE;
2082 client->engine_changed_cb = callback;
2083 client->engine_changed_user_data = user_data;
2088 int stt_unset_engine_changed_cb(stt_h stt)
2090 stt_client_s* client = NULL;
2091 if (0 != __stt_get_feature_enabled()) {
2092 return STT_ERROR_NOT_SUPPORTED;
2094 if (0 != __stt_check_privilege()) {
2095 return STT_ERROR_PERMISSION_DENIED;
2097 if (0 != __stt_check_handle(stt, &client)) {
2098 return STT_ERROR_INVALID_PARAMETER;
2101 if (STT_STATE_CREATED != client->current_state) {
2102 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2103 return STT_ERROR_INVALID_STATE;
2106 client->engine_changed_cb = NULL;
2107 client->engine_changed_user_data = NULL;