2 * Copyright (c) 2012, 2013 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.
16 #include <sys/types.h>
24 #include "stt_client.h"
27 #define CONNECTION_RETRY_COUNT 3
29 static bool g_is_daemon_started = false;
31 static Ecore_Timer* g_connect_timer = NULL;
33 static int __check_stt_daemon();
34 static Eina_Bool __stt_notify_state_changed(void *data);
35 static Eina_Bool __stt_notify_error(void *data);
37 int stt_create(stt_h* stt)
39 SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
42 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
43 return STT_ERROR_INVALID_PARAMETER;
46 if (0 == stt_client_get_size()) {
47 if (0 != stt_dbus_open_connection()) {
48 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
49 return STT_ERROR_OPERATION_FAILED;
53 if (0 != stt_client_new(stt)) {
54 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
55 return STT_ERROR_OUT_OF_MEMORY;
58 SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
60 SLOG(LOG_DEBUG, TAG_STTC, "=====");
61 SLOG(LOG_DEBUG, TAG_STTC, " ");
63 return STT_ERROR_NONE;
66 int stt_destroy(stt_h stt)
68 SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
71 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
72 SLOG(LOG_DEBUG, TAG_STTC, "=====");
73 SLOG(LOG_DEBUG, TAG_STTC, " ");
74 return STT_ERROR_INVALID_PARAMETER;
77 stt_client_s* client = stt_client_get(stt);
81 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
82 return STT_ERROR_INVALID_PARAMETER;
85 /* check used callback */
86 if (0 != stt_client_get_use_callback(client)) {
87 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
88 return STT_ERROR_OPERATION_FAILED;
94 switch (client->current_state) {
95 case STT_STATE_PROCESSING:
96 case STT_STATE_RECORDING:
98 ret = stt_dbus_request_finalize(client->uid);
100 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize");
102 g_is_daemon_started = false;
103 case STT_STATE_CREATED:
104 if (NULL != g_connect_timer) {
105 SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
106 ecore_timer_del(g_connect_timer);
109 stt_client_destroy(stt);
113 SLOG(LOG_DEBUG, TAG_STTC, "Success: destroy");
115 if (0 == stt_client_get_size()) {
116 if (0 != stt_dbus_close_connection()) {
117 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
121 SLOG(LOG_DEBUG, TAG_STTC, "=====");
122 SLOG(LOG_DEBUG, TAG_STTC, " ");
124 return STT_ERROR_NONE;
127 static Eina_Bool __stt_connect_daemon(void *data)
129 stt_h stt = (stt_h)data;
131 stt_client_s* client = stt_client_get(stt);
133 if (NULL == client) {
134 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
135 return STT_ERROR_INVALID_PARAMETER;
139 if (0 != stt_dbus_request_hello()) {
140 if (false == g_is_daemon_started) {
141 g_is_daemon_started = true;
142 __check_stt_daemon();
147 SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
149 /* request initialization */
152 bool silence_supported = false;
153 bool profanity_supported = false;
154 bool punctuation_supported = false;
157 ret = stt_dbus_request_initialize(client->uid, &silence_supported, &profanity_supported, &punctuation_supported);
159 if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
160 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : STT Engine Not found");
162 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
164 ecore_timer_add(0, __stt_notify_error, (void*)stt);
168 } else if(0 != ret) {
170 if(CONNECTION_RETRY_COUNT == i) {
171 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : TIMED OUT");
173 client->reason = STT_ERROR_TIMED_OUT;
175 ecore_timer_add(0, __stt_notify_error, (void*)stt);
181 /* success to connect stt-daemon */
182 stt_client_set_option_supported(client->stt, silence_supported, profanity_supported, punctuation_supported);
183 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), profanity(%s), punctuation(%s)",
184 silence_supported ? "true" : "false", profanity_supported ? "true" : "false", punctuation_supported ? "true" : "false");
189 client->before_state = client->current_state;
190 client->current_state = STT_STATE_READY;
192 ecore_timer_add(0, __stt_notify_state_changed, (void*)stt);
194 g_connect_timer = NULL;
196 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
198 SLOG(LOG_DEBUG, TAG_STTC, "=====");
199 SLOG(LOG_DEBUG, TAG_STTC, " ");
205 int stt_prepare(stt_h stt)
207 SLOG(LOG_DEBUG, TAG_STTC, "===== Prepare STT");
209 stt_client_s* client = stt_client_get(stt);
212 if (NULL == client) {
213 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
214 SLOG(LOG_DEBUG, TAG_STTC, "=====");
215 SLOG(LOG_DEBUG, TAG_STTC, " ");
216 return STT_ERROR_INVALID_PARAMETER;
220 if (client->current_state != STT_STATE_CREATED) {
221 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not 'CREATED'");
222 SLOG(LOG_DEBUG, TAG_STTC, "=====");
223 SLOG(LOG_DEBUG, TAG_STTC, " ");
224 return STT_ERROR_INVALID_STATE;
227 g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)stt);
229 SLOG(LOG_DEBUG, TAG_STTC, "=====");
230 SLOG(LOG_DEBUG, TAG_STTC, " ");
232 return STT_ERROR_NONE;
235 int stt_unprepare(stt_h stt)
237 SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
239 stt_client_s* client = stt_client_get(stt);
242 if (NULL == client) {
243 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
244 return STT_ERROR_INVALID_PARAMETER;
248 if (client->current_state != STT_STATE_READY) {
249 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not 'READY'");
250 SLOG(LOG_DEBUG, TAG_STTC, "=====");
251 SLOG(LOG_DEBUG, TAG_STTC, " ");
252 return STT_ERROR_INVALID_STATE;
255 int ret = stt_dbus_request_finalize(client->uid);
257 SLOG(LOG_WARN, TAG_STTC, "[ERROR] Fail to request finalize");
259 g_is_daemon_started = false;
261 client->before_state = client->current_state;
262 client->current_state = STT_STATE_CREATED;
264 ecore_timer_add(0, __stt_notify_state_changed, (void*)stt);
266 SLOG(LOG_DEBUG, TAG_STTC, "=====");
267 SLOG(LOG_DEBUG, TAG_STTC, " ");
269 return STT_ERROR_NONE;
272 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
274 SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
276 if (NULL == stt || NULL == callback) {
277 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
278 SLOG(LOG_DEBUG, TAG_STTC, "=====");
279 SLOG(LOG_DEBUG, TAG_STTC, " ");
280 return STT_ERROR_INVALID_PARAMETER;
283 stt_client_s* client = stt_client_get(stt);
286 if (NULL == client) {
287 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
288 SLOG(LOG_DEBUG, TAG_STTC, "=====");
289 SLOG(LOG_DEBUG, TAG_STTC, " ");
290 return STT_ERROR_INVALID_PARAMETER;
294 if (client->current_state != STT_STATE_READY) {
295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
296 return STT_ERROR_INVALID_STATE;
300 ret = stt_dbus_request_get_support_langs(client->uid, client->stt, callback, user_data);
302 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages");
304 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
307 SLOG(LOG_DEBUG, TAG_STTC, "=====");
308 SLOG(LOG_DEBUG, TAG_STTC, " ");
310 return STT_ERROR_NONE;
314 int stt_get_default_language(stt_h stt, char** language)
316 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
318 if (NULL == stt || NULL == language) {
319 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
320 SLOG(LOG_DEBUG, TAG_STTC, "=====");
321 SLOG(LOG_DEBUG, TAG_STTC, " ");
322 return STT_ERROR_INVALID_PARAMETER;
325 stt_client_s* client = stt_client_get(stt);
328 if (NULL == client) {
329 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
330 SLOG(LOG_DEBUG, TAG_STTC, "=====");
331 SLOG(LOG_DEBUG, TAG_STTC, " ");
332 return STT_ERROR_INVALID_PARAMETER;
336 if (client->current_state != STT_STATE_READY) {
337 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
338 return STT_ERROR_INVALID_STATE;
342 ret = stt_dbus_request_get_default_lang(client->uid, language);
345 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail : request get default language");
347 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
350 SLOG(LOG_DEBUG, TAG_STTC, "=====");
351 SLOG(LOG_DEBUG, TAG_STTC, " ");
356 int stt_get_state(stt_h stt, stt_state_e* state)
358 if (NULL == stt || NULL == state) {
359 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
360 return STT_ERROR_INVALID_PARAMETER;
363 stt_client_s* client = stt_client_get(stt);
365 if (NULL == client) {
366 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
367 return STT_ERROR_INVALID_PARAMETER;
370 *state = client->current_state;
373 case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break;
374 case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break;
375 case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break;
376 case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break;
379 return STT_ERROR_NONE;
382 int stt_is_partial_result_supported(stt_h stt, bool* partial_result)
384 if (NULL == stt || NULL == partial_result) {
385 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
386 return STT_ERROR_INVALID_PARAMETER;
389 stt_client_s* client = stt_client_get(stt);
391 if (NULL == client) {
392 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not valid");
393 return STT_ERROR_INVALID_PARAMETER;
397 if (client->current_state != STT_STATE_READY) {
398 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
399 return STT_ERROR_INVALID_STATE;
403 ret = stt_dbus_request_is_partial_result_supported(client->uid, partial_result);
406 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get partial result supported");
408 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Partial result supporting is %s", *partial_result ? "true " : "false");
411 return STT_ERROR_NONE;
414 int stt_set_profanity_filter(stt_h stt, stt_option_profanity_e type)
417 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
418 return STT_ERROR_INVALID_PARAMETER;
421 stt_client_s* client = stt_client_get(stt);
423 if (NULL == client) {
424 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
425 return STT_ERROR_INVALID_PARAMETER;
429 if (client->current_state != STT_STATE_READY) {
430 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
431 return STT_ERROR_INVALID_STATE;
434 if (true == client->profanity_supported) {
435 if (type >= STT_OPTION_PROFANITY_FALSE && type <= STT_OPTION_PROFANITY_AUTO)
436 client->profanity = type;
438 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
439 return STT_ERROR_INVALID_PARAMETER;
442 return STT_ERROR_NOT_SUPPORTED_FEATURE;
445 return STT_ERROR_NONE;
448 int stt_set_punctuation_override(stt_h stt, stt_option_punctuation_e type)
451 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
452 return STT_ERROR_INVALID_PARAMETER;
455 stt_client_s* client = stt_client_get(stt);
457 if (NULL == client) {
458 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
459 return STT_ERROR_INVALID_PARAMETER;
463 if (client->current_state != STT_STATE_READY) {
464 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
465 return STT_ERROR_INVALID_STATE;
468 if (true == client->punctuation_supported) {
469 if (type >= STT_OPTION_PUNCTUATION_FALSE && type <= STT_OPTION_PUNCTUATION_AUTO)
470 client->punctuation = type;
472 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
473 return STT_ERROR_INVALID_PARAMETER;
476 return STT_ERROR_NOT_SUPPORTED_FEATURE;
479 return STT_ERROR_NONE;
482 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
485 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
486 return STT_ERROR_INVALID_PARAMETER;
489 stt_client_s* client = stt_client_get(stt);
491 if (NULL == client) {
492 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
493 return STT_ERROR_INVALID_PARAMETER;
497 if (client->current_state != STT_STATE_READY) {
498 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
499 return STT_ERROR_INVALID_STATE;
502 if (true == client->silence_supported) {
503 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO)
504 client->silence = type;
506 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
507 return STT_ERROR_INVALID_PARAMETER;
510 return STT_ERROR_NOT_SUPPORTED_FEATURE;
513 return STT_ERROR_NONE;
516 int stt_start(stt_h stt, const char* language, const char* type)
518 SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
521 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
522 SLOG(LOG_DEBUG, TAG_STTC, "=====");
523 SLOG(LOG_DEBUG, TAG_STTC, " ");
524 return STT_ERROR_INVALID_PARAMETER;
527 stt_client_s* client = stt_client_get(stt);
530 if (NULL == client) {
531 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
532 SLOG(LOG_DEBUG, TAG_STTC, "=====");
533 SLOG(LOG_DEBUG, TAG_STTC, " ");
534 return STT_ERROR_INVALID_PARAMETER;
538 if (client->current_state != STT_STATE_READY) {
539 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state is not READY");
540 SLOG(LOG_DEBUG, TAG_STTC, "=====");
541 SLOG(LOG_DEBUG, TAG_STTC, " ");
542 return STT_ERROR_INVALID_STATE;
546 if (NULL == language) {
547 temp = strdup("default");
549 temp = strdup(language);
554 ret = stt_dbus_request_start(client->uid, temp, type, client->profanity, client->punctuation, client->silence);
557 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start");
559 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
561 client->before_state = client->current_state;
562 client->current_state = STT_STATE_RECORDING;
564 ecore_timer_add(0, __stt_notify_state_changed, (void*)stt);
569 SLOG(LOG_DEBUG, TAG_STTC, "=====");
570 SLOG(LOG_DEBUG, TAG_STTC, " ");
575 int stt_stop(stt_h stt)
577 SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
580 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] [ERROR] Input parameter is NULL");
581 SLOG(LOG_DEBUG, TAG_STTC, "=====");
582 SLOG(LOG_DEBUG, TAG_STTC, " ");
583 return STT_ERROR_INVALID_PARAMETER;
586 stt_client_s* client = stt_client_get(stt);
589 if (NULL == client) {
590 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
591 SLOG(LOG_DEBUG, TAG_STTC, "=====");
592 SLOG(LOG_DEBUG, TAG_STTC, " ");
593 return STT_ERROR_INVALID_PARAMETER;
597 if (client->current_state != STT_STATE_RECORDING) {
598 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state is NOT RECORDING");
599 SLOG(LOG_DEBUG, TAG_STTC, "=====");
600 SLOG(LOG_DEBUG, TAG_STTC, " ");
601 return STT_ERROR_INVALID_STATE;
606 ret = stt_dbus_request_stop(client->uid);
608 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to stop");
610 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
612 client->before_state = client->current_state;
613 client->current_state = STT_STATE_PROCESSING;
615 ecore_timer_add(0, __stt_notify_state_changed, (void*)stt);
618 SLOG(LOG_DEBUG, TAG_STTC, "=====");
619 SLOG(LOG_DEBUG, TAG_STTC, " ");
625 int stt_cancel(stt_h stt)
627 SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
630 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
631 SLOG(LOG_DEBUG, TAG_STTC, "=====");
632 SLOG(LOG_DEBUG, TAG_STTC, " ");
633 return STT_ERROR_INVALID_PARAMETER;
636 stt_client_s* client = stt_client_get(stt);
639 if (NULL == client) {
640 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
641 SLOG(LOG_DEBUG, TAG_STTC, "=====");
642 SLOG(LOG_DEBUG, TAG_STTC, " ");
643 return STT_ERROR_INVALID_PARAMETER;
647 if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
648 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : Current state is 'Ready'");
649 SLOG(LOG_DEBUG, TAG_STTC, "=====");
650 SLOG(LOG_DEBUG, TAG_STTC, " ");
651 return STT_ERROR_INVALID_STATE;
656 ret = stt_dbus_request_cancel(client->uid);
658 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to cancel");
660 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
662 client->before_state = client->current_state;
663 client->current_state = STT_STATE_READY;
665 ecore_timer_add(0, __stt_notify_state_changed, (void*)stt);
668 SLOG(LOG_DEBUG, TAG_STTC, "=====");
669 SLOG(LOG_DEBUG, TAG_STTC, " ");
674 static int __stt_get_audio_volume(float* volume)
676 FILE* fp = fopen(STT_AUDIO_VOLUME_PATH, "rb");
678 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open Volume File");
682 fread((void*)volume, sizeof(*volume), 1, fp);
688 int stt_get_recording_volume(stt_h stt, float* volume)
690 if (NULL == stt || NULL == volume) {
691 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
692 return STT_ERROR_INVALID_PARAMETER;
695 stt_client_s* client = stt_client_get(stt);
698 if (NULL == client) {
699 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
700 return STT_ERROR_INVALID_PARAMETER;
703 if (STT_STATE_RECORDING != client->current_state) {
704 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state");
705 return STT_ERROR_INVALID_STATE;
709 ret = __stt_get_audio_volume(volume);
711 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get audio volume");
712 return STT_ERROR_OPERATION_FAILED;
715 return STT_ERROR_NONE;
718 static Eina_Bool __stt_notify_error(void *data)
720 stt_h stt = (stt_h)data;
722 stt_client_s* client = stt_client_get(stt);
725 if (NULL == client) {
726 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
730 if (NULL != client->error_cb) {
731 stt_client_use_callback(client);
732 client->error_cb(client->stt, client->reason, client->error_user_data);
733 stt_client_not_use_callback(client);
734 SLOG(LOG_DEBUG, TAG_STTC, "Error callback is called");
736 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
742 int __stt_cb_error(int uid, int reason)
744 stt_client_s* client = stt_client_get_by_uid(uid);
745 if( NULL == client ) {
746 SLOG(LOG_ERROR, TAG_STTC, "Handle not found\n");
750 client->reason = reason;
752 if (NULL != client->error_cb) {
753 ecore_timer_add(0, __stt_notify_error, client->stt);
755 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
761 static Eina_Bool __stt_notify_result(void *data)
763 stt_h stt = (stt_h)data;
765 stt_client_s* client = stt_client_get(stt);
768 if (NULL == client) {
769 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
773 if (NULL != client->result_cb) {
774 stt_client_use_callback(client);
775 client->result_cb(client->stt, client->type, (const char**)client->data_list, client->data_count, client->msg, client->result_user_data);
776 stt_client_not_use_callback(client);
777 SLOG(LOG_DEBUG, TAG_STTC, "client result callback called");
779 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
783 if (NULL != client->type)
786 if (NULL != client->data_list) {
788 temp = client->data_list;
791 for (i = 0;i < client->data_count;i++) {
795 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
797 free(client->data_list);
800 if (NULL != client->msg)
803 client->data_count = 0;
808 static Eina_Bool __stt_notify_state_changed(void *data)
810 stt_h stt = (stt_h)data;
812 stt_client_s* client = stt_client_get(stt);
815 if (NULL == client) {
816 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
820 if (NULL != client->state_changed_cb) {
821 stt_client_use_callback(client);
822 client->state_changed_cb(client->stt, client->before_state, client->current_state, client->state_changed_user_data);
823 stt_client_not_use_callback(client);
824 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
826 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
832 int __stt_cb_result(int uid, const char* type, const char** data, int data_count, const char* msg)
834 stt_client_s* client = NULL;
836 client = stt_client_get_by_uid(uid);
837 if (NULL == client) {
838 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
842 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
845 for (i = 0;i < data_count;i++) {
847 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
850 if (NULL != client->result_cb) {
851 client->type = strdup(type);
852 client->msg = strdup(msg);
853 client->data_count = data_count;
855 if (data_count > 0) {
857 temp = malloc( sizeof(char*) * data_count);
859 for (i = 0;i < data_count;i++) {
861 temp[i] = strdup(data[i]);
863 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
866 client->data_list = temp;
869 ecore_timer_add(0, __stt_notify_result, client->stt);
871 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
874 client->before_state = client->current_state;
875 client->current_state = STT_STATE_READY;
877 if (NULL != client->state_changed_cb) {
878 ecore_timer_add(0, __stt_notify_state_changed, client->stt);
880 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
886 static Eina_Bool __stt_notify_partial_result(void *data)
888 stt_h stt = (stt_h)data;
890 stt_client_s* client = stt_client_get(stt);
893 if (NULL == client) {
894 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
898 if (client->partial_result_cb) {
899 stt_client_use_callback(client);
900 client->partial_result_cb(client->stt, client->partial_result, client->partial_result_user_data);
901 stt_client_not_use_callback(client);
902 SLOG(LOG_DEBUG, TAG_STTC, "Partial result callback is called");
904 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Partial result callback is null");
907 if (NULL != client->partial_result)
908 free(client->partial_result);
913 int __stt_cb_partial_result(int uid, const char* data)
915 stt_client_s* client = NULL;
917 client = stt_client_get_by_uid(uid);
918 if (NULL == client) {
919 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
923 if (client->current_state == STT_STATE_READY) {
924 SLOG(LOG_ERROR, TAG_STTC, "Current state has already been 'Ready' state");
928 if (client->partial_result_cb) {
929 client->partial_result = strdup(data);
930 ecore_timer_add(0, __stt_notify_partial_result, client->stt);
932 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Partial result callback is null");
938 int __stt_cb_set_state(int uid, int state)
940 stt_client_s* client = stt_client_get_by_uid(uid);
941 if( NULL == client ) {
942 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
946 stt_state_e state_from_daemon = (stt_state_e)state;
948 if (client->current_state == state_from_daemon) {
949 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
953 client->before_state = client->current_state;
954 client->current_state = state_from_daemon;
956 ecore_timer_add(0, __stt_notify_state_changed, client->stt);
960 int stt_set_result_cb(stt_h stt, stt_result_cb callback, void* user_data)
962 if (stt == NULL || callback == NULL)
963 return STT_ERROR_INVALID_PARAMETER;
965 stt_client_s* client = stt_client_get(stt);
968 if (NULL == client) {
969 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
970 return STT_ERROR_INVALID_PARAMETER;
973 if (STT_STATE_CREATED != client->current_state) {
974 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
975 return STT_ERROR_INVALID_STATE;
978 client->result_cb = callback;
979 client->result_user_data = user_data;
984 int stt_unset_result_cb(stt_h stt)
987 return STT_ERROR_INVALID_PARAMETER;
989 stt_client_s* client = stt_client_get(stt);
992 if (NULL == client) {
993 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
994 return STT_ERROR_INVALID_PARAMETER;
997 if (STT_STATE_CREATED != client->current_state) {
998 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
999 return STT_ERROR_INVALID_STATE;
1002 client->result_cb = NULL;
1003 client->result_user_data = NULL;
1008 int stt_set_partial_result_cb(stt_h stt, stt_partial_result_cb callback, void* user_data)
1010 if (NULL == stt || NULL == callback)
1011 return STT_ERROR_INVALID_PARAMETER;
1013 stt_client_s* client = stt_client_get(stt);
1016 if (NULL == client) {
1017 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1018 return STT_ERROR_INVALID_PARAMETER;
1021 if (STT_STATE_CREATED != client->current_state) {
1022 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1023 return STT_ERROR_INVALID_STATE;
1026 client->partial_result_cb = callback;
1027 client->partial_result_user_data = user_data;
1032 int stt_unset_partial_result_cb(stt_h stt)
1035 return STT_ERROR_INVALID_PARAMETER;
1037 stt_client_s* client = stt_client_get(stt);
1040 if (NULL == client) {
1041 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1042 return STT_ERROR_INVALID_PARAMETER;
1045 if (STT_STATE_CREATED != client->current_state) {
1046 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1047 return STT_ERROR_INVALID_STATE;
1050 client->partial_result_cb = NULL;
1051 client->partial_result_user_data = NULL;
1056 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1058 if (NULL == stt || NULL == callback)
1059 return STT_ERROR_INVALID_PARAMETER;
1061 stt_client_s* client = stt_client_get(stt);
1064 if (NULL == client) {
1065 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1066 return STT_ERROR_INVALID_PARAMETER;
1069 if (STT_STATE_CREATED != client->current_state) {
1070 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1071 return STT_ERROR_INVALID_STATE;
1074 client->state_changed_cb = callback;
1075 client->state_changed_user_data = user_data;
1080 int stt_unset_state_changed_cb(stt_h stt)
1083 return STT_ERROR_INVALID_PARAMETER;
1085 stt_client_s* client = stt_client_get(stt);
1088 if (NULL == client) {
1089 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1090 return STT_ERROR_INVALID_PARAMETER;
1093 if (STT_STATE_CREATED != client->current_state) {
1094 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1095 return STT_ERROR_INVALID_STATE;
1098 client->state_changed_cb = NULL;
1099 client->state_changed_user_data = NULL;
1105 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1107 if (NULL == stt || NULL == callback)
1108 return STT_ERROR_INVALID_PARAMETER;
1110 stt_client_s* client = stt_client_get(stt);
1113 if (NULL == client) {
1114 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1115 return STT_ERROR_INVALID_PARAMETER;
1118 if (STT_STATE_CREATED != client->current_state) {
1119 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1120 return STT_ERROR_INVALID_STATE;
1123 client->error_cb = callback;
1124 client->error_user_data = user_data;
1129 int stt_unset_error_cb(stt_h stt)
1132 return STT_ERROR_INVALID_PARAMETER;
1134 stt_client_s* client = stt_client_get(stt);
1137 if (NULL == client) {
1138 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1139 return STT_ERROR_INVALID_PARAMETER;
1142 if (STT_STATE_CREATED != client->current_state) {
1143 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state is not 'ready'.");
1144 return STT_ERROR_INVALID_STATE;
1147 client->error_cb = NULL;
1148 client->error_user_data = NULL;
1153 int __get_cmd_line(char *file, char *buf)
1157 fp = fopen(file, "r");
1159 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get command line");
1163 memset(buf, 0, 256);
1164 if (NULL == fgets(buf, 256, fp)) {
1165 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to fget command line");
1174 static bool __stt_is_alive()
1177 struct dirent *entry;
1178 struct stat filestat;
1184 dir = opendir("/proc");
1186 SLOG(LOG_ERROR, TAG_STTC, "process checking is FAILED");
1190 while ((entry = readdir(dir)) != NULL) {
1191 if (0 != lstat(entry->d_name, &filestat))
1194 if (!S_ISDIR(filestat.st_mode))
1197 pid = atoi(entry->d_name);
1198 if (pid <= 0) continue;
1200 sprintf(tempPath, "/proc/%d/cmdline", pid);
1201 if (0 != __get_cmd_line(tempPath, cmdLine)) {
1204 if ( 0 == strncmp(cmdLine, "[stt-daemon]", strlen("[stt-daemon]")) ||
1205 0 == strncmp(cmdLine, "stt-daemon", strlen("stt-daemon")) ||
1206 0 == strncmp(cmdLine, "/usr/bin/stt-daemon", strlen("/usr/bin/stt-daemon"))) {
1207 SLOG(LOG_DEBUG, TAG_STTC, "stt-daemon is ALIVE !! \n");
1212 SLOG(LOG_DEBUG, TAG_STTC, "THERE IS NO stt-daemon !! \n");
1219 static int __check_stt_daemon()
1221 if( TRUE == __stt_is_alive() )
1224 /* fork-exec stt-daemon */
1231 SLOG(LOG_DEBUG, TAG_STTC, "[STT ERROR] fail to create STT-DAEMON \n");
1236 for (i = 0;i < _NSIG;i++)
1239 execl("/usr/bin/stt-daemon", "/usr/bin/stt-daemon", NULL);