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 label_path[1024] = "/proc/self/attr/current";
96 char smack_label[1024] = {'\0',};
102 fp = fopen(label_path, "r");
104 if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0)
105 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread");
110 pid_t pid = getpid();
111 char *session = cynara_session_from_pid(pid);
112 int ret = cynara_check(p_cynara, smack_label, session, uid, privilege);
113 SLOG(LOG_DEBUG, TAG_STTC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied");
119 if (ret != CYNARA_API_ACCESS_ALLOWED)
124 static void __check_privilege_deinitialize()
127 cynara_finish(p_cynara);
131 static int __stt_check_privilege()
135 if (0 == g_privilege_allowed) {
136 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
137 return STT_ERROR_PERMISSION_DENIED;
138 } else if (-1 == g_privilege_allowed) {
139 if (false == __check_privilege_initialize()) {
140 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed");
141 return STT_ERROR_PERMISSION_DENIED;
143 snprintf(uid, 16, "%d", getuid());
144 if (false == __check_privilege(uid, STT_PRIVILEGE)) {
145 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
146 g_privilege_allowed = 0;
147 __check_privilege_deinitialize();
148 return STT_ERROR_PERMISSION_DENIED;
150 __check_privilege_deinitialize();
153 g_privilege_allowed = 1;
154 return STT_ERROR_NONE;
157 static const char* __stt_get_error_code(stt_error_e err)
160 case STT_ERROR_NONE: return "STT_ERROR_NONE";
161 case STT_ERROR_OUT_OF_MEMORY: return "STT_ERROR_OUT_OF_MEMORY";
162 case STT_ERROR_IO_ERROR: return "STT_ERROR_IO_ERROR";
163 case STT_ERROR_INVALID_PARAMETER: return "STT_ERROR_INVALID_PARAMETER";
164 case STT_ERROR_TIMED_OUT: return "STT_ERROR_TIMED_OUT";
165 case STT_ERROR_RECORDER_BUSY: return "STT_ERROR_RECORDER_BUSY";
166 case STT_ERROR_OUT_OF_NETWORK: return "STT_ERROR_OUT_OF_NETWORK";
167 case STT_ERROR_PERMISSION_DENIED: return "STT_ERROR_PERMISSION_DENIED";
168 case STT_ERROR_NOT_SUPPORTED: return "STT_ERROR_NOT_SUPPORTED";
169 case STT_ERROR_INVALID_STATE: return "STT_ERROR_INVALID_STATE";
170 case STT_ERROR_INVALID_LANGUAGE: return "STT_ERROR_INVALID_LANGUAGE";
171 case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND";
172 case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED";
173 case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE";
174 case STT_ERROR_SERVICE_RESET: return "STT_ERROR_SERVICE_RESET";
176 return "Invalid error code";
180 static int __stt_convert_config_error_code(stt_config_error_e code)
182 if (code == STT_CONFIG_ERROR_NONE) return STT_ERROR_NONE;
183 if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY) return STT_ERROR_OUT_OF_MEMORY;
184 if (code == STT_CONFIG_ERROR_IO_ERROR) return STT_ERROR_IO_ERROR;
185 if (code == STT_CONFIG_ERROR_INVALID_PARAMETER) return STT_ERROR_INVALID_PARAMETER;
186 if (code == STT_CONFIG_ERROR_PERMISSION_DENIED) return STT_ERROR_PERMISSION_DENIED;
187 if (code == STT_CONFIG_ERROR_NOT_SUPPORTED) return STT_ERROR_NOT_SUPPORTED;
188 if (code == STT_CONFIG_ERROR_INVALID_STATE) return STT_ERROR_INVALID_STATE;
189 if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE) return STT_ERROR_INVALID_LANGUAGE;
190 if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND) return STT_ERROR_ENGINE_NOT_FOUND;
191 if (code == STT_CONFIG_ERROR_OPERATION_FAILED) return STT_ERROR_OPERATION_FAILED;
196 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
198 SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
199 before_language, current_language);
201 if (0 == strcmp(before_language, current_language)) {
205 GList* client_list = NULL;
206 client_list = stt_client_get_client_list();
209 stt_client_s *data = NULL;
211 if (g_list_length(client_list) > 0) {
212 /* Get a first item */
213 iter = g_list_first(client_list);
215 while (NULL != iter) {
217 if (NULL != data->default_lang_changed_cb) {
218 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
219 data->default_lang_changed_cb(data->stt, before_language, current_language,
220 data->default_lang_changed_user_data);
224 iter = g_list_next(iter);
231 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)
233 stt_h stt = (stt_h)user_data;
235 stt_client_s* client = stt_client_get(stt);
236 if (NULL == client) {
237 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
241 if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
242 if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
243 if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
244 SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
246 /* call callback function */
247 if (NULL != client->engine_changed_cb) {
248 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
250 SLOG(LOG_WARN, TAG_STTC, "No registered callback function for engine change");
255 static int __stt_check_handle(stt_h stt, stt_client_s** client)
258 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
259 return STT_ERROR_INVALID_PARAMETER;
262 stt_client_s* temp = NULL;
263 temp = stt_client_get(stt);
267 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
268 return STT_ERROR_INVALID_PARAMETER;
272 return STT_ERROR_NONE;
275 int stt_create(stt_h* stt)
277 if (0 != __stt_get_feature_enabled()) {
278 return STT_ERROR_NOT_SUPPORTED;
280 if (0 != __stt_check_privilege()) {
281 return STT_ERROR_PERMISSION_DENIED;
284 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
287 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
288 return STT_ERROR_INVALID_PARAMETER;
291 if (0 == stt_client_get_size()) {
292 if (0 != stt_dbus_open_connection()) {
293 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
294 return STT_ERROR_OPERATION_FAILED;
298 if (0 != stt_client_new(stt)) {
299 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
300 return STT_ERROR_OUT_OF_MEMORY;
303 stt_client_s* client = stt_client_get(*stt);
304 if (NULL == client) {
305 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
306 stt_client_destroy(*stt);
307 return STT_ERROR_OPERATION_FAILED;
310 int ret = stt_config_mgr_initialize(client->uid);
311 ret = __stt_convert_config_error_code(ret);
313 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
314 stt_client_destroy(*stt);
318 ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
319 ret = __stt_convert_config_error_code(ret);
321 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
322 stt_client_destroy(*stt);
326 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
328 SLOG(LOG_DEBUG, TAG_STTC, "=====");
329 SLOG(LOG_DEBUG, TAG_STTC, " ");
331 return STT_ERROR_NONE;
334 int stt_destroy(stt_h stt)
336 stt_client_s* client = NULL;
337 if (0 != __stt_get_feature_enabled()) {
338 return STT_ERROR_NOT_SUPPORTED;
340 if (0 != __stt_check_privilege()) {
341 return STT_ERROR_PERMISSION_DENIED;
343 if (0 != __stt_check_handle(stt, &client)) {
344 return STT_ERROR_INVALID_PARAMETER;
347 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
349 /* check used callback */
350 if (0 != stt_client_get_use_callback(client)) {
351 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
352 return STT_ERROR_OPERATION_FAILED;
355 stt_config_mgr_finalize(client->uid);
360 switch (client->current_state) {
361 case STT_STATE_PROCESSING:
362 case STT_STATE_RECORDING:
363 case STT_STATE_READY:
364 ret = stt_dbus_request_finalize(client->uid);
366 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
368 case STT_STATE_CREATED:
369 if (NULL != g_connect_timer) {
370 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
371 ecore_timer_del(g_connect_timer);
372 g_connect_timer = NULL;
376 stt_client_destroy(stt);
382 if (0 == stt_client_get_size()) {
383 if (0 != stt_dbus_close_connection()) {
384 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
390 SLOG(LOG_DEBUG, TAG_STTC, "=====");
391 SLOG(LOG_DEBUG, TAG_STTC, " ");
393 return STT_ERROR_NONE;
396 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
397 const char* setting, bool support_silence, void* user_data)
399 stt_h stt = (stt_h)user_data;
401 stt_client_s* client = stt_client_get(stt);
402 if (NULL == client) {
403 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
407 /* call callback function */
408 if (NULL != client->supported_engine_cb) {
409 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
411 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
417 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
419 stt_client_s* client = NULL;
420 if (0 != __stt_get_feature_enabled()) {
421 return STT_ERROR_NOT_SUPPORTED;
423 if (0 != __stt_check_privilege()) {
424 return STT_ERROR_PERMISSION_DENIED;
426 if (0 != __stt_check_handle(stt, &client)) {
427 return STT_ERROR_INVALID_PARAMETER;
430 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
432 if (NULL == callback) {
433 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
434 return STT_ERROR_INVALID_PARAMETER;
437 if (client->current_state != STT_STATE_CREATED) {
438 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
439 return STT_ERROR_INVALID_STATE;
442 client->supported_engine_cb = callback;
443 client->supported_engine_user_data = user_data;
446 ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
447 ret = __stt_convert_config_error_code(ret);
449 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
452 client->supported_engine_cb = NULL;
453 client->supported_engine_user_data = NULL;
455 SLOG(LOG_DEBUG, TAG_STTC, "=====");
456 SLOG(LOG_DEBUG, TAG_STTC, " ");
461 int stt_get_engine(stt_h stt, char** engine_id)
463 stt_client_s* client = NULL;
464 if (0 != __stt_get_feature_enabled()) {
465 return STT_ERROR_NOT_SUPPORTED;
467 if (0 != __stt_check_privilege()) {
468 return STT_ERROR_PERMISSION_DENIED;
470 if (0 != __stt_check_handle(stt, &client)) {
471 return STT_ERROR_INVALID_PARAMETER;
474 SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
476 if (NULL == engine_id) {
477 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
478 return STT_ERROR_INVALID_PARAMETER;
481 if (client->current_state != STT_STATE_CREATED) {
482 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
483 return STT_ERROR_INVALID_STATE;
488 if (NULL != client->current_engine_id) {
489 *engine_id = strdup(client->current_engine_id);
490 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
493 ret = stt_config_mgr_get_engine(engine_id);
494 ret = __stt_convert_config_error_code(ret);
496 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
498 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
502 SLOG(LOG_DEBUG, TAG_STTC, "=====");
503 SLOG(LOG_DEBUG, TAG_STTC, " ");
508 int stt_set_engine(stt_h stt, const char* engine_id)
510 stt_client_s* client = NULL;
511 if (0 != __stt_get_feature_enabled()) {
512 return STT_ERROR_NOT_SUPPORTED;
514 if (0 != __stt_check_privilege()) {
515 return STT_ERROR_PERMISSION_DENIED;
517 if (0 != __stt_check_handle(stt, &client)) {
518 return STT_ERROR_INVALID_PARAMETER;
521 SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
523 if (NULL == engine_id) {
524 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
525 return STT_ERROR_INVALID_PARAMETER;
529 if (client->current_state != STT_STATE_CREATED) {
530 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
531 return STT_ERROR_INVALID_STATE;
534 if (NULL != client->current_engine_id) {
535 free(client->current_engine_id);
538 SLOG(LOG_DEBUG, TAG_STTC, "===== engined_id(%s)", engine_id);
540 client->current_engine_id = strdup(engine_id);
542 SLOG(LOG_DEBUG, TAG_STTC, "=====");
543 SLOG(LOG_DEBUG, TAG_STTC, " ");
548 int stt_set_credential(stt_h stt, const char* credential)
550 stt_client_s* client = NULL;
551 if (0 != __stt_get_feature_enabled()) {
552 return STT_ERROR_NOT_SUPPORTED;
554 if (0 != __stt_check_privilege()) {
555 return STT_ERROR_PERMISSION_DENIED;
557 if (0 != __stt_check_handle(stt, &client)) {
558 return STT_ERROR_INVALID_PARAMETER;
561 SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
563 if (NULL == credential) {
564 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
565 return STT_ERROR_INVALID_PARAMETER;
569 if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
570 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
571 return STT_ERROR_INVALID_STATE;
574 if (NULL != client->credential) {
575 free(client->credential);
576 client->credential = NULL;
578 client->credential = strdup(credential);
580 SLOG(LOG_DEBUG, TAG_STTC, "=====");
581 SLOG(LOG_DEBUG, TAG_STTC, " ");
583 return STT_ERROR_NONE;
586 int stt_set_private_data(stt_h stt, const char* key, const char* data)
588 stt_client_s* client = NULL;
589 if (0 != __stt_get_feature_enabled()) {
590 return STT_ERROR_NOT_SUPPORTED;
592 if (0 != __stt_check_privilege()) {
593 return STT_ERROR_PERMISSION_DENIED;
595 if (0 != __stt_check_handle(stt, &client)) {
596 return STT_ERROR_INVALID_PARAMETER;
599 SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data");
601 if (NULL == key || NULL == data) {
602 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
603 return STT_ERROR_INVALID_PARAMETER;
607 if (STT_STATE_READY != client->current_state) {
608 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
609 return STT_ERROR_INVALID_STATE;
615 ret = stt_dbus_request_set_private_data(client->uid, key, data);
617 if (STT_ERROR_TIMED_OUT != ret) {
618 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret));
621 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
624 if (STT_RETRY_COUNT == count) {
625 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
632 SLOG(LOG_DEBUG, TAG_STTC, "=====");
633 SLOG(LOG_DEBUG, TAG_STTC, "");
635 return STT_ERROR_NONE;
638 int stt_get_private_data(stt_h stt, const char* key, char** data)
640 stt_client_s* client = NULL;
641 if (0 != __stt_get_feature_enabled()) {
642 return STT_ERROR_NOT_SUPPORTED;
644 if (0 != __stt_check_privilege()) {
645 return STT_ERROR_PERMISSION_DENIED;
647 if (0 != __stt_check_handle(stt, &client)) {
648 return STT_ERROR_INVALID_PARAMETER;
651 SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data");
653 if (NULL == key || NULL == data) {
654 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter");
655 return STT_ERROR_INVALID_PARAMETER;
659 if (STT_STATE_READY != client->current_state) {
660 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
661 return STT_ERROR_INVALID_STATE;
667 ret = stt_dbus_request_get_private_data(client->uid, key, data);
669 if (STT_ERROR_TIMED_OUT != ret) {
670 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret));
673 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret));
676 if (STT_RETRY_COUNT == count) {
677 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
684 if (0 == strncmp(*data, "NULL", strlen(*data))) {
689 SLOG(LOG_DEBUG, TAG_STTC, "=====");
690 SLOG(LOG_DEBUG, TAG_STTC, "");
692 return STT_ERROR_NONE;
694 static Eina_Bool __stt_connect_daemon(void *data)
696 stt_client_s* client = (stt_client_s*)data;
698 if (NULL == client) {
699 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
700 g_connect_timer = NULL;
706 ret = stt_dbus_request_hello();
709 if (STT_ERROR_INVALID_STATE == ret) {
710 g_connect_timer = NULL;
716 g_connect_timer = NULL;
717 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect stt-service");
719 /* request initialization */
720 bool silence_supported = false;
721 bool credential_needed = false;
723 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
725 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
726 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
728 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
729 ecore_timer_add(0, __stt_notify_error, (void*)client);
733 } else if (STT_ERROR_NONE != ret) {
734 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
737 /* success to connect stt-service */
738 client->silence_supported = silence_supported;
739 client->credential_needed = credential_needed;
740 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
743 if (NULL != client->current_engine_id) {
746 silence_supported = false;
747 credential_needed = false;
748 SLOG(LOG_DEBUG, TAG_STTC, "[WARNING] current_engine_id(%s)", client->current_engine_id);
751 ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
753 if (STT_ERROR_TIMED_OUT != ret) {
754 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
757 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
760 if (STT_RETRY_COUNT == count) {
761 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
766 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
768 /* success to change engine */
769 client->silence_supported = silence_supported;
770 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
775 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
777 client->before_state = client->current_state;
778 client->current_state = STT_STATE_READY;
780 if (NULL != client->state_changed_cb) {
781 stt_client_use_callback(client);
782 client->state_changed_cb(client->stt, client->before_state,
783 client->current_state, client->state_changed_user_data);
784 stt_client_not_use_callback(client);
785 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
787 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
790 SLOG(LOG_DEBUG, TAG_STTC, "=====");
791 SLOG(LOG_DEBUG, TAG_STTC, " ");
796 int stt_prepare(stt_h stt)
798 stt_client_s* client = NULL;
799 if (0 != __stt_get_feature_enabled()) {
800 return STT_ERROR_NOT_SUPPORTED;
802 if (0 != __stt_check_privilege()) {
803 return STT_ERROR_PERMISSION_DENIED;
805 if (0 != __stt_check_handle(stt, &client)) {
806 return STT_ERROR_INVALID_PARAMETER;
810 if (client->current_state != STT_STATE_CREATED) {
811 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
812 return STT_ERROR_INVALID_STATE;
815 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
817 SLOG(LOG_DEBUG, TAG_STTC, "=====");
818 SLOG(LOG_DEBUG, TAG_STTC, " ");
820 return STT_ERROR_NONE;
823 int stt_unprepare(stt_h stt)
825 stt_client_s* client = NULL;
826 if (0 != __stt_get_feature_enabled()) {
827 return STT_ERROR_NOT_SUPPORTED;
829 if (0 != __stt_check_privilege()) {
830 return STT_ERROR_PERMISSION_DENIED;
832 if (0 != __stt_check_handle(stt, &client)) {
833 return STT_ERROR_INVALID_PARAMETER;
836 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
839 if (client->current_state != STT_STATE_READY) {
840 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
841 return STT_ERROR_INVALID_STATE;
847 ret = stt_dbus_request_finalize(client->uid);
849 if (STT_ERROR_TIMED_OUT != ret) {
850 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
853 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
856 if (STT_RETRY_COUNT == count) {
857 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
864 client->internal_state = STT_INTERNAL_STATE_NONE;
866 client->before_state = client->current_state;
867 client->current_state = STT_STATE_CREATED;
869 if (NULL != client->state_changed_cb) {
870 stt_client_use_callback(client);
871 client->state_changed_cb(client->stt, client->before_state,
872 client->current_state, client->state_changed_user_data);
873 stt_client_not_use_callback(client);
875 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
878 if (g_connect_timer) {
879 ecore_timer_del(g_connect_timer);
880 g_connect_timer = NULL;
883 SLOG(LOG_DEBUG, TAG_STTC, "=====");
884 SLOG(LOG_DEBUG, TAG_STTC, " ");
886 return STT_ERROR_NONE;
889 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
891 stt_h stt = (stt_h)user_data;
893 stt_client_s* client = stt_client_get(stt);
894 if (NULL == client) {
895 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
899 /* call callback function */
900 if (NULL != client->supported_lang_cb) {
901 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
903 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
909 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
911 stt_client_s* client = NULL;
912 if (0 != __stt_get_feature_enabled()) {
913 return STT_ERROR_NOT_SUPPORTED;
915 if (0 != __stt_check_privilege()) {
916 return STT_ERROR_PERMISSION_DENIED;
918 if (0 != __stt_check_handle(stt, &client)) {
919 return STT_ERROR_INVALID_PARAMETER;
922 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
924 if (NULL == callback) {
925 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
926 return STT_ERROR_INVALID_PARAMETER;
930 char* current_engine_id = NULL;
932 if (NULL == client->current_engine_id) {
933 ret = stt_config_mgr_get_engine(¤t_engine_id);
934 ret = __stt_convert_config_error_code(ret);
936 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
940 current_engine_id = strdup(client->current_engine_id);
941 if (NULL == current_engine_id) {
942 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
943 return STT_ERROR_OUT_OF_MEMORY;
947 client->supported_lang_cb = callback;
948 client->supported_lang_user_data = user_data;
950 ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
951 ret = __stt_convert_config_error_code(ret);
953 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
956 if (NULL != current_engine_id) {
957 free(current_engine_id);
960 client->supported_lang_cb = NULL;
961 client->supported_lang_user_data = NULL;
963 SLOG(LOG_DEBUG, TAG_STTC, "=====");
964 SLOG(LOG_DEBUG, TAG_STTC, " ");
969 int stt_get_default_language(stt_h stt, char** language)
971 stt_client_s* client = NULL;
972 if (0 != __stt_get_feature_enabled()) {
973 return STT_ERROR_NOT_SUPPORTED;
975 if (0 != __stt_check_privilege()) {
976 return STT_ERROR_PERMISSION_DENIED;
978 if (0 != __stt_check_handle(stt, &client)) {
979 return STT_ERROR_INVALID_PARAMETER;
982 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
984 if (NULL == language) {
985 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
986 return STT_ERROR_INVALID_PARAMETER;
990 ret = stt_config_mgr_get_default_language(language);
991 ret = __stt_convert_config_error_code(ret);
993 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
995 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
998 SLOG(LOG_DEBUG, TAG_STTC, "=====");
999 SLOG(LOG_DEBUG, TAG_STTC, " ");
1004 int stt_get_state(stt_h stt, stt_state_e* state)
1006 stt_client_s* client = NULL;
1007 if (0 != __stt_get_feature_enabled()) {
1008 return STT_ERROR_NOT_SUPPORTED;
1010 if (0 != __stt_check_privilege()) {
1011 return STT_ERROR_PERMISSION_DENIED;
1013 if (0 != __stt_check_handle(stt, &client)) {
1014 return STT_ERROR_INVALID_PARAMETER;
1017 if (NULL == state) {
1018 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1019 return STT_ERROR_INVALID_PARAMETER;
1022 *state = client->current_state;
1025 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
1026 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
1027 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
1028 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
1029 default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break;
1032 return STT_ERROR_NONE;
1035 int stt_get_error_message(stt_h stt, char** err_msg)
1037 stt_client_s* client = NULL;
1038 if (0 != __stt_get_feature_enabled()) {
1039 return STT_ERROR_NOT_SUPPORTED;
1041 if (0 != __stt_check_privilege()) {
1042 return STT_ERROR_PERMISSION_DENIED;
1044 if (0 != __stt_check_handle(stt, &client)) {
1045 return STT_ERROR_INVALID_PARAMETER;
1048 if (NULL == err_msg) {
1049 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1050 return STT_ERROR_INVALID_PARAMETER;
1053 if (false == g_err_callback_status) {
1054 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
1055 return STT_ERROR_OPERATION_FAILED;
1058 if (NULL != client->err_msg) {
1059 *err_msg = strdup(client->err_msg);
1060 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
1062 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
1065 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1066 SLOG(LOG_DEBUG, TAG_STTC, " ");
1068 return STT_ERROR_NONE;
1071 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
1073 stt_client_s* client = NULL;
1074 if (0 != __stt_get_feature_enabled()) {
1075 return STT_ERROR_NOT_SUPPORTED;
1077 if (0 != __stt_check_privilege()) {
1078 return STT_ERROR_PERMISSION_DENIED;
1080 if (0 != __stt_check_handle(stt, &client)) {
1081 return STT_ERROR_INVALID_PARAMETER;
1084 if (NULL == type || NULL == support) {
1085 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1086 return STT_ERROR_INVALID_PARAMETER;
1090 if (client->current_state != STT_STATE_READY) {
1091 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1092 return STT_ERROR_INVALID_STATE;
1098 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
1100 if (STT_ERROR_TIMED_OUT != ret) {
1101 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
1104 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1107 if (STT_RETRY_COUNT == count) {
1108 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1113 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
1118 return STT_ERROR_NONE;
1121 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
1123 stt_client_s* client = NULL;
1124 if (0 != __stt_get_feature_enabled()) {
1125 return STT_ERROR_NOT_SUPPORTED;
1127 if (0 != __stt_check_privilege()) {
1128 return STT_ERROR_PERMISSION_DENIED;
1130 if (0 != __stt_check_handle(stt, &client)) {
1131 return STT_ERROR_INVALID_PARAMETER;
1135 if (client->current_state != STT_STATE_READY) {
1136 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1137 return STT_ERROR_INVALID_STATE;
1140 if (true == client->silence_supported) {
1141 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
1142 client->silence = type;
1144 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
1145 return STT_ERROR_INVALID_PARAMETER;
1148 return STT_ERROR_NOT_SUPPORTED_FEATURE;
1151 return STT_ERROR_NONE;
1154 int stt_set_start_sound(stt_h stt, const char* filename)
1156 stt_client_s* client = NULL;
1157 if (0 != __stt_get_feature_enabled()) {
1158 return STT_ERROR_NOT_SUPPORTED;
1160 if (0 != __stt_check_privilege()) {
1161 return STT_ERROR_PERMISSION_DENIED;
1163 if (0 != __stt_check_handle(stt, &client)) {
1164 return STT_ERROR_INVALID_PARAMETER;
1167 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
1169 if (NULL == filename) {
1170 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1171 return STT_ERROR_INVALID_PARAMETER;
1174 if (0 != access(filename, F_OK)) {
1175 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1176 return STT_ERROR_INVALID_PARAMETER;
1180 if (client->current_state != STT_STATE_READY) {
1181 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1182 return STT_ERROR_INVALID_STATE;
1188 ret = stt_dbus_request_set_start_sound(client->uid, filename);
1190 if (STT_ERROR_TIMED_OUT != ret) {
1191 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
1194 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1197 if (STT_RETRY_COUNT == count) {
1198 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1203 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
1208 return STT_ERROR_NONE;
1211 int stt_unset_start_sound(stt_h stt)
1213 stt_client_s* client = NULL;
1214 if (0 != __stt_get_feature_enabled()) {
1215 return STT_ERROR_NOT_SUPPORTED;
1217 if (0 != __stt_check_privilege()) {
1218 return STT_ERROR_PERMISSION_DENIED;
1220 if (0 != __stt_check_handle(stt, &client)) {
1221 return STT_ERROR_INVALID_PARAMETER;
1224 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1227 if (client->current_state != STT_STATE_READY) {
1228 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1229 return STT_ERROR_INVALID_STATE;
1235 ret = stt_dbus_request_unset_start_sound(client->uid);
1237 if (STT_ERROR_TIMED_OUT != ret) {
1238 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1241 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1244 if (STT_RETRY_COUNT == count) {
1245 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1250 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1255 return STT_ERROR_NONE;
1258 int stt_set_stop_sound(stt_h stt, const char* filename)
1260 stt_client_s* client = NULL;
1261 if (0 != __stt_get_feature_enabled()) {
1262 return STT_ERROR_NOT_SUPPORTED;
1264 if (0 != __stt_check_privilege()) {
1265 return STT_ERROR_PERMISSION_DENIED;
1267 if (0 != __stt_check_handle(stt, &client)) {
1268 return STT_ERROR_INVALID_PARAMETER;
1271 SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1273 if (NULL == filename) {
1274 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1275 return STT_ERROR_INVALID_PARAMETER;
1278 if (0 != access(filename, F_OK)) {
1279 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1280 return STT_ERROR_INVALID_PARAMETER;
1284 if (client->current_state != STT_STATE_READY) {
1285 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1286 return STT_ERROR_INVALID_STATE;
1292 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1294 if (STT_ERROR_TIMED_OUT != ret) {
1295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1298 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1301 if (STT_RETRY_COUNT == count) {
1302 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1307 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1312 return STT_ERROR_NONE;
1315 int stt_unset_stop_sound(stt_h stt)
1317 stt_client_s* client = NULL;
1318 if (0 != __stt_get_feature_enabled()) {
1319 return STT_ERROR_NOT_SUPPORTED;
1321 if (0 != __stt_check_privilege()) {
1322 return STT_ERROR_PERMISSION_DENIED;
1324 if (0 != __stt_check_handle(stt, &client)) {
1325 return STT_ERROR_INVALID_PARAMETER;
1328 SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1331 if (client->current_state != STT_STATE_READY) {
1332 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1333 return STT_ERROR_INVALID_STATE;
1339 ret = stt_dbus_request_unset_stop_sound(client->uid);
1341 if (STT_ERROR_TIMED_OUT != ret) {
1342 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1345 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1348 if (STT_RETRY_COUNT == count) {
1349 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1354 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1359 return STT_ERROR_NONE;
1362 int stt_start(stt_h stt, const char* language, const char* type)
1364 stt_client_s* client = NULL;
1365 if (0 != __stt_get_feature_enabled()) {
1366 return STT_ERROR_NOT_SUPPORTED;
1368 if (0 != __stt_check_privilege()) {
1369 return STT_ERROR_PERMISSION_DENIED;
1371 if (0 != __stt_check_handle(stt, &client)) {
1372 return STT_ERROR_INVALID_PARAMETER;
1375 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1378 if (client->current_state != STT_STATE_READY) {
1379 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1380 return STT_ERROR_INVALID_STATE;
1383 if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1384 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1385 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1389 char appid[128] = {0, };
1390 ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1392 if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1393 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1395 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1399 if (NULL == language) {
1400 temp = strdup("default");
1402 temp = strdup(language);
1405 if (true == client->credential_needed && NULL == client->credential) {
1406 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1407 return STT_ERROR_PERMISSION_DENIED;
1410 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1412 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1414 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1415 client->internal_state = STT_INTERNAL_STATE_STARTING;
1418 if (NULL != temp) free(temp);
1420 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1421 SLOG(LOG_DEBUG, TAG_STTC, " ");
1426 int stt_stop(stt_h stt)
1428 stt_client_s* client = NULL;
1429 if (0 != __stt_get_feature_enabled()) {
1430 return STT_ERROR_NOT_SUPPORTED;
1432 if (0 != __stt_check_privilege()) {
1433 return STT_ERROR_PERMISSION_DENIED;
1435 if (0 != __stt_check_handle(stt, &client)) {
1436 return STT_ERROR_INVALID_PARAMETER;
1439 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1442 if (client->current_state != STT_STATE_RECORDING) {
1443 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1444 return STT_ERROR_INVALID_STATE;
1447 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1448 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1449 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1450 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1451 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1452 return STT_ERROR_IN_PROGRESS_TO_READY;
1453 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1454 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1455 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1458 int ret = stt_dbus_request_stop(client->uid);
1461 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1463 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1464 client->internal_state = STT_INTERNAL_STATE_STOPPING;
1467 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1468 SLOG(LOG_DEBUG, TAG_STTC, " ");
1474 int stt_cancel(stt_h stt)
1476 stt_client_s* client = NULL;
1477 if (0 != __stt_get_feature_enabled()) {
1478 return STT_ERROR_NOT_SUPPORTED;
1480 if (0 != __stt_check_privilege()) {
1481 return STT_ERROR_PERMISSION_DENIED;
1483 if (0 != __stt_check_handle(stt, &client)) {
1484 return STT_ERROR_INVALID_PARAMETER;
1487 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1490 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1491 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1492 return STT_ERROR_INVALID_STATE;
1495 if (STT_INTERNAL_STATE_STARTING == client->internal_state) {
1496 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state);
1497 return STT_ERROR_IN_PROGRESS_TO_RECORDING;
1498 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) {
1499 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state);
1500 return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
1501 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) {
1502 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state);
1503 return STT_ERROR_IN_PROGRESS_TO_READY;
1506 int ret = stt_dbus_request_cancel(client->uid);
1508 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1510 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1511 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1514 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1515 SLOG(LOG_DEBUG, TAG_STTC, " ");
1520 int __stt_cb_set_volume(int uid, float volume)
1522 stt_client_s* client = NULL;
1524 client = stt_client_get_by_uid(uid);
1525 if (NULL == client) {
1526 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1527 return STT_ERROR_INVALID_PARAMETER;
1530 if (STT_STATE_RECORDING != client->current_state) {
1531 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1532 return STT_ERROR_INVALID_STATE;
1535 g_volume_db = volume;
1536 SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1541 int stt_get_recording_volume(stt_h stt, float* volume)
1543 stt_client_s* client = NULL;
1544 if (0 != __stt_get_feature_enabled()) {
1545 return STT_ERROR_NOT_SUPPORTED;
1547 if (0 != __stt_check_privilege()) {
1548 return STT_ERROR_PERMISSION_DENIED;
1550 if (0 != __stt_check_handle(stt, &client)) {
1551 return STT_ERROR_INVALID_PARAMETER;
1554 if (NULL == volume) {
1555 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1556 return STT_ERROR_INVALID_PARAMETER;
1559 if (STT_STATE_RECORDING != client->current_state) {
1560 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1561 return STT_ERROR_INVALID_STATE;
1564 *volume = g_volume_db;
1566 return STT_ERROR_NONE;
1569 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1571 stt_client_s* client = (stt_client_s*)user_data;
1574 if (NULL == client) {
1575 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1579 if (NULL != client->result_time_cb) {
1580 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1581 index, event, text, start_time, end_time);
1582 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1583 text, start_time, end_time, client->result_time_user_data);
1585 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1592 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1594 stt_client_s* client = NULL;
1595 if (0 != __stt_get_feature_enabled()) {
1596 return STT_ERROR_NOT_SUPPORTED;
1598 if (0 != __stt_check_privilege()) {
1599 return STT_ERROR_PERMISSION_DENIED;
1601 if (0 != __stt_check_handle(stt, &client)) {
1602 return STT_ERROR_INVALID_PARAMETER;
1605 SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1607 if (NULL == callback) {
1608 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1609 return STT_ERROR_INVALID_PARAMETER;
1612 client->result_time_cb = callback;
1613 client->result_time_user_data = user_data;
1616 ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1617 ret = __stt_convert_config_error_code(ret);
1619 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1622 client->result_time_cb = NULL;
1623 client->result_time_user_data = NULL;
1625 SLOG(LOG_DEBUG, TAG_STTC, "=====");
1626 SLOG(LOG_DEBUG, TAG_STTC, " ");
1631 static Eina_Bool __stt_notify_error(void *data)
1633 stt_client_s* client = (stt_client_s*)data;
1635 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1638 if (NULL == client) {
1639 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1643 if (NULL == stt_client_get_by_uid(client->uid))
1646 if (NULL != client->error_cb) {
1647 stt_client_use_callback(client);
1648 g_err_callback_status = true;
1649 client->error_cb(client->stt, client->reason, client->error_user_data);
1650 g_err_callback_status = false;
1651 stt_client_not_use_callback(client);
1652 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1654 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1660 int __stt_cb_error(int uid, int reason, char* err_msg)
1662 stt_client_s* client = stt_client_get_by_uid(uid);
1663 if (NULL == client) {
1664 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1668 client->reason = reason;
1669 client->internal_state = STT_INTERNAL_STATE_NONE;
1670 if (NULL != client->err_msg) {
1671 free(client->err_msg);
1672 client->err_msg = NULL;
1674 client->err_msg = strdup(err_msg);
1676 SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1678 if (NULL != client->error_cb) {
1679 ecore_timer_add(0, __stt_notify_error, client);
1681 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1684 if (STT_ERROR_SERVICE_RESET == reason) {
1685 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset");
1687 client->current_state = STT_STATE_CREATED;
1688 if (0 != stt_prepare(client->stt)) {
1689 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare");
1696 static void __stt_notify_state_changed(void *data)
1698 stt_client_s* client = (stt_client_s*)data;
1701 if (NULL == client) {
1702 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1706 if (NULL == stt_client_get_by_uid(client->uid)) {
1710 if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1711 client->internal_state = STT_INTERNAL_STATE_NONE;
1712 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1713 } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1714 client->internal_state = STT_INTERNAL_STATE_NONE;
1715 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1716 } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1717 client->internal_state = STT_INTERNAL_STATE_NONE;
1718 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1721 if (NULL != client->state_changed_cb) {
1722 stt_client_use_callback(client);
1723 client->state_changed_cb(client->stt, client->before_state,
1724 client->current_state, client->state_changed_user_data);
1725 stt_client_not_use_callback(client);
1726 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1728 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1734 static Eina_Bool __stt_notify_result(void *data)
1736 stt_client_s* client = (stt_client_s*)data;
1739 if (NULL == client) {
1740 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1744 if (NULL == stt_client_get_by_uid(client->uid)) {
1748 if (NULL != client->recognition_result_cb) {
1749 stt_client_use_callback(client);
1750 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1751 client->msg, client->recognition_result_user_data);
1752 stt_client_not_use_callback(client);
1753 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1755 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1758 if (NULL != client->msg) {
1763 if (NULL != client->data_list) {
1765 temp = client->data_list;
1768 for (i = 0; i < client->data_count; i++) {
1769 if (NULL != temp[i]) {
1773 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1776 free(client->data_list);
1777 client->data_list = NULL;
1780 client->data_count = 0;
1782 stt_config_mgr_remove_time_info_file();
1784 if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1785 client->before_state = client->current_state;
1786 client->current_state = STT_STATE_READY;
1788 if (NULL != client->state_changed_cb) {
1789 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1791 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1798 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1800 stt_client_s* client = NULL;
1802 client = stt_client_get_by_uid(uid);
1803 if (NULL == client) {
1804 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1805 return STT_ERROR_INVALID_PARAMETER;
1809 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1812 for (i = 0; i < data_count; i++) {
1813 if (NULL != data[i])
1814 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1817 if (NULL != client->recognition_result_cb) {
1818 client->event = event;
1820 client->msg = strdup(msg);
1823 client->data_count = data_count;
1825 if (data_count > 0) {
1827 temp = (char**)calloc(data_count, sizeof(char*));
1829 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1830 return STT_ERROR_OUT_OF_MEMORY;
1833 for (i = 0; i < data_count; i++) {
1834 if (NULL != data[i])
1835 temp[i] = strdup(data[i]);
1837 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1840 client->data_list = temp;
1843 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1846 ecore_timer_add(0, __stt_notify_result, client);
1848 return STT_ERROR_NONE;
1851 int __stt_cb_set_state(int uid, int state)
1853 stt_client_s* client = stt_client_get_by_uid(uid);
1854 if (NULL == client) {
1855 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1859 stt_state_e state_from_daemon = (stt_state_e)state;
1861 if (client->current_state == state_from_daemon) {
1862 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1866 client->before_state = client->current_state;
1867 client->current_state = state_from_daemon;
1869 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1873 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1875 stt_client_s* client = NULL;
1876 if (0 != __stt_get_feature_enabled()) {
1877 return STT_ERROR_NOT_SUPPORTED;
1879 if (0 != __stt_check_privilege()) {
1880 return STT_ERROR_PERMISSION_DENIED;
1882 if (0 != __stt_check_handle(stt, &client)) {
1883 return STT_ERROR_INVALID_PARAMETER;
1886 if (callback == NULL)
1887 return STT_ERROR_INVALID_PARAMETER;
1889 if (STT_STATE_CREATED != client->current_state) {
1890 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1891 return STT_ERROR_INVALID_STATE;
1894 client->recognition_result_cb = callback;
1895 client->recognition_result_user_data = user_data;
1900 int stt_unset_recognition_result_cb(stt_h stt)
1902 stt_client_s* client = NULL;
1903 if (0 != __stt_get_feature_enabled()) {
1904 return STT_ERROR_NOT_SUPPORTED;
1906 if (0 != __stt_check_privilege()) {
1907 return STT_ERROR_PERMISSION_DENIED;
1909 if (0 != __stt_check_handle(stt, &client)) {
1910 return STT_ERROR_INVALID_PARAMETER;
1913 if (STT_STATE_CREATED != client->current_state) {
1914 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1915 return STT_ERROR_INVALID_STATE;
1918 client->recognition_result_cb = NULL;
1919 client->recognition_result_user_data = NULL;
1924 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1926 stt_client_s* client = NULL;
1927 if (0 != __stt_get_feature_enabled()) {
1928 return STT_ERROR_NOT_SUPPORTED;
1930 if (0 != __stt_check_privilege()) {
1931 return STT_ERROR_PERMISSION_DENIED;
1933 if (0 != __stt_check_handle(stt, &client)) {
1934 return STT_ERROR_INVALID_PARAMETER;
1937 if (NULL == callback)
1938 return STT_ERROR_INVALID_PARAMETER;
1940 if (STT_STATE_CREATED != client->current_state) {
1941 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1942 return STT_ERROR_INVALID_STATE;
1945 client->state_changed_cb = callback;
1946 client->state_changed_user_data = user_data;
1951 int stt_unset_state_changed_cb(stt_h stt)
1953 stt_client_s* client = NULL;
1954 if (0 != __stt_get_feature_enabled()) {
1955 return STT_ERROR_NOT_SUPPORTED;
1957 if (0 != __stt_check_privilege()) {
1958 return STT_ERROR_PERMISSION_DENIED;
1960 if (0 != __stt_check_handle(stt, &client)) {
1961 return STT_ERROR_INVALID_PARAMETER;
1964 if (STT_STATE_CREATED != client->current_state) {
1965 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1966 return STT_ERROR_INVALID_STATE;
1969 client->state_changed_cb = NULL;
1970 client->state_changed_user_data = NULL;
1975 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1977 stt_client_s* client = NULL;
1978 if (0 != __stt_get_feature_enabled()) {
1979 return STT_ERROR_NOT_SUPPORTED;
1981 if (0 != __stt_check_privilege()) {
1982 return STT_ERROR_PERMISSION_DENIED;
1984 if (0 != __stt_check_handle(stt, &client)) {
1985 return STT_ERROR_INVALID_PARAMETER;
1988 if (NULL == callback)
1989 return STT_ERROR_INVALID_PARAMETER;
1991 if (STT_STATE_CREATED != client->current_state) {
1992 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1993 return STT_ERROR_INVALID_STATE;
1996 client->error_cb = callback;
1997 client->error_user_data = user_data;
2002 int stt_unset_error_cb(stt_h stt)
2004 stt_client_s* client = NULL;
2005 if (0 != __stt_get_feature_enabled()) {
2006 return STT_ERROR_NOT_SUPPORTED;
2008 if (0 != __stt_check_privilege()) {
2009 return STT_ERROR_PERMISSION_DENIED;
2011 if (0 != __stt_check_handle(stt, &client)) {
2012 return STT_ERROR_INVALID_PARAMETER;
2015 if (STT_STATE_CREATED != client->current_state) {
2016 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2017 return STT_ERROR_INVALID_STATE;
2020 client->error_cb = NULL;
2021 client->error_user_data = NULL;
2026 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
2028 stt_client_s* client = NULL;
2029 if (0 != __stt_get_feature_enabled()) {
2030 return STT_ERROR_NOT_SUPPORTED;
2032 if (0 != __stt_check_privilege()) {
2033 return STT_ERROR_PERMISSION_DENIED;
2035 if (0 != __stt_check_handle(stt, &client)) {
2036 return STT_ERROR_INVALID_PARAMETER;
2039 if (NULL == callback)
2040 return STT_ERROR_INVALID_PARAMETER;
2042 if (STT_STATE_CREATED != client->current_state) {
2043 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2044 return STT_ERROR_INVALID_STATE;
2047 client->default_lang_changed_cb = callback;
2048 client->default_lang_changed_user_data = user_data;
2053 int stt_unset_default_language_changed_cb(stt_h stt)
2055 stt_client_s* client = NULL;
2056 if (0 != __stt_get_feature_enabled()) {
2057 return STT_ERROR_NOT_SUPPORTED;
2059 if (0 != __stt_check_privilege()) {
2060 return STT_ERROR_PERMISSION_DENIED;
2062 if (0 != __stt_check_handle(stt, &client)) {
2063 return STT_ERROR_INVALID_PARAMETER;
2066 if (STT_STATE_CREATED != client->current_state) {
2067 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2068 return STT_ERROR_INVALID_STATE;
2071 client->default_lang_changed_cb = NULL;
2072 client->default_lang_changed_user_data = NULL;
2077 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2079 stt_client_s* client = NULL;
2080 if (0 != __stt_get_feature_enabled()) {
2081 return STT_ERROR_NOT_SUPPORTED;
2083 if (0 != __stt_check_privilege()) {
2084 return STT_ERROR_PERMISSION_DENIED;
2086 if (0 != __stt_check_handle(stt, &client)) {
2087 return STT_ERROR_INVALID_PARAMETER;
2090 if (NULL == callback)
2091 return STT_ERROR_INVALID_PARAMETER;
2093 if (STT_STATE_CREATED != client->current_state) {
2094 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2095 return STT_ERROR_INVALID_STATE;
2098 client->engine_changed_cb = callback;
2099 client->engine_changed_user_data = user_data;
2104 int stt_unset_engine_changed_cb(stt_h stt)
2106 stt_client_s* client = NULL;
2107 if (0 != __stt_get_feature_enabled()) {
2108 return STT_ERROR_NOT_SUPPORTED;
2110 if (0 != __stt_check_privilege()) {
2111 return STT_ERROR_PERMISSION_DENIED;
2113 if (0 != __stt_check_handle(stt, &client)) {
2114 return STT_ERROR_INVALID_PARAMETER;
2117 if (STT_STATE_CREATED != client->current_state) {
2118 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2119 return STT_ERROR_INVALID_STATE;
2122 client->engine_changed_cb = NULL;
2123 client->engine_changed_user_data = NULL;