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.
18 #include <sys/types.h>
22 #include "tts_client.h"
25 #define MAX_TEXT_COUNT 1000
27 static bool g_is_daemon_started = false;
29 static Ecore_Timer* g_connect_timer = NULL;
31 /* Function definition */
32 static int __tts_check_tts_daemon();
33 static Eina_Bool __tts_notify_state_changed(void *data);
34 static Eina_Bool __tts_notify_error(void *data);
36 int tts_create(tts_h* tts)
38 SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
42 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
43 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
44 SLOG(LOG_DEBUG, TAG_TTSC, " ");
45 return TTS_ERROR_INVALID_PARAMETER;
48 if (0 == tts_client_get_size()) {
49 if (0 != tts_dbus_open_connection()) {
50 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
51 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
52 SLOG(LOG_DEBUG, TAG_TTSC, " ");
53 return TTS_ERROR_OPERATION_FAILED;
57 if (0 != tts_client_new(tts)) {
58 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
59 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
60 SLOG(LOG_DEBUG, TAG_TTSC, " ");
61 return TTS_ERROR_OUT_OF_MEMORY;
64 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
65 SLOG(LOG_DEBUG, TAG_TTSC, " ");
67 return TTS_ERROR_NONE;
70 int tts_destroy(tts_h tts)
72 SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
75 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
76 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
77 SLOG(LOG_DEBUG, TAG_TTSC, " ");
78 return TTS_ERROR_INVALID_PARAMETER;
81 tts_client_s* client = tts_client_get(tts);
85 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
86 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
87 SLOG(LOG_DEBUG, TAG_TTSC, " ");
88 return TTS_ERROR_INVALID_PARAMETER;
91 /* check used callback */
92 if (0 != tts_client_get_use_callback(client)) {
93 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
94 return TTS_ERROR_OPERATION_FAILED;
100 switch (client->current_state) {
101 case TTS_STATE_PAUSED:
102 case TTS_STATE_PLAYING:
103 case TTS_STATE_READY:
104 /* Request Finalize */
105 ret = tts_dbus_request_finalize(client->uid);
107 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request finalize");
109 g_is_daemon_started = false;
110 case TTS_STATE_CREATED:
111 if (NULL != g_connect_timer) {
112 SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
113 ecore_timer_del(g_connect_timer);
116 tts_client_destroy(tts);
120 if (0 == tts_client_get_size()) {
121 if (0 != tts_dbus_close_connection()) {
122 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
126 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
127 SLOG(LOG_DEBUG, TAG_TTSC, " ");
129 return TTS_ERROR_NONE;
132 int tts_set_mode(tts_h tts, tts_mode_e mode)
134 SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
136 tts_client_s* client = tts_client_get(tts);
139 if (NULL == client) {
140 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
141 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
142 SLOG(LOG_DEBUG, TAG_TTSC, " ");
143 return TTS_ERROR_INVALID_PARAMETER;
147 if (client->current_state != TTS_STATE_CREATED) {
148 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
149 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
150 SLOG(LOG_DEBUG, TAG_TTSC, " ");
151 return TTS_ERROR_INVALID_STATE;
154 if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
157 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
158 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
159 SLOG(LOG_DEBUG, TAG_TTSC, " ");
160 return TTS_ERROR_INVALID_PARAMETER;
163 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
164 SLOG(LOG_DEBUG, TAG_TTSC, " ");
166 return TTS_ERROR_NONE;
169 int tts_get_mode(tts_h tts, tts_mode_e* mode)
171 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
173 tts_client_s* client = tts_client_get(tts);
176 if (NULL == client) {
177 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
178 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
179 SLOG(LOG_DEBUG, TAG_TTSC, " ");
180 return TTS_ERROR_INVALID_PARAMETER;
184 if (client->current_state != TTS_STATE_CREATED) {
185 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
186 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
187 SLOG(LOG_DEBUG, TAG_TTSC, " ");
188 return TTS_ERROR_INVALID_STATE;
192 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
193 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
194 SLOG(LOG_DEBUG, TAG_TTSC, " ");
195 return TTS_ERROR_INVALID_PARAMETER;
198 *mode = client->mode;
200 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
201 SLOG(LOG_DEBUG, TAG_TTSC, " ");
203 return TTS_ERROR_NONE;
206 static Eina_Bool __tts_connect_daemon(void *data)
208 SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
210 tts_h tts = (tts_h)data;
212 tts_client_s* client = tts_client_get(tts);
215 if (NULL == client) {
216 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
217 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
218 SLOG(LOG_DEBUG, TAG_TTSC, " ");
223 if (0 != tts_dbus_request_hello()) {
224 if (false == g_is_daemon_started) {
225 g_is_daemon_started = true;
226 __tts_check_tts_daemon();
231 /* do request initialize */
234 ret = tts_dbus_request_initialize(client->uid);
236 if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
237 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found");
239 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
242 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
245 } else if (TTS_ERROR_NONE != ret) {
246 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection");
248 client->reason = TTS_ERROR_TIMED_OUT;
251 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
254 /* success to connect tts-daemon */
257 client->before_state = client->current_state;
258 client->current_state = TTS_STATE_READY;
260 ecore_timer_add(0, __tts_notify_state_changed, (void*)client->tts);
262 g_connect_timer = NULL;
264 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] uid(%d)", client->uid);
266 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
267 SLOG(LOG_DEBUG, TAG_TTSC, " ");
272 int tts_prepare(tts_h tts)
274 SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
276 tts_client_s* client = tts_client_get(tts);
279 if (NULL == client) {
280 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
281 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
282 SLOG(LOG_DEBUG, TAG_TTSC, " ");
283 return TTS_ERROR_INVALID_PARAMETER;
287 if (client->current_state != TTS_STATE_CREATED) {
288 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
289 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
290 SLOG(LOG_DEBUG, TAG_TTSC, " ");
291 return TTS_ERROR_INVALID_STATE;
294 g_connect_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
296 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
297 SLOG(LOG_DEBUG, TAG_TTSC, " ");
299 return TTS_ERROR_NONE;
302 int tts_unprepare(tts_h tts)
304 SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
306 tts_client_s* client = tts_client_get(tts);
309 if (NULL == client) {
310 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
311 return TTS_ERROR_INVALID_PARAMETER;
315 if (client->current_state != TTS_STATE_READY) {
316 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
317 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
318 SLOG(LOG_DEBUG, TAG_TTSC, " ");
319 return TTS_ERROR_INVALID_STATE;
322 int ret = tts_dbus_request_finalize(client->uid);
324 SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to request finalize");
326 g_is_daemon_started = false;
328 client->before_state = client->current_state;
329 client->current_state = TTS_STATE_CREATED;
331 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
333 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
334 SLOG(LOG_DEBUG, TAG_TTSC, " ");
336 return TTS_ERROR_NONE;
339 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
341 SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
343 if (NULL == tts || NULL == callback) {
344 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
345 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
346 SLOG(LOG_DEBUG, TAG_TTSC, " ");
347 return TTS_ERROR_INVALID_PARAMETER;
350 tts_client_s* client = tts_client_get(tts);
353 if (NULL == client) {
354 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
355 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
356 SLOG(LOG_DEBUG, TAG_TTSC, " ");
357 return TTS_ERROR_INVALID_PARAMETER;
360 if (TTS_STATE_READY != client->current_state) {
361 SLOG(LOG_ERROR, TAG_TTSC, "Current state is NOT 'READY'.");
362 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
363 SLOG(LOG_DEBUG, TAG_TTSC, " ");
364 return TTS_ERROR_INVALID_STATE;
368 ret = tts_dbus_request_get_support_voice(client->uid, client->tts, callback, user_data);
370 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
373 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
374 SLOG(LOG_DEBUG, TAG_TTSC, " ");
379 int tts_get_default_voice(tts_h tts, char** lang, tts_voice_type_e* vctype)
381 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
384 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
385 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
386 SLOG(LOG_DEBUG, TAG_TTSC, " ");
387 return TTS_ERROR_INVALID_PARAMETER;
390 tts_client_s* client = tts_client_get(tts);
392 if (NULL == client) {
393 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
394 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
395 SLOG(LOG_DEBUG, TAG_TTSC, " ");
396 return TTS_ERROR_INVALID_PARAMETER;
399 if (TTS_STATE_READY != client->current_state) {
400 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is NOT 'READY'. ");
401 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
402 SLOG(LOG_DEBUG, TAG_TTSC, " ");
403 return TTS_ERROR_INVALID_STATE;
406 /* Request call remote method */
408 ret = tts_dbus_request_get_default_voice(client->uid, lang, vctype );
411 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
414 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
415 SLOG(LOG_DEBUG, TAG_TTSC, " ");
420 int tts_get_max_text_count(tts_h tts, int* count)
422 if (NULL == tts || NULL == count) {
423 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
424 return TTS_ERROR_INVALID_PARAMETER;
427 tts_client_s* client = tts_client_get(tts);
429 if (NULL == client) {
430 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
431 return TTS_ERROR_INVALID_PARAMETER;
434 if (TTS_STATE_READY != client->current_state) {
435 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
436 return TTS_ERROR_INVALID_STATE;
439 *count = MAX_TEXT_COUNT;
441 SLOG(LOG_DEBUG, TAG_TTSC, "[Suceess] Get max text count");
442 return TTS_ERROR_NONE;
445 int tts_get_state(tts_h tts, tts_state_e* state)
447 if (NULL == tts || NULL == state) {
448 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
449 return TTS_ERROR_INVALID_PARAMETER;
452 tts_client_s* client = tts_client_get(tts);
454 if (NULL == client) {
455 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
456 return TTS_ERROR_INVALID_PARAMETER;
459 *state = client->current_state;
462 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break;
463 case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break;
464 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break;
465 case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break;
468 return TTS_ERROR_NONE;
471 int tts_add_text(tts_h tts, const char* text, const char* language, tts_voice_type_e voice_type, tts_speed_e speed, int* utt_id)
473 SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
475 if (NULL == tts || NULL == utt_id) {
476 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
477 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
478 SLOG(LOG_DEBUG, TAG_TTSC, " ");
479 return TTS_ERROR_INVALID_PARAMETER;
482 tts_client_s* client = tts_client_get(tts);
484 if (NULL == client) {
485 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
486 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
487 SLOG(LOG_DEBUG, TAG_TTSC, " ");
488 return TTS_ERROR_INVALID_PARAMETER;
491 if (TTS_STATE_CREATED == client->current_state) {
492 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
493 return TTS_ERROR_INVALID_STATE;
496 /* change default language value */
499 if (NULL == language)
500 temp = strdup("default");
502 temp = strdup(language);
504 client->current_utt_id ++;
505 if (client->current_utt_id == 10000) {
506 client->current_utt_id = 1;
511 ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id);
513 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
516 *utt_id = client->current_utt_id;
521 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
522 SLOG(LOG_DEBUG, TAG_TTSC, " ");
527 int tts_play(tts_h tts)
529 SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
532 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
533 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
534 SLOG(LOG_DEBUG, TAG_TTSC, " ");
535 return TTS_ERROR_INVALID_PARAMETER;
538 tts_client_s* client = tts_client_get(tts);
540 if (NULL == client) {
541 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
542 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
543 SLOG(LOG_DEBUG, TAG_TTSC, " ");
544 return TTS_ERROR_INVALID_PARAMETER;
547 if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
548 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
549 return TTS_ERROR_INVALID_STATE;
553 ret = tts_dbus_request_play(client->uid);
555 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request play : result(%d)", ret);
556 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
557 SLOG(LOG_DEBUG, TAG_TTSC, " ");
561 client->before_state = client->current_state;
562 client->current_state = TTS_STATE_PLAYING;
564 if (NULL != client->state_changed_cb) {
565 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
567 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
570 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
571 SLOG(LOG_DEBUG, TAG_TTSC, " ");
573 return TTS_ERROR_NONE;
577 int tts_stop(tts_h tts)
579 SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
582 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
583 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
584 SLOG(LOG_DEBUG, TAG_TTSC, " ");
585 return TTS_ERROR_INVALID_PARAMETER;
588 tts_client_s* client = tts_client_get(tts);
590 if (NULL == client) {
591 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
592 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
593 SLOG(LOG_DEBUG, TAG_TTSC, " ");
594 return TTS_ERROR_INVALID_PARAMETER;
597 if (TTS_STATE_CREATED == client->current_state) {
598 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
599 return TTS_ERROR_INVALID_STATE;
603 ret = tts_dbus_request_stop(client->uid);
605 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
606 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
607 SLOG(LOG_DEBUG, TAG_TTSC, " ");
611 client->before_state = client->current_state;
612 client->current_state = TTS_STATE_READY;
614 if (NULL != client->state_changed_cb) {
615 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
617 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
620 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
621 SLOG(LOG_DEBUG, TAG_TTSC, " ");
623 return TTS_ERROR_NONE;
627 int tts_pause(tts_h tts)
629 SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
632 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
633 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
634 SLOG(LOG_DEBUG, TAG_TTSC, " ");
635 return TTS_ERROR_INVALID_PARAMETER;
638 tts_client_s* client = tts_client_get(tts);
640 if (NULL == client) {
641 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
642 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
643 SLOG(LOG_DEBUG, TAG_TTSC, " ");
644 return TTS_ERROR_INVALID_PARAMETER;
647 if (TTS_STATE_PLAYING != client->current_state) {
648 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
649 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
650 SLOG(LOG_DEBUG, TAG_TTSC, " ");
651 return TTS_ERROR_INVALID_STATE;
655 ret = tts_dbus_request_pause(client->uid);
657 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request pause : result(%d)", ret);
658 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
659 SLOG(LOG_DEBUG, TAG_TTSC, " ");
663 client->before_state = client->current_state;
664 client->current_state = TTS_STATE_PAUSED;
666 if (NULL != client->state_changed_cb) {
667 ecore_timer_add(0, __tts_notify_state_changed, (void*)tts);
669 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
672 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
673 SLOG(LOG_DEBUG, TAG_TTSC, " ");
675 return TTS_ERROR_NONE;
678 static Eina_Bool __tts_notify_error(void *data)
680 tts_h tts = (tts_h)data;
682 tts_client_s* client = tts_client_get(tts);
685 if (NULL == client) {
686 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
690 if (NULL != client->error_cb) {
691 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
692 tts_client_use_callback(client);
693 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data );
694 tts_client_not_use_callback(client);
696 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
702 int __tts_cb_error(int uid, tts_error_e reason, int utt_id)
704 tts_client_s* client = tts_client_get_by_uid(uid);
706 if (NULL == client) {
707 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
708 return TTS_ERROR_INVALID_PARAMETER;
711 client->utt_id = utt_id;
712 client->reason = reason;
714 /* call callback function */
715 if (NULL != client->error_cb) {
716 ecore_timer_add(0, __tts_notify_error, client->tts);
718 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
724 static Eina_Bool __tts_notify_state_changed(void *data)
726 tts_h tts = (tts_h)data;
728 tts_client_s* client = tts_client_get(tts);
731 if (NULL == client) {
732 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
736 if (NULL != client->state_changed_cb) {
737 tts_client_use_callback(client);
738 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
739 tts_client_not_use_callback(client);
740 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
742 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
748 int __tts_cb_set_state(int uid, int state)
750 tts_client_s* client = tts_client_get_by_uid(uid);
751 if( NULL == client ) {
752 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
756 tts_state_e state_from_daemon = (tts_state_e)state;
758 if (client->current_state == state_from_daemon) {
759 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
763 if (NULL != client->state_changed_cb) {
764 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
766 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
769 client->before_state = client->current_state;
770 client->current_state = state_from_daemon;
775 static Eina_Bool __tts_notify_utt_started(void *data)
777 tts_h tts = (tts_h)data;
779 tts_client_s* client = tts_client_get(tts);
782 if (NULL == client) {
783 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt started : A handle is not valid");
787 if (NULL != client->utt_started_cb) {
788 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
789 tts_client_use_callback(client);
790 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
791 tts_client_not_use_callback(client);
793 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
799 int __tts_cb_utt_started(int uid, int utt_id)
801 tts_client_s* client = tts_client_get_by_uid(uid);
803 if (NULL == client) {
804 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
805 return TTS_ERROR_INVALID_PARAMETER;
808 SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
810 client->utt_id = utt_id;
812 /* call callback function */
813 if (NULL != client->utt_started_cb) {
814 ecore_timer_add(0, __tts_notify_utt_started, client->tts);
816 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
822 static Eina_Bool __tts_notify_utt_completed(void *data)
824 tts_h tts = (tts_h)data;
826 tts_client_s* client = tts_client_get(tts);
829 if (NULL == client) {
830 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt completed : A handle is not valid");
834 if (NULL != client->utt_completeted_cb) {
835 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
836 tts_client_use_callback(client);
837 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
838 tts_client_not_use_callback(client);
840 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
846 int __tts_cb_utt_completed(int uid, int utt_id)
848 tts_client_s* client = tts_client_get_by_uid(uid);
850 if (NULL == client) {
851 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
852 return TTS_ERROR_INVALID_PARAMETER;
855 SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
857 client->utt_id = utt_id;
859 /* call callback function */
860 if (NULL != client->utt_completeted_cb) {
861 ecore_timer_add(0, __tts_notify_utt_completed, client->tts);
863 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
869 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
871 if (NULL == tts || NULL == callback) {
872 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
873 return TTS_ERROR_INVALID_PARAMETER;
876 tts_client_s* client = tts_client_get(tts);
878 if (NULL == client) {
879 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
880 return TTS_ERROR_INVALID_PARAMETER;
883 if (TTS_STATE_CREATED != client->current_state) {
884 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
885 return TTS_ERROR_INVALID_STATE;
888 client->state_changed_cb = callback;
889 client->state_changed_user_data = user_data;
891 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
896 int tts_unset_state_changed_cb(tts_h tts)
899 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
900 return TTS_ERROR_INVALID_PARAMETER;
903 tts_client_s* client = tts_client_get(tts);
905 if (NULL == client) {
906 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
907 return TTS_ERROR_INVALID_PARAMETER;
910 if (TTS_STATE_CREATED != client->current_state) {
911 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
912 return TTS_ERROR_INVALID_STATE;
915 client->state_changed_cb = NULL;
916 client->state_changed_user_data = NULL;
918 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
923 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
925 if (NULL == tts || NULL == callback) {
926 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
927 return TTS_ERROR_INVALID_PARAMETER;
930 tts_client_s* client = tts_client_get(tts);
932 if (NULL == client) {
933 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
934 return TTS_ERROR_INVALID_PARAMETER;
937 if (TTS_STATE_CREATED != client->current_state) {
938 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
939 return TTS_ERROR_INVALID_STATE;
942 client->utt_started_cb = callback;
943 client->utt_started_user_data = user_data;
945 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
950 int tts_unset_utterance_started_cb(tts_h tts)
953 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
954 return TTS_ERROR_INVALID_PARAMETER;
957 tts_client_s* client = tts_client_get(tts);
959 if (NULL == client) {
960 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
961 return TTS_ERROR_INVALID_PARAMETER;
964 if (TTS_STATE_CREATED != client->current_state) {
965 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
966 return TTS_ERROR_INVALID_STATE;
969 client->utt_started_cb = NULL;
970 client->utt_started_user_data = NULL;
972 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
977 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
979 if (NULL == tts || NULL == callback) {
980 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
981 return TTS_ERROR_INVALID_PARAMETER;
984 tts_client_s* client = tts_client_get(tts);
986 if (NULL == client) {
987 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
988 return TTS_ERROR_INVALID_PARAMETER;
991 if (TTS_STATE_CREATED != client->current_state) {
992 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
993 return TTS_ERROR_INVALID_STATE;
996 client->utt_completeted_cb = callback;
997 client->utt_completed_user_data = user_data;
999 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1004 int tts_unset_utterance_completed_cb(tts_h tts)
1007 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1008 return TTS_ERROR_INVALID_PARAMETER;
1011 tts_client_s* client = tts_client_get(tts);
1013 if (NULL == client) {
1014 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1015 return TTS_ERROR_INVALID_PARAMETER;
1018 if (TTS_STATE_CREATED != client->current_state) {
1019 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1020 return TTS_ERROR_INVALID_STATE;
1023 client->utt_completeted_cb = NULL;
1024 client->utt_completed_user_data = NULL;
1026 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1030 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1032 if (NULL == tts || NULL == callback) {
1033 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1034 return TTS_ERROR_INVALID_PARAMETER;
1037 tts_client_s* client = tts_client_get(tts);
1039 if (NULL == client) {
1040 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1041 return TTS_ERROR_INVALID_PARAMETER;
1044 if (TTS_STATE_CREATED != client->current_state) {
1045 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1046 return TTS_ERROR_INVALID_STATE;
1049 client->error_cb = callback;
1050 client->error_user_data = user_data;
1052 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1057 int tts_unset_error_cb(tts_h tts)
1060 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1061 return TTS_ERROR_INVALID_PARAMETER;
1064 tts_client_s* client = tts_client_get(tts);
1066 if (NULL == client) {
1067 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1068 return TTS_ERROR_INVALID_PARAMETER;
1071 if (TTS_STATE_CREATED != client->current_state) {
1072 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1073 return TTS_ERROR_INVALID_STATE;
1076 client->error_cb = NULL;
1077 client->error_user_data = NULL;
1079 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1084 int __get_cmd_line(char *file, char *buf)
1088 fp = fopen(file, "r");
1090 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get command line");
1094 memset(buf, 0, 256);
1095 if (NULL == fgets(buf, 256, fp)) {
1096 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to fget command line");
1104 static bool _tts_is_alive()
1107 struct dirent *entry;
1108 struct stat filestat;
1114 dir = opendir("/proc");
1116 SLOG(LOG_ERROR, TAG_TTSC, "process checking is FAILED");
1120 while ((entry = readdir(dir)) != NULL) {
1121 if (0 != lstat(entry->d_name, &filestat))
1124 if (!S_ISDIR(filestat.st_mode))
1127 pid = atoi(entry->d_name);
1128 if (pid <= 0) continue;
1130 sprintf(tempPath, "/proc/%d/cmdline", pid);
1131 if (0 != __get_cmd_line(tempPath, cmdLine)) {
1135 if ( 0 == strncmp(cmdLine, "[tts-daemon]", strlen("[tts-daemon]")) ||
1136 0 == strncmp(cmdLine, "tts-daemon", strlen("tts-daemon")) ||
1137 0 == strncmp(cmdLine, "/usr/bin/tts-daemon", strlen("/usr/bin/tts-daemon"))) {
1138 SLOG(LOG_DEBUG, TAG_TTSC, "tts-daemon is ALIVE !!");
1144 SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO tts-daemon !!");
1150 static int __tts_check_tts_daemon()
1152 if (TRUE == _tts_is_alive()) {
1156 /* fork-exec tts-daemom */
1163 SLOG(LOG_ERROR, TAG_TTSC, "Fail to create tts-daemon");
1168 for (i = 0;i < _NSIG;i++)
1171 execl("/usr/bin/tts-daemon", "/usr/bin/tts-daemon", NULL);