From af44daf564960ed74bc1f6b1be5d6842abdce321 Mon Sep 17 00:00:00 2001 From: Dongyeol Lee Date: Tue, 21 Aug 2012 17:37:12 +0900 Subject: [PATCH] Update tts for tizen 2.0 beta --- client/tts.c | 469 +++++++++++++++++++++++++++++++++------------ client/tts.h | 134 ++++++++----- client/tts_client.c | 9 +- client/tts_client.h | 11 +- client/tts_dbus.c | 102 ++++++---- client/tts_dbus.h | 2 +- client/tts_main.h | 2 +- client/tts_setting.c | 131 ++++++++++--- client/tts_setting.h | 28 ++- client/tts_setting_dbus.c | 4 +- client/tts_setting_dbus.h | 2 +- common/tts_defs.h | 19 +- debian/changelog | 294 +++++++++++++++++++++++++++- debian/copyright | 12 -- debian/libtts.install.in | 1 + debian/rules | 0 packaging/tts.spec | 3 +- server/CMakeLists.txt | 4 +- server/ttsd.conf | 3 + server/ttsd_config.c | 261 ++++++++++++------------- server/ttsd_config.h | 36 +--- server/ttsd_data.cpp | 117 +++++++++-- server/ttsd_data.h | 42 ++-- server/ttsd_dbus.c | 139 +++++++------- server/ttsd_dbus.h | 8 +- server/ttsd_dbus_server.c | 60 ------ server/ttsd_dbus_server.h | 8 - server/ttsd_engine_agent.c | 56 +++--- server/ttsd_main.c | 4 + server/ttsd_main.h | 2 + server/ttsd_network.c | 6 +- server/ttsd_player.cpp | 65 ++++--- server/ttsd_server.cpp | 388 +++++++++++++++++++++---------------- server/ttsd_server.h | 11 +- 34 files changed, 1577 insertions(+), 856 deletions(-) delete mode 100644 debian/copyright mode change 100755 => 100644 debian/rules create mode 100644 server/ttsd.conf diff --git a/client/tts.c b/client/tts.c index 9c1d5e7..e4ccab3 100644 --- a/client/tts.c +++ b/client/tts.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,21 +13,23 @@ #include +#include #include "tts_main.h" #include "tts_client.h" #include "tts_dbus.h" #define MAX_TEXT_COUNT 1000 -#define CONNECTION_RETRY_COUNT 2 + +static bool g_is_daemon_started = false; /* Function definition */ -int __tts_check_tts_daemon(); +static int __tts_check_tts_daemon(); +static Eina_Bool __tts_notify_state_changed(void *data); +static Eina_Bool __tts_notify_error(void *data); int tts_create(tts_h* tts) { - int ret = 0; - SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS"); /* check param */ @@ -47,11 +49,6 @@ int tts_create(tts_h* tts) } } - /* Send hello */ - if (0 != tts_dbus_request_hello()) { - __tts_check_tts_daemon(); - } - if (0 != tts_client_new(tts)) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); @@ -59,34 +56,6 @@ int tts_create(tts_h* tts) return TTS_ERROR_OUT_OF_MEMORY; } - /* do request initialize */ - int i = 1; - while(1) { - ret = tts_dbus_request_initialize((*tts)->handle); - - if (TTS_ERROR_ENGINE_NOT_FOUND == ret) { - tts_client_destroy(*tts); - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found"); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); - SLOG(LOG_DEBUG, TAG_TTSC, " "); - return ret; - } else if (TTS_ERROR_NONE != ret) { - usleep(1); - if (i == CONNECTION_RETRY_COUNT) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection"); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); - SLOG(LOG_DEBUG, TAG_TTSC, " "); - return TTS_ERROR_TIMED_OUT; - } - i++; - } else { - /* success to connect tts-daemon */ - break; - } - } - - SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] uid(%d)", (*tts)->handle); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -114,18 +83,27 @@ int tts_destroy(tts_h tts) return TTS_ERROR_INVALID_PARAMETER; } - /* Request Finalize */ - int ret = tts_dbus_request_finalize(client->uid); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request finalize "); - } - - /* Free resources */ - tts_client_destroy(tts); - + int ret = -1; + + /* check state */ + switch (client->current_state) { + case TTS_STATE_PAUSED: + case TTS_STATE_PLAYING: + case TTS_STATE_READY: + /* Request Finalize */ + ret = tts_dbus_request_finalize(client->uid); + if (0 != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request finalize"); + } + case TTS_STATE_CREATED: + /* Free resources */ + tts_client_destroy(tts); + break; + } + if (0 == tts_client_get_size()) { if (0 != tts_dbus_close_connection()) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection\n "); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection"); } } @@ -135,6 +113,137 @@ int tts_destroy(tts_h tts) return TTS_ERROR_NONE; } +static Eina_Bool __tts_connect_daemon(void *data) +{ + SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon"); + + tts_h tts = (tts_h)data; + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return EINA_FALSE; + } + + /* Send hello */ + if (0 != tts_dbus_request_hello()) { + if (false == g_is_daemon_started) { + g_is_daemon_started = true; + __tts_check_tts_daemon(); + } + return EINA_TRUE; + } + + /* do request initialize */ + int ret = -1; + + ret = tts_dbus_request_initialize(client->uid); + + if (TTS_ERROR_ENGINE_NOT_FOUND == ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found"); + + client->reason = TTS_ERROR_ENGINE_NOT_FOUND; + client->utt_id = -1; + + ecore_timer_add(0, __tts_notify_error, (void*)client->tts); + return EINA_FALSE; + + } else if (TTS_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection"); + + client->reason = TTS_ERROR_TIMED_OUT; + client->utt_id = -1; + + ecore_timer_add(0, __tts_notify_error, (void*)client->tts); + return EINA_FALSE; + } else { + /* success to connect tts-daemon */ + } + + client->before_state = client->current_state; + client->current_state = TTS_STATE_READY; + + ecore_timer_add(0, __tts_notify_state_changed, (void*)client->tts); + + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] uid(%d)", client->uid); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return EINA_FALSE; +} + + +int tts_prepare(tts_h tts) +{ + SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS"); + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available"); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return TTS_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (client->current_state != TTS_STATE_CREATED) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'"); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return TTS_ERROR_INVALID_STATE; + } + + ecore_timer_add(0, __tts_connect_daemon, (void*)tts); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_ERROR_NONE; +} + +int tts_unprepare(tts_h tts) +{ + SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS"); + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available"); + return TTS_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (client->current_state != TTS_STATE_READY) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'"); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return TTS_ERROR_INVALID_STATE; + } + + int ret = tts_dbus_request_finalize(client->uid); + if (0 != ret) { + SLOG(LOG_WARN, TAG_TTSC, "[ERROR] Fail to request finalize"); + } + + client->before_state = client->current_state; + client->current_state = TTS_STATE_CREATED; + + ecore_timer_add(0, __tts_notify_state_changed, (void*)tts); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_ERROR_NONE; +} + int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices"); @@ -258,6 +367,7 @@ int tts_get_state(tts_h tts, tts_state_e* state) *state = client->current_state; switch(*state) { + case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'"); break; case TTS_STATE_READY: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'"); break; case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'"); break; case TTS_STATE_PAUSED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'"); break; @@ -286,6 +396,11 @@ int tts_add_text(tts_h tts, const char* text, const char* language, tts_voice_ty return TTS_ERROR_INVALID_PARAMETER; } + if (TTS_STATE_CREATED == client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'."); + return TTS_ERROR_INVALID_STATE; + } + /* change default language value */ char* temp = NULL; @@ -322,7 +437,7 @@ int tts_play(tts_h tts) SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts"); if (NULL == tts) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null."); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_ERROR_INVALID_PARAMETER; @@ -331,29 +446,35 @@ int tts_play(tts_h tts) tts_client_s* client = tts_client_get(tts); if (NULL == client) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid."); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_PLAYING == client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "Current state is 'playing'. This request should be skipped.\n"); + if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid."); return TTS_ERROR_INVALID_STATE; } int ret = 0; ret = tts_dbus_request_play(client->uid); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request play : result(%d)", ret); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return ret; } - /* change state */ + client->before_state = client->current_state; client->current_state = TTS_STATE_PLAYING; + if (NULL != client->state_changed_cb) { + ecore_timer_add(0, __tts_notify_state_changed, (void*)tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); + } + SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -381,8 +502,10 @@ int tts_stop(tts_h tts) return TTS_ERROR_INVALID_PARAMETER; } - SLOG(LOG_DEBUG, TAG_TTSC, "change state to ready\n"); - client->current_state = TTS_STATE_READY; + if (TTS_STATE_CREATED == client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'."); + return TTS_ERROR_INVALID_STATE; + } int ret = 0; ret = tts_dbus_request_stop(client->uid); @@ -393,6 +516,15 @@ int tts_stop(tts_h tts) return ret; } + client->before_state = client->current_state; + client->current_state = TTS_STATE_READY; + + if (NULL != client->state_changed_cb) { + ecore_timer_add(0, __tts_notify_state_changed, (void*)tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); + } + SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -421,7 +553,7 @@ int tts_pause(tts_h tts) } if (TTS_STATE_PLAYING != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "Error : Current state is NOT 'playing'. So this request should be not running.\n"); + SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running."); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_ERROR_INVALID_STATE; @@ -430,20 +562,51 @@ int tts_pause(tts_h tts) int ret = 0; ret = tts_dbus_request_pause(client->uid); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Request pause : result(%d)", ret); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return ret; } + client->before_state = client->current_state; client->current_state = TTS_STATE_PAUSED; + if (NULL != client->state_changed_cb) { + ecore_timer_add(0, __tts_notify_state_changed, (void*)tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); + } + SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_ERROR_NONE; } +static Eina_Bool __tts_notify_error(void *data) +{ + tts_h tts = (tts_h)data; + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error : A handle is not valid"); + return EINA_FALSE; + } + + if (NULL != client->error_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error"); + tts_client_use_callback(client); + client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data ); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error \n"); + } + + return EINA_FALSE; +} + int __tts_cb_error(int uid, tts_error_e reason, int utt_id) { tts_client_s* client = tts_client_get_by_uid(uid); @@ -453,12 +616,12 @@ int __tts_cb_error(int uid, tts_error_e reason, int utt_id) return TTS_ERROR_INVALID_PARAMETER; } + client->utt_id = utt_id; + client->reason = reason; + /* call callback function */ if (NULL != client->error_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error"); - tts_client_use_callback(client); - client->error_cb(client->tts, utt_id, reason, client->error_user_data ); - tts_client_not_use_callback(client); + ecore_timer_add(0, __tts_notify_error, client->tts); } else { SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error \n"); } @@ -466,38 +629,79 @@ int __tts_cb_error(int uid, tts_error_e reason, int utt_id) return 0; } -int __tts_cb_interrupt(int uid, tts_interrupted_code_e code) +static Eina_Bool __tts_notify_state_changed(void *data) { - tts_client_s* client = tts_client_get_by_uid(uid); + tts_h tts = (tts_h)data; + + tts_client_s* client = tts_client_get(tts); + /* check handle */ if (NULL == client) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid"); - return TTS_ERROR_INVALID_PARAMETER; + SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error : A handle is not valid"); + return EINA_FALSE; } - /* change state by interrupt code */ - if (TTS_INTERRUPTED_PAUSED == code) { - SLOG(LOG_DEBUG, TAG_TTSC, "change state to ready"); - client->current_state = TTS_STATE_PAUSED; - } else if (TTS_INTERRUPTED_STOPPED == code) { - SLOG(LOG_DEBUG, TAG_TTSC, "change state to ready"); - client->current_state = TTS_STATE_READY; + if (NULL != client->state_changed_cb) { + tts_client_use_callback(client); + client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data); + tts_client_not_use_callback(client); + SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called"); } else { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Interrupt code is not available"); + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); + } + + return EINA_FALSE; +} + +int __tts_cb_set_state(int uid, int state) +{ + tts_client_s* client = tts_client_get_by_uid(uid); + if( NULL == client ) { + SLOG(LOG_ERROR, TAG_TTSC, "Handle not found"); return -1; } - /* call callback function */ - if (NULL != client->interrupted_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of stopped \n"); + tts_state_e state_from_daemon = (tts_state_e)state; + + if (client->current_state == state_from_daemon) { + SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state); + return 0; + } + + if (NULL != client->state_changed_cb) { + ecore_timer_add(0, __tts_notify_state_changed, client->tts); + } else { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null"); + } + + client->before_state = client->current_state; + client->current_state = state_from_daemon; + + return 0; +} + +static Eina_Bool __tts_notify_utt_started(void *data) +{ + tts_h tts = (tts_h)data; + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt started : A handle is not valid"); + return EINA_FALSE; + } + + if (NULL != client->utt_started_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started \n"); tts_client_use_callback(client); - client->interrupted_cb(client->tts, code, client->interrupted_user_data); + client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data); tts_client_not_use_callback(client); } else { - SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of stopped \n"); + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started \n"); } - return 0; + return EINA_FALSE; } int __tts_cb_utt_started(int uid, int utt_id) @@ -511,12 +715,11 @@ int __tts_cb_utt_started(int uid, int utt_id) SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : uttid(%d) \n", utt_id); + client->utt_id = utt_id; + /* call callback function */ if (NULL != client->utt_started_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started \n"); - tts_client_use_callback(client); - client->utt_started_cb(client->tts, utt_id, client->utt_started_user_data); - tts_client_not_use_callback(client); + ecore_timer_add(0, __tts_notify_utt_started, client->tts); } else { SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started \n"); } @@ -524,6 +727,30 @@ int __tts_cb_utt_started(int uid, int utt_id) return 0; } +static Eina_Bool __tts_notify_utt_completed(void *data) +{ + tts_h tts = (tts_h)data; + + tts_client_s* client = tts_client_get(tts); + + /* check handle */ + if (NULL == client) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to notify utt completed : A handle is not valid"); + return EINA_FALSE; + } + + if (NULL != client->utt_completeted_cb) { + SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed \n"); + tts_client_use_callback(client); + client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data); + tts_client_not_use_callback(client); + } else { + SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed \n"); + } + + return EINA_FALSE; +} + int __tts_cb_utt_completed(int uid, int utt_id) { tts_client_s* client = tts_client_get_by_uid(uid); @@ -535,12 +762,11 @@ int __tts_cb_utt_completed(int uid, int utt_id) SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) \n", utt_id); + client->utt_id = utt_id; + /* call callback function */ if (NULL != client->utt_completeted_cb) { - SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed \n"); - tts_client_use_callback(client); - client->utt_completeted_cb(client->tts, utt_id, client->utt_completed_user_data); - tts_client_not_use_callback(client); + ecore_timer_add(0, __tts_notify_utt_completed, client->tts); } else { SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed \n"); } @@ -548,56 +774,56 @@ int __tts_cb_utt_completed(int uid, int utt_id) return 0; } -int tts_set_interrupted_cb(tts_h tts, tts_interrupted_cb callback, void* user_data) +int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data) { if (NULL == tts || NULL == callback) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set interrupted cb : Input parameter is null"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null"); return TTS_ERROR_INVALID_PARAMETER; } tts_client_s* client = tts_client_get(tts); if (NULL == client) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set interrupted cb : A handle is not valid"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid"); return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set interrupted cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } - client->interrupted_cb = callback; - client->interrupted_user_data = user_data; + client->state_changed_cb = callback; + client->state_changed_user_data = user_data; - SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set interrupted cb"); + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb"); return 0; } -int tts_unset_interrupted_cb(tts_h tts) +int tts_unset_state_changed_cb(tts_h tts) { if (NULL == tts) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset interrupted cb : Input parameter is null"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null"); return TTS_ERROR_INVALID_PARAMETER; } tts_client_s* client = tts_client_get(tts); if (NULL == client) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset interrupted cb : A handle is not valid"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid"); return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset interrupted cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } - client->interrupted_cb = NULL; - client->interrupted_user_data = NULL; + client->state_changed_cb = NULL; + client->state_changed_user_data = NULL; - SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset interrupted cb"); + SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb"); return 0; } @@ -616,8 +842,8 @@ int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, v return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -643,8 +869,8 @@ int tts_unset_utterance_started_cb(tts_h tts) return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -670,8 +896,8 @@ int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callbac return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -697,8 +923,8 @@ int tts_unset_utterance_completed_cb(tts_h tts) return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -723,8 +949,8 @@ int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data) return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -750,8 +976,8 @@ int tts_unset_error_cb(tts_h tts) return TTS_ERROR_INVALID_PARAMETER; } - if (TTS_STATE_READY != client->current_state) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'ready'."); + if (TTS_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'."); return TTS_ERROR_INVALID_STATE; } @@ -773,7 +999,7 @@ static bool _tts_is_alive() memset(cmd, '\0', sizeof(char) * 256); if ((fp = popen("ps -eo \"cmd\"", "r")) == NULL) { - SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] popen error \n"); + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] popen error"); return FALSE; } @@ -783,7 +1009,7 @@ static bool _tts_is_alive() if (0 == strncmp(cmd, "[tts-daemon]", strlen("[tts-daemon]")) || 0 == strncmp(cmd, "tts-daemon", strlen("tts-daemon")) || 0 == strncmp(cmd, "/usr/bin/tts-daemon", strlen("/usr/bin/tts-daemon"))) { - SLOG(LOG_DEBUG, TAG_TTSC, "tts-daemon is ALIVE !! \n"); + SLOG(LOG_DEBUG, TAG_TTSC, "tts-daemon is ALIVE !!"); fclose(fp); return TRUE; } @@ -791,7 +1017,7 @@ static bool _tts_is_alive() fclose(fp); - SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO tts-daemon !! \n"); + SLOG(LOG_DEBUG, TAG_TTSC, "THERE IS NO tts-daemon !!"); return FALSE; } @@ -813,7 +1039,7 @@ static void __my_sig_child(int signo, siginfo_t *info, void *data) return; } -int __tts_check_tts_daemon() +static int __tts_check_tts_daemon() { if (TRUE == _tts_is_alive()) return 0; @@ -836,7 +1062,7 @@ int __tts_check_tts_daemon() switch(pid) { case -1: - SLOG(LOG_ERROR, TAG_TTSC, "fail to create TTS-DAEMON \n"); + SLOG(LOG_ERROR, TAG_TTSC, "Fail to create tts-daemon"); break; case 0: @@ -848,7 +1074,6 @@ int __tts_check_tts_daemon() break; default: - sleep(1); break; } diff --git a/client/tts.h b/client/tts.h index 084f956..4a51bdb 100644 --- a/client/tts.h +++ b/client/tts.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -50,42 +50,35 @@ typedef enum { * @brief Enumerations of speaking speed. */ typedef enum { - TTS_SPEED_AUTO, /**< Speed from settings */ - TTS_SPEED_VERY_SLOW, /**< Very slow */ - TTS_SPEED_SLOW, /**< Slow */ - TTS_SPEED_NORMAL, /**< Normal */ - TTS_SPEED_FAST, /**< Fast */ - TTS_SPEED_VERY_FAST /**< Very fast */ + TTS_SPEED_AUTO, /**< Speed from settings */ + TTS_SPEED_VERY_SLOW, /**< Very slow */ + TTS_SPEED_SLOW, /**< Slow */ + TTS_SPEED_NORMAL, /**< Normal */ + TTS_SPEED_FAST, /**< Fast */ + TTS_SPEED_VERY_FAST /**< Very fast */ } tts_speed_e; /** * @brief Enumerations of voice type. */ typedef enum { - TTS_VOICE_TYPE_AUTO, /**< Voice type from settings or auto selection based language */ - TTS_VOICE_TYPE_MALE, /**< Male */ - TTS_VOICE_TYPE_FEMALE, /**< Female */ - TTS_VOICE_TYPE_CHILD, /**< Child */ - TTS_VOICE_TYPE_USER1, /**< Engine defined */ - TTS_VOICE_TYPE_USER2, /**< Engine defined */ - TTS_VOICE_TYPE_USER3 /**< Engine defined */ + TTS_VOICE_TYPE_AUTO, /**< Voice type from settings or auto selection based language */ + TTS_VOICE_TYPE_MALE, /**< Male */ + TTS_VOICE_TYPE_FEMALE, /**< Female */ + TTS_VOICE_TYPE_CHILD, /**< Child */ + TTS_VOICE_TYPE_USER1, /**< Engine defined */ + TTS_VOICE_TYPE_USER2, /**< Engine defined */ + TTS_VOICE_TYPE_USER3 /**< Engine defined */ } tts_voice_type_e; /** -* @brief Enumerations of interrupted code. -*/ -typedef enum { - TTS_INTERRUPTED_PAUSED = 0, /**< The current state be changed #TTS_STATE_PAUSED by the daemon */ - TTS_INTERRUPTED_STOPPED /**< The current state be changed #TTS_STATE_READY by the daemon */ -} tts_interrupted_code_e; - -/** * @brief Enumerations of state. */ typedef enum { - TTS_STATE_READY = 0, /**< 'READY' state */ - TTS_STATE_PLAYING, /**< 'PLAYING' state */ - TTS_STATE_PAUSED /**< 'PAUSED' state*/ + TTS_STATE_CREATED = 0, /**< 'CREATED' state */ + TTS_STATE_READY, /**< 'READY' state */ + TTS_STATE_PLAYING, /**< 'PLAYING' state */ + TTS_STATE_PAUSED /**< 'PAUSED' state*/ }tts_state_e; /** @@ -95,22 +88,22 @@ typedef struct tts_s *tts_h; /** -* @brief Called when the TTS state has changed by the daemon. +* @brief Called when the state of TTS is changed. * * @details If the daemon must stop player because of changing engine and * the daemon must pause player because of other requests, this callback function is called. * * @param[in] tts The handle for TTS -* @param[in] code The interrupt type -* @param[in] user_data The user data passed from the the callback registration function +* @param[in] previous A previous state +* @param[in] current A current state +* @param[in] user_data The user data passed from the callback registration function. * -* @pre An application registers this callback using tts_set_interrupted_cb() to detect interrupts. -* @post If this function is called, the TTS state will be #TTS_STATE_READY or #TTS_STATE_PAUSED. +* @pre An application registers this callback using tts_set_state_changed_cb() to detect changing state. * -* @see tts_set_interrupted_cb() -* @see tts_unset_interrupted_cb() +* @see tts_set_state_changed_cb() +* @see tts_unset_state_changed_cb() */ -typedef void (*tts_interrupted_cb)(tts_h tts, tts_interrupted_code_e code, void* user_data); +typedef void (*tts_state_changed_cb)(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data); /** * @brief Called when utterance has started. @@ -177,17 +170,15 @@ typedef void (*tts_error_cb)(tts_h tts, int utt_id, tts_error_e reason, void* us */ typedef bool(*tts_supported_voice_cb)(tts_h tts, const char* language, tts_voice_type_e voice_type, void* user_data); + /** -* @brief Creates a handle for TTS and connects the daemon. +* @brief Creates a handle for TTS. * * @param[out] tts The handle for TTS * * @return 0 on success, otherwise a negative error value * @retval #TTS_ERROR_NONE Successful -* @retval #TTS_ERROR_TIMED_OUT The daemon is blocked or do not exist -* @retval #TTS_ERROR_ENGINE_NOT_FOUND No available engine \n Engine should be installed * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter -* @retval #TTS_ERROR_OUT_OF_MEMORY Out of memory * * @see tts_destroy() */ @@ -207,6 +198,40 @@ int tts_create(tts_h* tts); int tts_destroy(tts_h tts); /** +* @brief Connects the daemon asynchronously. +* +* @param[in] tts The handle for TTS +* +* @return 0 on success, otherwise a negative error value +* @retval #TTS_ERROR_NONE Successful +* @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter +* @retval #TTS_ERROR_INVALID_STATE Invalid state +* +* @pre The state should be #TTS_STATE_CREATED. +* @post If this function is called, the TTS state will be #TTS_STATE_READY. +* +* @see tts_unprepare() +*/ +int tts_prepare(tts_h tts); + +/** +* @brief Disconnects the daemon. +* +* @param[in] tts The handle for TTS +* +* @return 0 on success, otherwise a negative error value +* @retval #TTS_ERROR_NONE Successful +* @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter +* @retval #STT_ERROR_INVALID_STATE Invalid state +* +* @pre The state should be #TTS_STATE_READY. +* @post If this function is called, the TTS state will be #TTS_STATE_CREATED. +* +* @see tts_prepare() +*/ +int tts_unprepare(tts_h tts); + +/** * @brief Retrieves all supported voices of the current engine using callback function. * * @param[in] tts The handle for TTS @@ -217,6 +242,8 @@ int tts_destroy(tts_h tts); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * @retval #TTS_ERROR_OPERATION_FAILED Operation failure +* +* @pre The state should be #TTS_STATE_READY. * @post This function invokes tts_supported_voice_cb() repeatedly for getting voices. * * @see tts_get_default_voice() @@ -240,6 +267,8 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi * @retval #TTS_ERROR_OUT_OF_MEMORY Out of memory * @retval #TTS_ERROR_OPERATION_FAILED Operation failure * +* @pre The state should be #TTS_STATE_READY. +* * @see tts_foreach_supported_voices() */ int tts_get_default_voice(tts_h tts, char** language, tts_voice_type_e* voice_type); @@ -255,6 +284,8 @@ int tts_get_default_voice(tts_h tts, char** language, tts_voice_type_e* voice_ty * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * @retval #TTS_ERROR_OPERATION_FAILED Operation failure * +* @pre The state should be #TTS_STATE_READY. +* * @see tts_add_text() */ int tts_get_max_text_count(tts_h tts, int* count); @@ -293,6 +324,7 @@ int tts_get_state(tts_h tts, tts_state_e* state); * @retval #TTS_ERROR_OUT_OF_MEMORY Out of memory * @retval #TTS_ERROR_OPERATION_FAILED Operation failure * +* @pre The state should be #TTS_STATE_READY, #TTS_STATE_PLAYING or #TTS_STATE_PAUSED. * @see tts_get_max_text_count() */ 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); @@ -363,7 +395,7 @@ int tts_stop(tts_h tts); int tts_pause(tts_h tts); /** -* @brief Registers a callback function for detecting player interrupted. +* @brief Registers a callback function to be called when TTS state changes. * * @param[in] tts The handle for TTS * @param[in] callback The callback function to register @@ -373,10 +405,12 @@ int tts_pause(tts_h tts); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * -* @see tts_interrupted_cb() -* @see tts_unset_interrupted_cb() +* @pre The state should be #TTS_STATE_CREATED. +* +* @see tts_state_changed_cb() +* @see tts_unset_state_changed_cb() */ -int tts_set_interrupted_cb(tts_h tts, tts_interrupted_cb callback, void* user_data); +int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data); /** * @brief Unregisters the callback function. @@ -387,9 +421,11 @@ int tts_set_interrupted_cb(tts_h tts, tts_interrupted_cb callback, void* user_da * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * -* @see tts_set_interrupted_cb() +* @pre The state should be #TTS_STATE_CREATED. +* +* @see tts_set_state_changed_cb() */ -int tts_unset_interrupted_cb(tts_h tts); +int tts_unset_state_changed_cb(tts_h tts); /** * @brief Registers a callback function for detecting utterance started. @@ -402,6 +438,8 @@ int tts_unset_interrupted_cb(tts_h tts); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_utterance_started_cb() * @see tts_unset_utterance_started_cb() */ @@ -416,6 +454,8 @@ int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, v * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_set_utterance_started_cb() */ int tts_unset_utterance_started_cb(tts_h tts); @@ -431,6 +471,8 @@ int tts_unset_utterance_started_cb(tts_h tts); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_utterance_completed_cb() * @see tts_unset_utterance_completed_cb() */ @@ -445,6 +487,8 @@ int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callbac * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_OUT_OF_MEMORY Out of memory * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_set_utterance_completed_cb() */ int tts_unset_utterance_completed_cb(tts_h tts); @@ -460,6 +504,8 @@ int tts_unset_utterance_completed_cb(tts_h tts); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_error_cb() * @see tts_unset_error_cb() */ @@ -474,6 +520,8 @@ int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data); * @retval #TTS_ERROR_NONE Successful * @retval #TTS_ERROR_INVALID_PARAMETER Invalid parameter * +* @pre The state should be #TTS_STATE_CREATED. +* * @see tts_set_error_cb() */ int tts_unset_error_cb(tts_h tts); diff --git a/client/tts_client.c b/client/tts_client.c index 5b348fc..7179b2a 100644 --- a/client/tts_client.c +++ b/client/tts_client.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -48,8 +48,8 @@ int tts_client_new(tts_h* tts) client->uid = temp->handle; client->current_utt_id = 0; - client->interrupted_cb = NULL; - client->interrupted_user_data = NULL; + client->state_changed_cb = NULL; + client->state_changed_user_data = NULL; client->utt_started_cb = NULL; client->utt_started_user_data = NULL; @@ -59,7 +59,8 @@ int tts_client_new(tts_h* tts) client->error_cb = NULL; client->error_user_data = NULL; - client->current_state = TTS_STATE_READY; + client->before_state = TTS_STATE_CREATED; + client->current_state = TTS_STATE_CREATED; client->cb_ref_count = 0; diff --git a/client/tts_client.h b/client/tts_client.h index 494327e..f1c4740 100644 --- a/client/tts_client.h +++ b/client/tts_client.h @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -31,8 +31,8 @@ typedef struct { int current_utt_id; /* callback info */ - tts_interrupted_cb interrupted_cb; - void* interrupted_user_data; + tts_state_changed_cb state_changed_cb; + void* state_changed_user_data; tts_utterance_started_cb utt_started_cb; void* utt_started_user_data; tts_utterance_completed_cb utt_completeted_cb; @@ -41,10 +41,15 @@ typedef struct { void* error_user_data; /* state */ + tts_state_e before_state; tts_state_e current_state; /* semaphore */ int cb_ref_count; + + /* callback data */ + int utt_id; + int reason; }tts_client_s; int tts_client_new(tts_h* tts); diff --git a/client/tts_dbus.c b/client/tts_dbus.c index d0c6538..e5115ca 100644 --- a/client/tts_dbus.c +++ b/client/tts_dbus.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -16,7 +16,9 @@ #include "tts_main.h" #include "tts_dbus.h" #include "tts_defs.h" +#include "tts_client.h" +#define INIT_WAITING_TIME 5000 #define WAITING_TIME 1000 static Ecore_Fd_Handler* g_fd_handler = NULL; @@ -26,7 +28,7 @@ static DBusConnection* g_conn = NULL; extern int __tts_cb_error(int uid, tts_error_e reason, int utt_id); -extern int __tts_cb_interrupt(int uid, tts_interrupted_code_e code); +extern int __tts_cb_set_state(int uid, int state); extern int __tts_cb_utt_started(int uid, int utt_id); @@ -58,7 +60,47 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle snprintf(if_name, 64, "%s%d", TTS_CLIENT_SERVICE_INTERFACE, getpid()); /* check if the message is a signal from the correct interface and with the correct name */ - if (dbus_message_is_method_call(msg, if_name, TTS_METHOD_UTTERANCE_STARTED)) { + if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_HELLO)) { + SLOG(LOG_DEBUG, TAG_TTSC, "===== Get Hello"); + int uid = 0; + int response = -1; + + dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID); + + if (uid > 0) { + SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get hello : uid(%d) \n", uid); + + /* check uid */ + tts_client_s* client = tts_client_get_by_uid(uid); + if (NULL != client) + response = 1; + else + response = 0; + } else { + SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get hello : invalid uid \n"); + } + + reply = dbus_message_new_method_return(msg); + + if (NULL != reply) { + dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID); + + if (!dbus_connection_send(conn, reply, NULL)) + SLOG(LOG_ERROR, TAG_TTSC, ">>>> tts get hello : fail to send reply"); + else + SLOG(LOG_DEBUG, TAG_TTSC, ">>>> tts get hello : result(%d)", response); + + dbus_connection_flush(conn); + dbus_message_unref(reply); + } else { + SLOG(LOG_ERROR, TAG_TTSC, ">>>> tts get hello : fail to create reply message"); + } + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + } /* TTSD_METHOD_HELLO */ + + else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance started"); int uid, uttid; dbus_message_get_args(msg, &err, @@ -70,19 +112,15 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance started - Get arguments error (%s)\n", err.message); dbus_error_free(&err); } else { - SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance started signal : uid(%d), uttid(%d) \n", uid, uttid); + SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance started message : uid(%d), uttid(%d) \n", uid, uttid); __tts_cb_utt_started(uid, uttid); } - reply = dbus_message_new_method_return(msg); - dbus_connection_send(conn, reply, NULL); - dbus_connection_flush(conn); - dbus_message_unref(reply); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); }/* TTS_SIGNAL_UTTERANCE_STARTED */ - else if (dbus_message_is_method_call(msg, if_name, TTS_METHOD_UTTERANCE_COMPLETED)) { + else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance completed"); int uid, uttid; dbus_message_get_args(msg, &err, @@ -94,46 +132,36 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance completed - Get arguments error (%s)\n", err.message); dbus_error_free(&err); } else { - SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance completed signal : uid(%d), uttid(%d) \n", uid, uttid); + SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance completed message : uid(%d), uttid(%d) \n", uid, uttid); __tts_cb_utt_completed(uid, uttid); } - reply = dbus_message_new_method_return(msg); - dbus_connection_send(conn, reply, NULL); - dbus_connection_flush(conn); - dbus_message_unref(reply); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); }/* TTS_SIGNAL_UTTERANCE_COMPLETED */ - else if (dbus_message_is_method_call(msg, if_name, TTS_METHOD_INTERRUPT)) { - SLOG(LOG_DEBUG, TAG_TTSC, "===== Get interrupt callback"); + else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_SET_STATE)) { + SLOG(LOG_DEBUG, TAG_TTSC, "===== Get state changed callback"); int uid; - int code; + int state; dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, - DBUS_TYPE_INT32, &code, + DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID); if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Stop signal - Get arguments error (%s)\n", err.message); + SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get state change - Get arguments error (%s)", err.message); dbus_error_free(&err); } else { - SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Interrupt signal : uid(%d) , interrupt code(%d)\n", uid, code); - __tts_cb_interrupt(uid, (tts_interrupted_code_e)code); + SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get state change : uid(%d) , state(%d)", uid, state); + __tts_cb_set_state(uid, state); } - reply = dbus_message_new_method_return(msg); - dbus_connection_send(conn, reply, NULL); - dbus_connection_flush(conn); - dbus_message_unref(reply); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); - } /* TTS_SIGNAL_INTERRUPT */ + } /* TTSD_METHOD_SET_STATE */ - else if (dbus_message_is_method_call(msg, if_name, TTS_METHOD_ERROR)) { + else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_ERROR)) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get error callback"); int uid; @@ -154,11 +182,6 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle __tts_cb_error(uid, reason, uttid); } - reply = dbus_message_new_method_return(msg); - dbus_connection_send(conn, reply, NULL); - dbus_connection_flush(conn); - dbus_message_unref(reply); - SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); }/* TTS_SIGNAL_ERROR */ @@ -234,7 +257,7 @@ int tts_dbus_open_connection() int fd = 0; dbus_connection_get_unix_fd(g_conn, &fd); - g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ | ECORE_FD_ERROR | ECORE_FD_WRITE, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL); + g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL); if (NULL == g_fd_handler) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore \n"); @@ -250,6 +273,8 @@ int tts_dbus_close_connection() DBusError err; dbus_error_init(&err); + ecore_main_fd_handler_del(g_fd_handler); + int pid = getpid(); char service_name[64]; @@ -259,7 +284,8 @@ int tts_dbus_close_connection() dbus_bus_release_name (g_conn, service_name, &err); dbus_connection_close(g_conn); - + + g_fd_handler = NULL; g_conn = NULL; return 0; @@ -309,7 +335,7 @@ int tts_dbus_request_hello() DBusMessage* result_msg = NULL; int result = 0; - result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err); + result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err); dbus_message_unref(msg); @@ -359,7 +385,7 @@ int tts_dbus_request_initialize(int uid) DBusMessage* result_msg; int result = TTS_ERROR_OPERATION_FAILED; - result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err); + result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, INIT_WAITING_TIME, &err); dbus_message_unref(msg); if (dbus_error_is_set(&err)) diff --git a/client/tts_dbus.h b/client/tts_dbus.h index 89ce20e..73ab1e6 100644 --- a/client/tts_dbus.h +++ b/client/tts_dbus.h @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/client/tts_main.h b/client/tts_main.h index 9198a80..5f07ccc 100644 --- a/client/tts_main.h +++ b/client/tts_main.h @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/client/tts_setting.c b/client/tts_setting.c index 86a38e3..5afadba 100644 --- a/client/tts_setting.c +++ b/client/tts_setting.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,24 +13,73 @@ #include +#include #include "tts_main.h" #include "tts_setting.h" #include "tts_setting_dbus.h" -#define CONNECTION_RETRY_COUNT 2 - -static bool g_is_setting_initialized = false; +static bool g_is_daemon_started = false; static int __check_tts_daemon(); +static tts_setting_state_e g_state = TTS_SETTING_STATE_NONE; + +static tts_setting_initialized_cb g_initialized_cb; +static void* g_user_data; + +static int g_reason; /* API Implementation */ +static Eina_Bool __tts_setting_initialized(void *data) +{ + g_initialized_cb(g_state, g_reason, g_user_data); + + return EINA_FALSE; +} + +static Eina_Bool __tts_setting_connect_daemon(void *data) +{ + /* Send hello */ + if (0 != tts_setting_dbus_request_hello()) { + if (false == g_is_daemon_started) { + g_is_daemon_started = true; + __check_tts_daemon(); + } + return EINA_TRUE; + } + + SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon"); + + /* do request initialize */ + int ret = -1; + + ret = tts_setting_dbus_request_initialize(); + + if (TTS_SETTING_ERROR_ENGINE_NOT_FOUND == ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found"); + } else if (TTS_SETTING_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connection : %d", ret); + } else { + /* success to connect tts-daemon */ + g_state = TTS_SETTING_STATE_READY; + } + + g_reason = ret; + + ecore_timer_add(0, __tts_setting_initialized, NULL); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return EINA_FALSE; +} + int tts_setting_initialize() { SLOG(LOG_DEBUG, TAG_TTSC, "===== Initialize TTS Setting"); - if (true == g_is_setting_initialized) { + if (TTS_SETTING_STATE_READY == g_state) { SLOG(LOG_WARN, TAG_TTSC, "[WARNING] TTS Setting has already been initialized. \n"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -43,7 +92,7 @@ int tts_setting_initialize() SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_SETTING_ERROR_OPERATION_FAILED; } - + /* Send hello */ if (0 != tts_setting_dbus_request_hello()) { __check_tts_daemon(); @@ -59,8 +108,8 @@ int tts_setting_initialize() SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine not found"); break; } else if(ret) { - usleep(1); - if (i == CONNECTION_RETRY_COUNT) { + sleep(1); + if (i == 3) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Connection Time out"); ret = TTS_SETTING_ERROR_TIMED_OUT; break; @@ -73,7 +122,7 @@ int tts_setting_initialize() } if (TTS_SETTING_ERROR_NONE == ret) { - g_is_setting_initialized = true; + g_state = TTS_SETTING_STATE_READY; SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Initialize"); } @@ -83,16 +132,45 @@ int tts_setting_initialize() return ret; } +int tts_setting_initialize_async(tts_setting_initialized_cb callback, void* user_data) +{ + SLOG(LOG_DEBUG, TAG_TTSC, "===== Initialize TTS Setting"); + + if (TTS_SETTING_STATE_READY == g_state) { + SLOG(LOG_WARN, TAG_TTSC, "[WARNING] TTS Setting has already been initialized. \n"); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return TTS_SETTING_ERROR_NONE; + } + + if( 0 != tts_setting_dbus_open_connection() ) { + SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open connection\n "); + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + return TTS_SETTING_ERROR_OPERATION_FAILED; + } + + g_initialized_cb = callback; + g_user_data = user_data; + + ecore_timer_add(0, __tts_setting_connect_daemon, NULL); + + SLOG(LOG_DEBUG, TAG_TTSC, "====="); + SLOG(LOG_DEBUG, TAG_TTSC, " "); + + return TTS_SETTING_ERROR_NONE; +} + int tts_setting_finalize() { SLOG(LOG_DEBUG, TAG_TTSC, "===== Finalize TTS Setting"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); - return TTS_SETTING_ERROR_NONE; + return TTS_SETTING_ERROR_INVALID_STATE; } int ret = tts_setting_dbus_request_finalilze(); @@ -110,7 +188,7 @@ int tts_setting_finalize() SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Finalize"); } - g_is_setting_initialized = false; + g_state = TTS_SETTING_STATE_NONE; SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -122,7 +200,7 @@ int tts_setting_foreach_supported_engines(tts_setting_supported_engine_cb callba { SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported engines"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -153,7 +231,7 @@ int tts_setting_get_engine(char** engine_id) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get current engine"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -184,7 +262,7 @@ int tts_setting_set_engine(const char* engine_id) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Set current engine"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -215,7 +293,7 @@ int tts_setting_foreach_surpported_voices(tts_setting_supported_voice_cb callbac { SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -247,7 +325,7 @@ int tts_setting_get_default_voice(char** language, tts_setting_voice_type_e* voi { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -278,7 +356,7 @@ int tts_setting_set_default_voice(const char* language, tts_setting_voice_type_e { SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default voice"); - if (false == g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -292,7 +370,7 @@ int tts_setting_set_default_voice(const char* language, tts_setting_voice_type_e return TTS_SETTING_ERROR_INVALID_PARAMETER; } - if (voice_type < TTS_SETTING_VOICE_TYPE_MALE && TTS_SETTING_VOICE_TYPE_USER3 < voice_type ) { + if (voice_type < TTS_SETTING_VOICE_TYPE_MALE || TTS_SETTING_VOICE_TYPE_USER3 < voice_type ) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid voice type"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -309,7 +387,7 @@ int tts_setting_set_default_voice(const char* language, tts_setting_voice_type_e SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); - return TTS_SETTING_ERROR_NONE; + return ret; } @@ -317,7 +395,7 @@ int tts_setting_get_default_speed(tts_setting_speed_e* speed) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default speed"); - if (!g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -354,14 +432,14 @@ int tts_setting_set_default_speed(tts_setting_speed_e speed) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default speed"); - if (!g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); return TTS_SETTING_ERROR_INVALID_STATE; } - if (speed < TTS_SETTING_SPEED_VERY_SLOW && TTS_SETTING_SPEED_VERY_FAST < speed ) { + if (speed < TTS_SETTING_SPEED_VERY_SLOW || TTS_SETTING_SPEED_VERY_FAST < speed) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid speed"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -385,7 +463,7 @@ int tts_setting_foreach_engine_settings(tts_setting_engine_setting_cb callback, { SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach engine setting"); - if (!g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -416,7 +494,7 @@ int tts_setting_set_engine_setting(const char* key, const char* value) { SLOG(LOG_DEBUG, TAG_TTSC, "===== Set engine setting"); - if (!g_is_setting_initialized) { + if (TTS_SETTING_STATE_NONE == g_state) { SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized"); SLOG(LOG_DEBUG, TAG_TTSC, "====="); SLOG(LOG_DEBUG, TAG_TTSC, " "); @@ -457,7 +535,7 @@ static bool __tts_is_alive() fp = popen("ps", "r"); if (NULL == fp) { - SLOG(LOG_DEBUG, TAG_TTSC, "[TTS SETTING ERROR] popen error \n"); + SLOG(LOG_DEBUG, TAG_TTSC, "[TTS SETTING ERROR] popen error"); return FALSE; } @@ -532,7 +610,6 @@ static int __check_tts_daemon() break; default: - sleep(1); break; } diff --git a/client/tts_setting.h b/client/tts_setting.h index 06e2219..f734af0 100644 --- a/client/tts_setting.h +++ b/client/tts_setting.h @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -67,6 +67,14 @@ typedef enum { TTS_SETTING_VOICE_TYPE_USER3 /**< Engine defined */ } tts_setting_voice_type_e; +/** +* @brief Enumerations of setting state. +*/ +typedef enum { + TTS_SETTING_STATE_NONE = 0, + TTS_SETTING_STATE_READY +} tts_setting_state_e; + /** * @brief Called to get a engine information. * @@ -114,9 +122,21 @@ typedef bool(*tts_setting_supported_voice_cb)(const char* engine_id, const char* */ typedef bool(*tts_setting_engine_setting_cb)(const char* engine_id, const char* key, const char* value, void* user_data); +/** +* @brief Called to initialize setting. +* +* @param[in] state Current state. +* @param[in] reason Error reason. +* @param[in] user_data User data passed from the tts_setting_initialize_async(). +* +* @pre tts_setting_initialize_async() will invoke this callback. +* +* @see tts_setting_initialize_async() +*/ +typedef void(*tts_setting_initialized_cb)(tts_setting_state_e state, tts_setting_error_e reason, void* user_data); /** -* @brief Initialize TTS setting and connect to tts-daemon. +* @brief Initialize TTS setting and connect to tts-daemon asynchronously. * * @return 0 on success, otherwise a negative error value. * @retval #TTS_SETTING_ERROR_NONE Success. @@ -126,7 +146,9 @@ typedef bool(*tts_setting_engine_setting_cb)(const char* engine_id, const char* * * @see tts_setting_finalize() */ -int tts_setting_initialize(void); +int tts_setting_initialize(); + +int tts_setting_initialize_async(tts_setting_initialized_cb callback, void* user_data); /** * @brief finalize tts setting and disconnect to tts-daemon. diff --git a/client/tts_setting_dbus.c b/client/tts_setting_dbus.c index c8c57a5..a0eb8b9 100644 --- a/client/tts_setting_dbus.c +++ b/client/tts_setting_dbus.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -82,6 +82,8 @@ int tts_setting_dbus_close_connection() dbus_bus_release_name(g_conn, service_name, &err); + dbus_connection_close(g_conn); + g_conn = NULL; return 0; diff --git a/client/tts_setting_dbus.h b/client/tts_setting_dbus.h index 3f979ac..90d47bc 100644 --- a/client/tts_setting_dbus.h +++ b/client/tts_setting_dbus.h @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/common/tts_defs.h b/common/tts_defs.h index eae80bb..6787947 100644 --- a/common/tts_defs.h +++ b/common/tts_defs.h @@ -50,11 +50,12 @@ extern "C" { #define TTS_METHOD_STOP "tts_method_stop" #define TTS_METHOD_PAUSE "tts_method_pause" -#define TTS_METHOD_INTERRUPT "tts_method_interrupt" -#define TTS_METHOD_UTTERANCE_STARTED "tts_method_utterance_started" -#define TTS_METHOD_UTTERANCE_COMPLETED "tts_method_utterance_completed" -#define TTS_METHOD_ERROR "tts_method_error" - +#define TTSD_METHOD_HELLO "ttsd_method_hello" +#define TTSD_METHOD_UTTERANCE_STARTED "ttsd_method_utterance_started" +#define TTSD_METHOD_UTTERANCE_COMPLETED "ttsd_method_utterance_completed" +#define TTSD_METHOD_ERROR "ttsd_method_error" +#define TTSD_METHOD_SET_STATE "ttsd_method_set_state" +#define TTSD_METHOD_GET_STATE "ttsd_method_get_state" /****************************************************************************************** * Message Definition for Setting @@ -74,14 +75,6 @@ extern "C" { #define TTS_SETTING_METHOD_GET_ENGINE_SETTING "tts_setting_method_get_engine_setting" #define TTS_SETTING_METHOD_SET_ENGINE_SETTING "tts_setting_method_set_engine_setting" -/****************************************************************************************** -* Message Definition for tts-daemon internal -*******************************************************************************************/ - -#define TTS_METHOD_NEXT_PLAY "tts_method_start_play" -#define TTS_METHOD_NEXT_SYNTHESIS "tts_method_start_synthesis" - - #ifdef __cplusplus } #endif diff --git a/debian/changelog b/debian/changelog index 5c6c90e..23903fa 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,8 +1,294 @@ -tts (0.1.1-1) unstable; urgency=low +tts (0.1.1-37slp2+1) unstable; urgency=low - * 1.0 release. - * Git: pkgs/t/tts - * Tag: tts_0.1.1-1 + * Fix the bug of player BS + * Git: framework/uifw/voice/tts + * Tag: tts_0.1.1-37slp2+1 + + -- Dongyeol Lee Thu, 16 Aug 2012 11:30:47 +0900 + +tts (0.1.1-36slp2+1) unstable; urgency=low + + * Update Setting API for async init + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-36slp2+1 + + -- Dongyeol Lee Mon, 06 Aug 2012 19:30:59 +0900 + +tts (0.1.1-35slp2+1) unstable; urgency=low + + * Remove fd write option of dbus in client lib + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-35slp2+1 + + -- Dongyeol Lee Tue, 31 Jul 2012 10:17:11 +0900 + +tts (0.1.1-34slp2+1) unstable; urgency=low + + * Fix the bug of setting client management + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-34slp2+1 + + -- Dongyeol Lee Tue, 24 Jul 2012 13:47:43 +0900 + +tts (0.1.1-33slp2+1) unstable; urgency=low + + * Update API for async init + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-33slp2+1 + + -- Dongyeol Lee Mon, 04 Jun 2012 19:48:29 +0900 + +tts (0.1.1-32slp2+1) unstable; urgency=low + + * Add config file + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-32slp2+1 + + -- Dongyeol Lee Thu, 24 May 2012 14:50:30 +0900 + +tts (0.1.1-31slp2+1) unstable; urgency=low + + * update config not to depend on VConf + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-31slp2+1 + + -- Dongyeol Lee Fri, 18 May 2012 18:56:19 +0900 + +tts (0.1.1-30slp2+1) unstable; urgency=low + + * fix bug about fork daemon + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-30slp2+1 + + -- Dongyeol Lee Mon, 26 Mar 2012 15:48:37 +0900 + +tts (0.1.1-29slp2+1) unstable; urgency=low + + * udpate changelog + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-29slp2+1 + + -- Dongyeol Lee Mon, 19 Mar 2012 19:20:22 +0900 + +tts (0.1.1-28slp2+1) unstable; urgency=low + + * udpate setting api + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-28slp2+1 -- Dongyeol Lee Mon, 19 Mar 2012 11:37:32 +0900 +tts (0.1.1-27slp2+1) unstable; urgency=low + + * fix IPC bug + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-27slp2+1 + + -- Dongyeol Lee Wed, 14 Mar 2012 16:14:08 +0900 + +tts (0.1.1-26slp2+1) unstable; urgency=low + + * beta release + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-26slp2+1 + + -- Dongyeol Lee Fri, 17 Feb 2012 17:42:12 +0900 + +tts (0.1.1-25slp2+1) unstable; urgency=low + + * fix player bug and update doxygen + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-25slp2+1 + + -- Dongyeol Lee Fri, 17 Feb 2012 10:45:28 +0900 + +tts (0.1.1-24slp2+1) unstable; urgency=low + + * update engine api + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-24slp2+1 + + -- Dongyeol Lee Thu, 05 Jan 2012 15:53:48 +0900 + +tts (0.1.1-23slp2+1) unstable; urgency=low + + * update changelog + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-23slp2+1 + + -- Dongyeol Lee Mon, 19 Dec 2011 13:50:50 +0900 + +tts (0.1.1-22slp2+1) unstable; urgency=low + + * code cleanup and update log + * Git: slp/pkgs/t/tts + * Tag: tts_0.1.1-22slp2+1 + + -- Dongyeol Lee Fri, 16 Dec 2011 15:56:08 +0900 + +tts (0.1.1-21slp2+1) unstable; urgency=low + + * code cleanup and update log + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-21slp2+1 + + -- Dongyeol Lee Tue, 06 Dec 2011 19:01:19 +0900 + +tts (0.1.1-20slp2+1) unstable; urgency=low + + * change boiler plate + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-20slp2+1 + + -- Dongyeol Lee Fri, 02 Dec 2011 10:52:46 +0900 + +tts (0.1.1-19slp2+1) unstable; urgency=low + + * update for connman + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-19slp2+1 + + -- Dongyeol Lee Tue, 29 Nov 2011 16:14:14 +0900 + +tts (0.1.1-18slp2+1) unstable; urgency=low + + * bug fix about unref message + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-18slp2+1 + + -- Dongyeol Lee Wed, 23 Nov 2011 15:34:46 +0900 + +tts (0.1.1-17slp2+1) unstable; urgency=low + + * update API : change sync function and use add_text in 'Play' state + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-17slp2+1 + + -- Dongyeol Lee Wed, 16 Nov 2011 11:28:03 +0900 + +tts (0.1.1-16slp2+1) unstable; urgency=low + + * update Setting API + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-16slp2+1 + + -- Dongyeol Lee Tue, 01 Nov 2011 11:24:58 +0900 + +tts (0.1.1-15slp2+1) unstable; urgency=low + + * update API doxygen and fix bug about initial default voice + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-15slp2+1 + + -- Dongyeol Lee Thu, 27 Oct 2011 11:06:49 +0900 + +tts (0.1.1-14slp2+1) unstable; urgency=low + + * change API for SDK release + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-14slp2+1 + + -- Dongyeol Lee Fri, 21 Oct 2011 16:42:51 +0900 + +tts (0.1.1-13slp2+1) unstable; urgency=low + + * update API's new callback + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-13slp2+1 + + -- Dongyeol Lee Thu, 20 Oct 2011 17:49:13 +0900 + +tts (0.1.1-12slp2+1) unstable; urgency=low + + * update new API for sdk release and change boilerplate + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-12slp2+1 + + -- Dongyeol Lee Wed, 19 Oct 2011 16:31:50 +0900 + +tts (0.1.1-11slp2+1) unstable; urgency=low + + * update bug of prevent and remove dependency of gtk + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-11slp2+1 + + -- Dongyeol Lee Wed, 07 Sep 2011 14:47:34 +0900 + +tts (0.1.1-10slp2+1) unstable; urgency=low + + * update build file + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-10slp2+1 + + -- Dongyeol Lee Tue, 19 Jul 2011 16:15:13 +0900 + +tts (0.1.1-9slp2+1) unstable; urgency=low + + * update build file + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-9slp2+1 + + -- Dongyeol Lee Mon, 18 Jul 2011 10:27:52 +0900 + +tts (0.1.1-8slp2+1) unstable; urgency=low + + * Change IPC and Code Cleanup + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-8slp2+1 + + -- Dongyeol Lee Fri, 15 Jul 2011 18:01:31 +0900 + +tts (0.1.1-7slp2+1) unstable; urgency=low + + * support multi instance + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-7slp2+1 + + -- Dongyeol Lee Fri, 24 Jun 2011 14:36:36 +0900 + +tts (0.1.1-6slp2+1) unstable; urgency=low + + * fix defect from prevent + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-6slp2+1 + + -- Dongyeol Lee Tue, 07 Jun 2011 17:05:49 +0900 + +tts (0.1.1-5slp2+1) unstable; urgency=low + + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-5slp2+1 + + -- Dongyeol Lee Mon, 23 May 2011 15:14:10 +0900 + +tts (0.1.1-4slp2+1) unstable; urgency=low + + * Change API - change error code + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-4slp2+1 + + -- Dongyeol Lee Mon, 23 May 2011 09:00:57 +0900 + +tts (0.1.1-3slp2+1) unstable; urgency=low + + * change control file + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-3slp2+1 + + -- Jae-Yong Lee Mon, 16 May 2011 10:45:01 +0900 + +tts (0.1.1-2slp2+1) unstable; urgency=low + + * Initial Release (change files to unix type). + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-2slp2+1 + + -- Jae-Yong Lee Mon, 16 May 2011 10:11:02 +0900 + +tts (0.1.1-1slp2+1) unstable; urgency=low + + * Initial Release. + * Git: 165.213.180.234:slp/pkgs/t/tts + * Tag: tts_0.1.1-1slp2+1 + + -- Jae-Yong Lee Fri, 13 May 2011 16:15:22 +0900 diff --git a/debian/copyright b/debian/copyright deleted file mode 100644 index 0592e06..0000000 --- a/debian/copyright +++ /dev/null @@ -1,12 +0,0 @@ -Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - - diff --git a/debian/libtts.install.in b/debian/libtts.install.in index 28666bf..dba0b31 100644 --- a/debian/libtts.install.in +++ b/debian/libtts.install.in @@ -1,2 +1,3 @@ @PREFIX@/lib/lib*.so* @PREFIX@/bin/tts-daemon +@PREFIX@/lib/voice/tts/1.0/ttsd.conf \ No newline at end of file diff --git a/debian/rules b/debian/rules old mode 100755 new mode 100644 diff --git a/packaging/tts.spec b/packaging/tts.spec index 3331343..dd094da 100644 --- a/packaging/tts.spec +++ b/packaging/tts.spec @@ -4,7 +4,7 @@ Version: 0.1.1 Release: 1 Group: libs License: Samsung -Source0: tts-0.1.1.tar.gz +Source0: %{name}-%{version}.tar.gz Requires(post): /sbin/ldconfig Requires(postun): /sbin/ldconfig BuildRequires: pkgconfig(glib-2.0) @@ -55,6 +55,7 @@ rm -rf %{buildroot} %files %defattr(-,root,root,-) %{_libdir}/lib*.so +%{_libdir}/voice/tts/1.0/ttsd.conf %{_bindir}/tts-daemon diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 0c4132f..63b5bd3 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -33,7 +33,7 @@ INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/../common") ## Dependent packages ## INCLUDE(FindPkgConfig) pkg_check_modules(pkgs REQUIRED - mm-player mm-common vconf dbus-1 + mm-player vconf mm-common dbus-1 dlog openssl ) @@ -66,3 +66,5 @@ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS}) ## Install ## INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin) INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ttsp.h DESTINATION include) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ttsd.conf DESTINATION lib/voice/tts/1.0) + diff --git a/server/ttsd.conf b/server/ttsd.conf new file mode 100644 index 0000000..3d23424 --- /dev/null +++ b/server/ttsd.conf @@ -0,0 +1,3 @@ +ENGINE_ID 27F277E9-BBC4-4dca-B553-D9884A3CDAA0 +VOICE en_US 2 +SPEED 3 \ No newline at end of file diff --git a/server/ttsd_config.c b/server/ttsd_config.c index 83dce1c..7f4ca59 100644 --- a/server/ttsd_config.c +++ b/server/ttsd_config.c @@ -11,212 +11,189 @@ * limitations under the License. */ - -#include #include "ttsd_main.h" #include "ttsd_config.h" -/* -* tts-daemon config -*/ -int ttsd_config_get_char_type(const char* key, char** value) -{ - if (NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } - - *value = vconf_get_str(key); - if (NULL == *value) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to get char type from config : key(%s)\n", key); - return -1; - } +#define CONFIG_FILE_PATH BASE_DIRECTORY_DOWNLOAD"ttsd.conf" +#define CONFIG_DEFAULT BASE_DIRECTORY_DEFAULT"ttsd.conf" + +#define ENGINE_ID "ENGINE_ID" +#define VOICE "VOICE" +#define SPEED "SPEED" - return 0; -} -int ttsd_config_set_char_type(const char* key, const char* value) +static char* g_engine_id; +static char* g_language; +static int g_vc_type; +static int g_speed; + +int __ttsd_config_save() { - if (NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } + FILE* config_fp; + config_fp = fopen(CONFIG_FILE_PATH, "w+"); - if (0 != vconf_set_str(key, value)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to set char type \n"); + if (NULL == config_fp) { + /* make file and file default */ + SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Fail to load config (engine id)"); return -1; } - return 0; -} + /* Write engine id */ + fprintf(config_fp, "%s %s\n", ENGINE_ID, g_engine_id); -int ttsd_config_get_bool_type(const char* key, bool* value) -{ - if (NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } - - int result ; - if (0 != vconf_get_int(key, &result)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to get bool type config : key(%s)\n", key); - return -1; - } + /* Write voice */ + fprintf(config_fp, "%s %s %d\n", VOICE, g_language, g_vc_type); - *value = (bool) result; + /* Read speed */ + fprintf(config_fp, "%s %d\n", SPEED, g_speed); + + fclose(config_fp); return 0; } -int ttsd_config_set_bool_type(const char* key, const bool value) + +int __ttsd_config_load() { - if (NULL == key) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } - - int result = (int)value; - if (0 != vconf_set_int(key, result)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to set bool type config : key(%s)\n", key); - return -1; - } + FILE* config_fp; + char buf_id[256] = {0}; + char buf_param[256] = {0}; + int int_param = 0; - return 0; -} + config_fp = fopen(CONFIG_FILE_PATH, "r"); -int ttsd_config_get_int_type(const char* key, int* value) -{ - if (NULL == key || NULL == value) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } + if (NULL == config_fp) { + SLOG(LOG_WARN, TAG_TTSD, "[Config WARNING] Not open file(%s)", CONFIG_FILE_PATH); + + config_fp = fopen(CONFIG_DEFAULT, "r"); + if (NULL == config_fp) { + SLOG(LOG_WARN, TAG_TTSD, "[Config WARNING] Not open original config file(%s)", CONFIG_FILE_PATH); + __ttsd_config_save(); + return -1; + } + } - if (0 != vconf_get_int(key, value)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to get bool type config : key(%s)\n", key); + /* Read engine id */ + fscanf(config_fp, "%s %s", buf_id, buf_param); + if (0 == strncmp(ENGINE_ID, buf_id, strlen(ENGINE_ID))) { + g_engine_id = strdup(buf_param); + } else { + fclose(config_fp); + SLOG(LOG_WARN, TAG_TTSD, "[Config WARNING] Fail to load config (engine id)"); + __ttsd_config_save(); return -1; } - return 0; -} - -int ttsd_config_set_int_type(const char* key, const int value) -{ - if (NULL == key) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Input parameter is NULL\n"); - return TTSD_ERROR_INVALID_PARAMETER; - } + /* Read voice */ + fscanf(config_fp, "%s %s %d", buf_id, buf_param, &int_param); + if (0 == strncmp(VOICE, buf_id, strlen(VOICE))) { + g_language = strdup(buf_param); + g_vc_type = int_param; + } else { + fclose(config_fp); + SLOG(LOG_WARN, TAG_TTSD, "[Config WARNING] Fail to load config (voice)"); + __ttsd_config_save(); + return -1; + } - if (0 != vconf_set_int(key, value)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to set int type config : key(%s)\n", key); + /* Read speed */ + fscanf(config_fp, "%s %d", buf_id, &int_param); + if (0 == strncmp(SPEED, buf_id, strlen(SPEED))) { + g_speed = int_param; + } else { + fclose(config_fp); + SLOG(LOG_WARN, TAG_TTSD, "[Config WARNING] Fail to load config (speed)"); + __ttsd_config_save(); return -1; } + SLOG(LOG_DEBUG, TAG_TTSD, "[Config] Load config : engine(%s), voice(%s,%d), speed(%d)", + g_engine_id, g_language, g_vc_type, g_speed); + return 0; } -/* -* interface for engine plug-in -*/ - -int config_make_key_for_engine(const char* engine_id, const char* key, char** out_key) +int ttsd_config_initialize() { - int key_size = strlen(TTSD_CONFIG_PREFIX) + strlen(engine_id) + strlen(key) + 2; /* 2 is '/' and '\0' */ + g_engine_id = NULL; + g_language = NULL; + g_vc_type = 1; + g_speed = 3; - *out_key = (char*) g_malloc0( sizeof(char) * key_size); - - if (*out_key == NULL) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] Not enough memory!! \n"); - return -1; - } else { - snprintf(*out_key, key_size, "%s%s/%s", TTSD_CONFIG_PREFIX, engine_id, key ); - SLOG(LOG_DEBUG, TAG_TTSD, "[Config DEBUG] make key (%s) \n", *out_key); - } + __ttsd_config_load(); return 0; } -int ttsd_config_set_persistent_data(const char* engine_id, const char* key, const char* value) +int ttsd_config_finalize() { - char* vconf_key = NULL; + __ttsd_config_save(); + return 0; +} - if (0 != config_make_key_for_engine(engine_id, key, &vconf_key)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail config_make_key_for_engine()\n"); +int ttsd_config_get_default_engine(char** engine_id) +{ + if (NULL == engine_id) return -1; - } - if (0 != vconf_set_str(vconf_key, value)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to set key, value\n"); - - if(vconf_key != NULL) - g_free(vconf_key); + *engine_id = strdup(g_engine_id); + return 0; +} +int ttsd_config_set_default_engine(const char* engine_id) +{ + if (NULL == engine_id) return -1; - } - - SLOG(LOG_DEBUG, TAG_TTSD, "[Config DEBUG] Set data : key(%s), value(%s) \n", vconf_key, value); - if (vconf_key != NULL) - g_free(vconf_key); + if (NULL != g_engine_id) + free(g_engine_id); + g_engine_id = strdup(engine_id); + __ttsd_config_save(); return 0; } -int ttsd_config_get_persistent_data(const char* engine_id, const char* key, char** value) +int ttsd_config_get_default_voice(char** language, int* type) { - char* vconf_key = NULL; - - if (0 != config_make_key_for_engine(engine_id, key, &vconf_key)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail config_make_key_for_engine()\n"); + if (NULL == language || NULL == type) return -1; - } - char* temp; - temp = vconf_get_str(vconf_key); - if (temp == NULL) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to get value\n"); + *language = strdup(g_language); + *type = g_vc_type; - if(vconf_key != NULL) - g_free(vconf_key); + return 0; +} +int ttsd_config_set_default_voice(const char* language, int type) +{ + if (NULL == language) return -1; - } - - *value = g_strdup(temp); - SLOG(LOG_DEBUG, TAG_TTSD, "[Config DEBUG] Get data : key(%s), value(%s) \n", vconf_key, *value); + if (NULL != g_language) + free(g_language); - if (NULL != vconf_key) - g_free(vconf_key); + g_language = strdup(language); + g_vc_type = type; - if (NULL != temp) - g_free(temp); + __ttsd_config_save(); return 0; } -int ttsd_config_remove_persistent_data(const char* engine_id, const char* key) +int ttsd_config_get_default_speed(int* speed) { - char* vconf_key = NULL; - int result = 0; - - if (0 != config_make_key_for_engine(engine_id, key, &vconf_key)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail config_make_key_for_engine()\n"); + if (NULL == speed) return -1; - } - if( NULL == vconf_key ) - return -1; - - if (0 != vconf_unset(vconf_key)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Config ERROR] fail to remove key\n"); - result = -1; - } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[Config DEBUG] Remove data : key(%s)", vconf_key); - } + *speed = g_speed; - if( vconf_key != NULL ) - g_free(vconf_key); + return 0; +} - return result; +int ttsd_config_set_default_speed(int speed) +{ + g_speed = speed; + __ttsd_config_save(); + return 0; } diff --git a/server/ttsd_config.h b/server/ttsd_config.h index 45e9b89..01c0aa1 100644 --- a/server/ttsd_config.h +++ b/server/ttsd_config.h @@ -15,45 +15,25 @@ #ifndef __TTSD_CONFIG_H_ #define __TTSD_CONFIG_H_ -#include - #ifdef __cplusplus extern "C" { #endif -#define TTSD_CONFIG_PREFIX "db/ttsd/" - -#define CONFIG_KEY_DEFAULT_ENGINE_ID TTSD_CONFIG_PREFIX"engine" -#define CONFIG_KEY_DEFAULT_LANGUAGE TTSD_CONFIG_PREFIX"language" -#define CONFIG_KEY_DEFAULT_VOICE_TYPE TTSD_CONFIG_PREFIX"vctype" -#define CONFIG_KEY_DEFAULT_SPEED TTSD_CONFIG_PREFIX"speed" - -/* -* tts-daemon config -*/ - -int ttsd_config_get_char_type(const char* key, char** value); +int ttsd_config_initialize(); -int ttsd_config_set_char_type(const char* key, const char* value); +int ttsd_config_finalize(); -int ttsd_config_get_bool_type(const char* key, bool* value); +int ttsd_config_get_default_engine(char** engine_id); -int ttsd_config_set_bool_type(const char* key, const bool value); - -int ttsd_config_get_int_type(const char* key, int* value); - -int ttsd_config_set_int_type(const char* key, const int value); - -/* -* interface for engine plug-in -*/ +int ttsd_config_set_default_engine(const char* engine_id); -int ttsd_config_set_persistent_data(const char* engine_id, const char* key, const char* value); +int ttsd_config_get_default_voice(char** language, int* type); -int ttsd_config_get_persistent_data(const char* engine_id, const char* key, char** value); +int ttsd_config_set_default_voice(const char* langauge, int type); -int ttsd_config_remove_persistent_data(const char* engine_id, const char* key); +int ttsd_config_get_default_speed(int* speed); +int ttsd_config_set_default_speed(int speed); #ifdef __cplusplus } diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp index 2d59d88..d031019 100644 --- a/server/ttsd_data.cpp +++ b/server/ttsd_data.cpp @@ -19,6 +19,8 @@ using namespace std; static vector g_app_list; +static vector g_setting_list; + static bool g_mutex_state = false; /* @@ -40,10 +42,25 @@ int __data_show_list() } SLOG(LOG_DEBUG, TAG_TTSD, "-----------------------"); + + SLOG(LOG_DEBUG, TAG_TTSD, "----- setting client list -----"); + + vsize = g_setting_list.size(); + + for (int i=0; i m_wav_data; }app_data_s; +typedef struct { + int pid; +} setting_app_data_s; -int ttsd_data_new_client(const int pid, const int uid); +int ttsd_data_new_client(int pid, int uid); -int ttsd_data_delete_client(const int uid); +int ttsd_data_delete_client(int uid); -int ttsd_data_is_client(const int uid); +int ttsd_data_is_client(int uid); int ttsd_data_get_client_count(); -int ttsd_data_get_pid(const int uid); +int ttsd_data_get_pid(int uid); -int ttsd_data_add_speak_data(const int uid, const speak_data_s data); +int ttsd_data_add_speak_data(int uid, speak_data_s data); -int ttsd_data_get_speak_data(const int uid, speak_data_s* data); +int ttsd_data_get_speak_data(int uid, speak_data_s* data); -int ttsd_data_get_speak_data_size(const int uid); +int ttsd_data_get_speak_data_size(int uid); -int ttsd_data_add_sound_data(const int uid, const sound_data_s data); +int ttsd_data_add_sound_data(int uid, sound_data_s data); -int ttsd_data_get_sound_data(const int uid, sound_data_s* data); +int ttsd_data_get_sound_data(int uid, sound_data_s* data); -int ttsd_data_get_sound_data_size(const int uid); +int ttsd_data_get_sound_data_size(int uid); -int ttsd_data_clear_data(const int uid); +int ttsd_data_clear_data(int uid); -int ttsd_data_get_client_state(const int pid, app_state_e* state); +int ttsd_data_get_client_state(int pid, app_state_e* state); -int ttsd_data_set_client_state(const int pid, const app_state_e state); +int ttsd_data_set_client_state(int pid, app_state_e state); int ttsd_data_get_current_playing(); - typedef bool(*ttsd_data_get_client_cb)(int pid, int uid, app_state_e state, void* user_data); int ttsd_data_foreach_clients(ttsd_data_get_client_cb callback, void* user_data); bool ttsd_data_is_uttid_valid(int uid, int uttid); +int ttsd_data_is_current_playing(); + + +int ttsd_setting_data_add(int pid); + +int ttsd_setting_data_delete(int pid); + +int ttsd_setting_data_is_setting(int pid); + #ifdef __cplusplus } #endif diff --git a/server/ttsd_dbus.c b/server/ttsd_dbus.c index a6fc673..199fa0c 100644 --- a/server/ttsd_dbus.c +++ b/server/ttsd_dbus.c @@ -23,7 +23,63 @@ static DBusConnection* g_conn; -int ttsdc_send_message(int pid, int uid, int uttid, char *method) +static int g_waiting_time = 3000; + +int ttsdc_send_hello(int pid, int uid) +{ + char service_name[64]; + memset(service_name, 0, 64); + snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid); + + char target_if_name[64]; + snprintf(target_if_name, sizeof(target_if_name), "%s%d", TTS_CLIENT_SERVICE_INTERFACE, pid); + + DBusMessage* msg; + + /* create a message & check for errors */ + msg = dbus_message_new_method_call( + service_name, + TTS_CLIENT_SERVICE_OBJECT_PATH, + target_if_name, + TTSD_METHOD_HELLO); + + if (NULL == msg) { + SLOG(LOG_ERROR, TAG_TTSD, "<<<< [Dbus ERROR] Fail to create hello message : uid(%d)", uid); + return -1; + } else { + SLOG(LOG_DEBUG, TAG_TTSD, "<<<< [Dbus] Send hello message : uid(%d)", uid); + } + + dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID); + + DBusError err; + dbus_error_init(&err); + + DBusMessage* result_msg; + int result = -1; + + result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err); + dbus_message_unref(msg); + + if (NULL != result_msg) { + dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID); + + if (dbus_error_is_set(&err)) { + SLOG(LOG_ERROR, TAG_TTSD, ">>>> [Dbus] Get arguments error (%s)", err.message); + dbus_error_free(&err); + result = -1; + } + + dbus_message_unref(result_msg); + } else { + SLOG(LOG_DEBUG, TAG_TTSD, ">>>> [Dbus] Result message is NULL. Client is not available"); + result = 0; + } + + return result; +} + +int ttsdc_send_message(int pid, int uid, int data, char *method) { char service_name[64]; memset(service_name, 0, 64); @@ -44,15 +100,15 @@ int ttsdc_send_message(int pid, int uid, int uttid, char *method) if (NULL == msg) { SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] Fail to create message : type(%s), uid(%d)\n", method, uid); return -1; - } + } - dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID); + dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &data, DBUS_TYPE_INVALID); /* send the message and flush the connection */ if (!dbus_connection_send(g_conn, msg, NULL)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] <<<< send message : Out Of Memory, type(%s), ifname(%s), uid(%d), uttid(%d)", method, target_if_name, uid, uttid); + SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] <<<< send message : Out Of Memory, type(%s), ifname(%s), uid(%d), data(%d)", method, target_if_name, uid, data); } else { - SLOG(LOG_DEBUG, TAG_TTSD, "<<<< send message : type(%s), uid(%d), uttid(%d)", method, uid, uttid); + SLOG(LOG_DEBUG, TAG_TTSD, "<<<< send message : type(%s), uid(%d), data(%d)", method, uid, data); dbus_connection_flush(g_conn); } @@ -64,17 +120,17 @@ int ttsdc_send_message(int pid, int uid, int uttid, char *method) int ttsdc_send_utt_start_message(int pid, int uid, int uttid) { - return ttsdc_send_message(pid, uid, uttid, TTS_METHOD_UTTERANCE_STARTED); + return ttsdc_send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_STARTED); } int ttsdc_send_utt_finish_message(int pid, int uid, int uttid) { - return ttsdc_send_message(pid, uid, uttid, TTS_METHOD_UTTERANCE_COMPLETED); + return ttsdc_send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_COMPLETED); } -int ttsdc_send_interrupt_message(int pid, int uid, ttsd_interrupted_code_e code) +int ttsdc_send_set_state_message(int pid, int uid, int state) { - return ttsdc_send_message(pid, uid, (int)code, TTS_METHOD_INTERRUPT); + return ttsdc_send_message(pid, uid, state, TTSD_METHOD_SET_STATE); } int ttsdc_send_error_message(int pid, int uid, int uttid, int reason) @@ -92,7 +148,7 @@ int ttsdc_send_error_message(int pid, int uid, int uttid, int reason) service_name, TTS_CLIENT_SERVICE_OBJECT_PATH, target_if_name, - TTS_METHOD_ERROR); + TTSD_METHOD_ERROR); if (NULL == msg) { SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] Fail to create error message : uid(%d)\n", uid); @@ -201,13 +257,6 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle else if (dbus_message_is_method_call(msg, TTS_SERVER_SERVICE_INTERFACE, TTS_SETTING_METHOD_SET_ENGINE_SETTING) ) ttsd_dbus_server_setting_set_engine_setting(conn, msg); - - - else if (dbus_message_is_method_call(msg, TTS_SERVER_SERVICE_INTERFACE, TTS_METHOD_NEXT_PLAY)) - ttsd_dbus_server_start_next_play(msg); - - else if (dbus_message_is_method_call(msg, TTS_SERVER_SERVICE_INTERFACE, TTS_METHOD_NEXT_SYNTHESIS)) - ttsd_dbus_server_start_next_synthesis(msg); /* free the message */ @@ -297,59 +346,3 @@ int ttsd_dbus_close_connection() return 0; } - -int ttsd_send_start_next_play_message(int uid) -{ - DBusMessage* msg; - - msg = dbus_message_new_method_call( - TTS_SERVER_SERVICE_NAME, - TTS_SERVER_SERVICE_OBJECT_PATH, - TTS_SERVER_SERVICE_INTERFACE, - TTS_METHOD_NEXT_PLAY); - - if (NULL == msg) { - SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] >>>> Fail to make message for 'start next play'"); - return -1; - } - - dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID); - - if (!dbus_connection_send(g_conn, msg, NULL)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] >>>> Fail to send message for 'start next play'\n"); - return -1; - } - - dbus_connection_flush(g_conn); - dbus_message_unref(msg); - - return 0; -} - -int ttsd_send_start_next_synthesis_message(int uid) -{ - DBusMessage* msg; - - msg = dbus_message_new_method_call( - TTS_SERVER_SERVICE_NAME, - TTS_SERVER_SERVICE_OBJECT_PATH, - TTS_SERVER_SERVICE_INTERFACE, - TTS_METHOD_NEXT_SYNTHESIS); - - if (NULL == msg) { - SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] >>>> Fail to make message for 'start next synthesis'\n"); - return -1; - } - - dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID); - - if (!dbus_connection_send(g_conn, msg, NULL)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Dbus ERROR] >>>> Fail to send message for 'start next synthesis'\n"); - return -1; - } - - dbus_connection_flush(g_conn); - dbus_message_unref(msg); - - return 0; -} diff --git a/server/ttsd_dbus.h b/server/ttsd_dbus.h index a176bcf..a3f293d 100644 --- a/server/ttsd_dbus.h +++ b/server/ttsd_dbus.h @@ -24,17 +24,15 @@ int ttsd_dbus_open_connection(); int ttsd_dbus_close_connection(); +int ttsdc_send_hello(int pid, int uid); + int ttsdc_send_utt_start_message(int pid, int uid, int uttid); int ttsdc_send_utt_finish_message(int pid, int uid, int uttid); int ttsdc_send_error_message(int pid, int uid, int uttid, int reason); -int ttsdc_send_interrupt_message(int pid, int uid, ttsd_interrupted_code_e code); - -int ttsd_send_start_next_play_message(int uid); - -int ttsd_send_start_next_synthesis_message(int uid); +int ttsdc_send_set_state_message(int pid, int uid, int state); #ifdef __cplusplus } diff --git a/server/ttsd_dbus_server.c b/server/ttsd_dbus_server.c index 4837fcc..5a632a6 100644 --- a/server/ttsd_dbus_server.c +++ b/server/ttsd_dbus_server.c @@ -1264,63 +1264,3 @@ int ttsd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessag return 0; } - -/* -* Dbus Server functions for tts daemon intenal -*/ - -int ttsd_dbus_server_start_next_play(DBusMessage* msg) -{ - DBusError err; - dbus_error_init(&err); - - int uid; - - dbus_message_get_args(msg, &err, - DBUS_TYPE_INT32, &uid, - DBUS_TYPE_INVALID); - - SLOG(LOG_DEBUG, TAG_TTSD, ">>>>> TTSD NEXT PLAY"); - - if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_TTSD, "[IN ERROR] ttsd 'start next play' : Get arguments error (%s)\n", err.message); - dbus_error_free(&err); - } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[IN] ttsd 'start next play' : uid(%d) \n", uid); - int ret = ttsd_server_start_next_play(uid); - SLOG(LOG_DEBUG, TAG_TTSD, "[OUT] ttsd 'start next play' : result(%d) \n", ret); - } - - SLOG(LOG_DEBUG, TAG_TTSD, "<<<<<"); - SLOG(LOG_DEBUG, TAG_TTSD, " "); - - return 0; -} - -int ttsd_dbus_server_start_next_synthesis(DBusMessage* msg) -{ - DBusError err; - dbus_error_init(&err); - - int uid; - - dbus_message_get_args(msg, &err, - DBUS_TYPE_INT32, &uid, - DBUS_TYPE_INVALID); - - SLOG(LOG_DEBUG, TAG_TTSD, ">>>>> TTSD NEXT SYNTHESIS"); - - if (dbus_error_is_set(&err)) { - SLOG(LOG_ERROR, TAG_TTSD, "[IN ERROR] ttsd 'start next synthesis' : Get arguments error (%s)\n", err.message); - dbus_error_free(&err); - } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[IN] ttsd 'start next synthesis' : uid(%d) \n", uid); - int ret = ttsd_server_start_next_synthesis(uid); - SLOG(LOG_DEBUG, TAG_TTSD, "[OUT] ttsd 'start next synthesis' : result(%d) \n", ret); - } - - SLOG(LOG_DEBUG, TAG_TTSD, "<<<<<"); - SLOG(LOG_DEBUG, TAG_TTSD, " "); - - return 0; -} \ No newline at end of file diff --git a/server/ttsd_dbus_server.h b/server/ttsd_dbus_server.h index f96bc4a..e876543 100644 --- a/server/ttsd_dbus_server.h +++ b/server/ttsd_dbus_server.h @@ -73,14 +73,6 @@ int ttsd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessag int ttsd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg); -/* -* Dbus Server functions for tts daemon internal -*/ - -int ttsd_dbus_server_start_next_play(DBusMessage* msg); - -int ttsd_dbus_server_start_next_synthesis(DBusMessage* msg); - #ifdef __cplusplus } #endif diff --git a/server/ttsd_engine_agent.c b/server/ttsd_engine_agent.c index c7f9361..06bb623 100644 --- a/server/ttsd_engine_agent.c +++ b/server/ttsd_engine_agent.c @@ -120,17 +120,16 @@ int ttsd_engine_agent_init(synth_result_callback result_cb) g_agent_init = true; - if (0 != ttsd_config_get_char_type(CONFIG_KEY_DEFAULT_LANGUAGE, &(g_cur_engine.default_lang)) && - 0 != ttsd_config_get_int_type(CONFIG_KEY_DEFAULT_VOICE_TYPE, &(g_cur_engine.default_vctype)) ) { - /* Set default voice */ + if (0 != ttsd_config_get_default_voice(&(g_cur_engine.default_lang), &(g_cur_engine.default_vctype))) { SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] There is No default voice in config\n"); + /* Set default voice */ g_cur_engine.default_lang = strdup("en_US"); g_cur_engine.default_vctype = TTSP_VOICE_TYPE_FEMALE; } - if (0 != ttsd_config_get_int_type(CONFIG_KEY_DEFAULT_SPEED, &(g_cur_engine.default_speed))) { + if (0 != ttsd_config_get_default_speed(&(g_cur_engine.default_speed))) { SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] There is No default speed in config\n"); - ttsd_config_set_int_type(CONFIG_KEY_DEFAULT_SPEED, TTSP_SPEED_NORMAL); + ttsd_config_set_default_speed((int)TTSP_SPEED_NORMAL); g_cur_engine.default_speed = TTSP_SPEED_NORMAL; } @@ -169,15 +168,19 @@ int ttsd_engine_agent_release() g_list_free(iter); /* release current engine data */ - if( g_cur_engine.pefuncs != NULL) + if (g_cur_engine.pefuncs != NULL) g_free(g_cur_engine.pefuncs); - if( g_cur_engine.pdfuncs != NULL) + if (g_cur_engine.pdfuncs != NULL) g_free(g_cur_engine.pdfuncs); g_result_cb = NULL; g_agent_init = false; + if (g_cur_engine.default_lang != NULL) + g_free(g_cur_engine.default_lang); + + SLOG(LOG_DEBUG, TAG_TTSD, "[Engine Agent SUCCESS] Release Engine Agent\n"); return 0; @@ -200,7 +203,7 @@ int ttsd_engine_agent_initialize_current_engine() char* cur_engine_uuid = NULL; bool is_get_engineid_from_config = false; - if (0 != ttsd_config_get_char_type(CONFIG_KEY_DEFAULT_ENGINE_ID ,&cur_engine_uuid)) { + if (0 != ttsd_config_get_default_engine(&cur_engine_uuid)) { /*not set current engine */ /*set system default engine*/ GList *iter = NULL; @@ -273,7 +276,7 @@ int ttsd_engine_agent_initialize_current_engine() } if (false == is_get_engineid_from_config) { - if (0 != ttsd_config_set_char_type(CONFIG_KEY_DEFAULT_ENGINE_ID ,cur_engine_uuid)) + if (0 != ttsd_config_set_default_engine(cur_engine_uuid)) SLOG(LOG_ERROR, TAG_TTSD, "[Engine Agent ERROR] fail to set id to config \n"); } @@ -526,6 +529,11 @@ int __internal_set_current_engine(const char* engine_uuid) if (g_cur_engine.engine_name != NULL) g_free(g_cur_engine.engine_name); if (g_cur_engine.engine_path != NULL) g_free(g_cur_engine.engine_path); + if (NULL == data->engine_uuid || NULL == data->engine_name || NULL == data->engine_path) { + SLOG(LOG_ERROR, TAG_TTSD, "[Engine Agent ERROR] __internal_set_current_engine : Engine data is NULL"); + return TTSD_ERROR_OPERATION_FAILED; + } + g_cur_engine.engine_uuid = g_strdup(data->engine_uuid); g_cur_engine.engine_name = g_strdup(data->engine_name); g_cur_engine.engine_path = g_strdup(data->engine_path); @@ -661,9 +669,8 @@ int ttsd_engine_agent_load_current_engine() return TTSD_ERROR_OPERATION_FAILED; } - ttsd_config_set_char_type(CONFIG_KEY_DEFAULT_LANGUAGE, voice->language); - ttsd_config_set_int_type(CONFIG_KEY_DEFAULT_VOICE_TYPE, voice->type); - + ttsd_config_set_default_voice(voice->language, (int)voice->type); + g_cur_engine.default_lang = g_strdup(voice->language); g_cur_engine.default_vctype = voice->type; @@ -1100,10 +1107,9 @@ int ttsd_engine_get_default_voice( char** lang, ttsp_voice_type_e* vctype ) SLOG(LOG_ERROR, TAG_TTSD, "[Engine ERROR] Fail voice is NOT valid "); return TTSD_ERROR_OPERATION_FAILED; } - - ttsd_config_set_char_type(CONFIG_KEY_DEFAULT_LANGUAGE, voice->language); - ttsd_config_set_int_type(CONFIG_KEY_DEFAULT_VOICE_TYPE, voice->type); - + + ttsd_config_set_default_voice(voice->language, (int)voice->type); + if (NULL != g_cur_engine.default_lang) g_free(g_cur_engine.default_lang); @@ -1228,8 +1234,9 @@ int ttsd_engine_setting_set_engine(const char* engine_id) /* roll back to old current engine. */ __internal_set_current_engine(tmp_uuid); - - if( tmp_uuid != NULL ) + ttsd_engine_agent_load_current_engine(); + + if (tmp_uuid != NULL) free(tmp_uuid); return TTSD_ERROR_OPERATION_FAILED; @@ -1248,7 +1255,7 @@ int ttsd_engine_setting_set_engine(const char* engine_id) } /* save engine id to config */ - if (0 != ttsd_config_set_char_type(CONFIG_KEY_DEFAULT_ENGINE_ID, engine_id)) { + if (0 != ttsd_config_set_default_engine(engine_id)) { SLOG(LOG_WARN, TAG_TTSD, "[Engine Agent WARNING] Fail to save engine id to config \n"); } @@ -1348,15 +1355,10 @@ int ttsd_engine_setting_set_default_voice(const char* language, ttsp_voice_type_ g_cur_engine.default_lang = strdup(language); g_cur_engine.default_vctype = vctype; - ret = ttsd_config_set_char_type(CONFIG_KEY_DEFAULT_LANGUAGE, language); + ret = ttsd_config_set_default_voice(language, (int)vctype); if (0 == ret) { - ret = ttsd_config_set_int_type(CONFIG_KEY_DEFAULT_VOICE_TYPE, vctype); - if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Engine Agent ERROR] fail to write default voice to config (%d) \n", ret); - } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d) \n", + SLOG(LOG_DEBUG, TAG_TTSD, "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d) \n", g_cur_engine.default_lang, g_cur_engine.default_vctype); - } } else { SLOG(LOG_ERROR, TAG_TTSD, "[Engine Agent ERROR] fail to write default voice to config (%d) \n", ret); } @@ -1396,7 +1398,7 @@ int ttsd_engine_setting_set_default_speed(const ttsp_speed_e speed) g_cur_engine.default_speed = speed; - if (0 != ttsd_config_set_int_type(CONFIG_KEY_DEFAULT_SPEED, speed)) { + if (0 != ttsd_config_set_default_speed(speed)) { SLOG(LOG_ERROR, TAG_TTSD, "[Engine Agent ERROR] fail to set default speed to config"); } diff --git a/server/ttsd_main.c b/server/ttsd_main.c index 6411921..1930eaf 100644 --- a/server/ttsd_main.c +++ b/server/ttsd_main.c @@ -19,6 +19,8 @@ #include +#define CLIENT_CLEAN_UP_TIME 500 + /* Main of TTS Daemon */ int main() { @@ -47,6 +49,8 @@ int main() return EXIT_FAILURE; } + ecore_timer_add(CLIENT_CLEAN_UP_TIME, ttsd_cleanup_client, NULL); + SLOG(LOG_DEBUG, TAG_TTSD, "[Main] tts-daemon start...\n"); SLOG(LOG_DEBUG, TAG_TTSD, "====="); SLOG(LOG_DEBUG, TAG_TTSD, " "); diff --git a/server/ttsd_main.h b/server/ttsd_main.h index 78becd1..8933868 100644 --- a/server/ttsd_main.h +++ b/server/ttsd_main.h @@ -34,9 +34,11 @@ extern "C" { /* TTS Daemon Define */ #define TAG_TTSD "ttsd" +#define BASE_DIRECTORY_DEFAULT "/usr/lib/voice/tts/1.0/" #define ENGINE_DIRECTORY_DEFAULT "/usr/lib/voice/tts/1.0/engine" #define ENGINE_DIRECTORY_DEFAULT_SETTING "/usr/lib/voice/tts/1.0/setting" +#define BASE_DIRECTORY_DOWNLOAD "/opt/apps/voice/tts/1.0/" #define ENGINE_DIRECTORY_DOWNLOAD "/opt/apps/voice/tts/1.0/engine" #define ENGINE_DIRECTORY_DOWNLOAD_SETTING "/opt/apps/voice/tts/1.0/setting" diff --git a/server/ttsd_network.c b/server/ttsd_network.c index ae46d1f..f9b8a75 100644 --- a/server/ttsd_network.c +++ b/server/ttsd_network.c @@ -58,7 +58,6 @@ int ttsd_network_initialize() vconf_get_int(VCONFKEY_NETWORK_STATUS, &network_status); if(network_status == VCONFKEY_NETWORK_OFF){ - printf("Current network connection is OFF!! \n"); SLOG(LOG_DEBUG, TAG_TTSD, "[Network] Current network connection is OFF."); } else{ @@ -66,14 +65,13 @@ int ttsd_network_initialize() * This is the problem of network connection * Just terminate the application, network f/w will fix the problem automatically. */ - printf("network status is wrong or IP is not set\n"); - printf("network has problem, try again\n"); + SLOG(LOG_WARN, TAG_TTSD, "network status is wrong or IP is not set\n"); + SLOG(LOG_WARN, TAG_TTSD, "network has problem, try again\n"); return -1; } g_is_connected = false; } else { - printf("Current network connection is ON. \n"); SLOG(LOG_DEBUG, TAG_TTSD, "[Network] Current network connection is ON."); g_is_connected = true; diff --git a/server/ttsd_player.cpp b/server/ttsd_player.cpp index 01bafd1..b7a4edf 100644 --- a/server/ttsd_player.cpp +++ b/server/ttsd_player.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include "ttsd_main.h" #include "ttsd_player.h" @@ -199,12 +200,6 @@ int ttsd_player_destroy_instance(int uid) switch (player_state) { case MM_PLAYER_STATE_PLAYING: case MM_PLAYER_STATE_PAUSED: - ret = mm_player_stop(current->player_handle); - if (MM_ERROR_NONE != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Player WARNING] fail mm_player_stop() : %x", ret); - } - /* NO break for unrealize */ - case MM_PLAYER_STATE_READY: ret = mm_player_unrealize(current->player_handle); if (MM_ERROR_NONE != ret) { @@ -213,13 +208,16 @@ int ttsd_player_destroy_instance(int uid) /* NO break for destroy */ case MM_PLAYER_STATE_NULL: - mm_player_destroy(current->player_handle); + ret = mm_player_destroy(current->player_handle); + if (MM_ERROR_NONE != ret) { + SLOG(LOG_ERROR, TAG_TTSD, "[Player ERROR] fail mm_player_destroy() : %x", ret); + } break; default: break; } - + GList *iter = NULL; player_s *data = NULL; @@ -245,6 +243,8 @@ int ttsd_player_destroy_instance(int uid) } } + SLOG(LOG_DEBUG, TAG_TTSD, "[PLAYER Success] Destroy instance"); + return 0; } @@ -340,7 +340,7 @@ int ttsd_player_next_play(int uid) return 0; } } else { - SLOG(LOG_ERROR, TAG_TTSD, "[Player ERROR] Current player do NOT exist"); + SLOG(LOG_WARN, TAG_TTSD, "[Player WARNING] Current player do NOT exist"); return -1; } @@ -354,12 +354,6 @@ int ttsd_player_next_play(int uid) switch (player_state) { case MM_PLAYER_STATE_PLAYING: case MM_PLAYER_STATE_PAUSED: - ret = mm_player_stop(current->player_handle); - if (MM_ERROR_NONE != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Player WARNING] fail mm_player_stop() : %x", ret); - } - /* NO break for unrealize */ - case MM_PLAYER_STATE_READY: ret = mm_player_unrealize(current->player_handle); if (MM_ERROR_NONE != ret) { @@ -431,12 +425,6 @@ int ttsd_player_stop(const int uid) switch (player_state) { case MM_PLAYER_STATE_PLAYING: case MM_PLAYER_STATE_PAUSED: - ret = mm_player_stop(current->player_handle); - if (MM_ERROR_NONE != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Player WARNING] fail mm_player_stop() : %x", ret); - } - /* NO break for unrealize */ - case MM_PLAYER_STATE_READY: ret = mm_player_unrealize(current->player_handle); if (MM_ERROR_NONE != ret) { @@ -536,6 +524,8 @@ int ttsd_player_resume(const int uid) if (MM_ERROR_NONE != ret) { SLOG(LOG_ERROR, TAG_TTSD, "[Player ERROR] fail mm_player_resume() : %d", ret); return -1; + } else { + SLOG(LOG_DEBUG, TAG_TTSD, "[Player] Resume player"); } g_playing_info = current; @@ -611,11 +601,6 @@ int ttsd_player_all_stop() } if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) { - ret = mm_player_stop(data->player_handle); - if (MM_ERROR_NONE != ret) { - SLOG(LOG_WARN, TAG_TTSD, "[player WARNING] fail mm_player_stop() : %x ", ret); - } - /* unrealize player */ ret = mm_player_unrealize(data->player_handle); if (MM_ERROR_NONE != ret) { @@ -636,6 +621,27 @@ int ttsd_player_all_stop() return 0; } +static Eina_Bool __player_next_play(void *data) +{ + SLOG(LOG_DEBUG, TAG_TTSD, "===== PLAYER NEXT PLAY"); + + int* uid = (int*)data; + + SLOG(LOG_DEBUG, TAG_TTSD, "[PLAYER] uid = %d", *uid); + + if (0 != ttsd_player_next_play(*uid)) { + SLOG(LOG_WARN, TAG_TTSD, "[PLAYER WARNING] Fail to play next"); + } + + if (NULL != uid) + free(uid); + + SLOG(LOG_DEBUG, TAG_TTSD, "====="); + SLOG(LOG_DEBUG, TAG_TTSD, " "); + + return EINA_FALSE; +} + static int msg_callback(int message, void *data, void *user_param) { user_data_s* user_data; @@ -769,7 +775,12 @@ static int msg_callback(int message, void *data, void *user_param) SLOG(LOG_ERROR, TAG_TTSD, "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)", pid, uid, utt_id); } - ttsd_send_start_next_play_message(uid); + int* uid_data = (int*) g_malloc0(sizeof(int)); + *uid_data = uid; + + SLOG(LOG_DEBUG, TAG_TTSD, "[PLAYER] uid = %d", *uid_data); + + ecore_timer_add(0, __player_next_play, (void*)uid_data); SLOG(LOG_DEBUG, TAG_TTSD, "====="); SLOG(LOG_DEBUG, TAG_TTSD, " "); diff --git a/server/ttsd_server.cpp b/server/ttsd_server.cpp index 60ae8ec..3bf737d 100644 --- a/server/ttsd_server.cpp +++ b/server/ttsd_server.cpp @@ -11,7 +11,7 @@ * limitations under the License. */ - +#include #include "ttsd_main.h" #include "ttsd_player.h" #include "ttsd_data.h" @@ -30,10 +30,18 @@ typedef struct { } utterance_t; /* If current engine exist */ -static bool g_is_engine; +static bool g_is_engine; /* If engine is running */ -static bool g_is_synthesizing; +static bool g_is_synthesizing; + +/* If the daemon get the result */ +Ecore_Timer* g_timer; +static bool g_is_next_synthesis; + +/* Function definitions */ +int __server_next_synthesis(int uid); + int __server_set_is_synthesizing(bool flag) { @@ -58,38 +66,20 @@ int __server_send_error(int uid, int utt_id, int error_code) return 0; } -int __server_interrupt_client(int org_uid) -{ - int pid = ttsd_data_get_pid(org_uid); - - /* pause player */ - if (0 != ttsd_player_pause(org_uid)) { - SLOG(LOG_WARN, TAG_TTSD, "[Server ERROR] fail to ttsd_player_pause() : uid (%d)\n", org_uid); - } - - /* send message to client about changing state */ - ttsdc_send_interrupt_message (pid, org_uid, TTSD_INTERRUPTED_PAUSED); - - /* change state */ - ttsd_data_set_client_state(org_uid, APP_STATE_PAUSED); - - return 0; -} - -int __server_start_synthesis(int uid) +int __server_start_synthesis(int uid, int mode) { int result = 0; /* check if tts-engine is running */ if (true == __server_get_current_synthesis()) { - SLOG(LOG_DEBUG, TAG_TTSD, "[Server] TTS-engine is running \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server] TTS-engine is running "); } else { speak_data_s sdata; if (0 == ttsd_data_get_speak_data(uid, &sdata)) { utterance_t* utt = (utterance_t*)g_malloc0(sizeof(utterance_t)); if (NULL == utt) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Out of memory : utterance \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Out of memory : utterance "); return TTSD_ERROR_OUT_OF_MEMORY; } @@ -104,7 +94,7 @@ int __server_start_synthesis(int uid) __server_set_is_synthesizing(true); int ret = 0; - ret = ttsd_engine_start_synthesis( sdata.lang, sdata.vctype, sdata.text, sdata.speed, (void*)utt); + ret = ttsd_engine_start_synthesis(sdata.lang, sdata.vctype, sdata.text, sdata.speed, (void*)utt); if (0 != ret) { SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] * FAIL to start SYNTHESIS !!!! * "); @@ -113,6 +103,14 @@ int __server_start_synthesis(int uid) result = TTSD_ERROR_OPERATION_FAILED; g_free(utt); + + if (2 == mode) { + __server_send_error(uid, sdata.utt_id, TTSD_ERROR_OPERATION_FAILED); + ttsd_server_stop(uid); + + int pid = ttsd_data_get_pid(uid); + ttsdc_send_set_state_message(pid, uid, APP_STATE_READY); + } } else { SLOG(LOG_DEBUG, TAG_TTSD, "[Server] SUCCESS to start synthesis"); } @@ -142,16 +140,17 @@ int __server_play_internal(int uid, app_state_e state) /* resume player and start speech synthesis */ if (0 != ttsd_player_resume(uid)) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] fail to ttsd_player_resume() \n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] fail to ttsd_player_resume()"); } - ret = __server_start_synthesis(uid); + /* mode 1 for play */ + ret = __server_start_synthesis(uid, 1); } else if(APP_STATE_READY == state) { - SLOG(LOG_DEBUG, TAG_TTSD, "[Server] uid(%d) is 'Ready' state : Next step is start synthesis ", uid); - - ret = __server_start_synthesis(uid); + + /* mode 1 for play */ + ret = __server_start_synthesis(uid, 1); } else { /* NO this case */ } @@ -174,7 +173,7 @@ int __server_next_synthesis(int uid) } if (true == __server_get_current_synthesis()) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Engine has already been running. \n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Engine has already been running. "); SLOG(LOG_DEBUG, TAG_TTSD, "====="); SLOG(LOG_DEBUG, TAG_TTSD, " "); return 0; @@ -187,7 +186,7 @@ int __server_next_synthesis(int uid) utterance_t* utt = (utterance_t*)g_malloc0(sizeof(utterance_t)); if (NULL == utt) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to allocate memory : utterance \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to allocate memory : utterance "); __server_send_error(current_uid, sdata.utt_id, TTSD_ERROR_OUT_OF_MEMORY); return TTSD_ERROR_OUT_OF_MEMORY; @@ -214,6 +213,11 @@ int __server_next_synthesis(int uid) __server_send_error(current_uid, sdata.utt_id, TTSD_ERROR_OPERATION_FAILED); g_free(utt); + + ttsd_server_stop(current_uid); + + int pid = ttsd_data_get_pid(current_uid); + ttsdc_send_set_state_message(pid, current_uid, APP_STATE_READY); } if(sdata.text != NULL) @@ -221,7 +225,7 @@ int __server_next_synthesis(int uid) } if (0 != ttsd_player_play(current_uid)) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] __synthesis_result_callback : fail ttsd_player_play() \n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] __synthesis_result_callback : fail ttsd_player_play() "); } else { /* success playing */ SLOG(LOG_DEBUG, TAG_TTSD, "[Server] Success to start player"); @@ -245,13 +249,13 @@ int __player_result_callback(player_event_e event, int uid, int utt_id) if (false == __server_get_current_synthesis()) { /* check text queue is empty */ if (0 == ttsd_data_get_speak_data_size(uid) && 0 == ttsd_data_get_sound_data_size(uid)) { - SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER Callback] all play completed \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER Callback] all play completed "); } } break; case PLAYER_ERROR: - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER Callback ERROR] callback : player error \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[SERVER Callback ERROR] callback : player error "); __server_send_error(uid, utt_id, TTSD_ERROR_OPERATION_FAILED); break; @@ -263,9 +267,29 @@ int __player_result_callback(player_event_e event, int uid, int utt_id) return 0; } +Eina_Bool __start_next_synthesis(void *data) +{ + /* get current play */ + int uid = ttsd_data_is_current_playing(); + + if (uid < 0) + return EINA_FALSE; + + if (true == g_is_next_synthesis) { + SLOG(LOG_DEBUG, TAG_TTSD, "===== NEXT SYNTHESIS START"); + __server_next_synthesis(uid); + SLOG(LOG_DEBUG, TAG_TTSD, "===== "); + SLOG(LOG_DEBUG, TAG_TTSD, " "); + + g_is_next_synthesis = false; + } + + return EINA_TRUE; +} + int __synthesis_result_callback(ttsp_result_event_e event, const void* data, unsigned int data_size, void *user_data) { - SLOG(LOG_DEBUG, TAG_TTSD, "===== SYNTHESIS RESULT CALLBACK"); + SLOG(LOG_DEBUG, TAG_TTSD, "===== SYNTHESIS RESULT CALLBACK START"); utterance_t* utt_get_param; utt_get_param = (utterance_t*)user_data; @@ -274,7 +298,7 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns int uttid = utt_get_param->uttid; if (NULL == utt_get_param) { - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] User data is NULL \n" ); + SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] User data is NULL " ); SLOG(LOG_DEBUG, TAG_TTSD, "====="); SLOG(LOG_DEBUG, TAG_TTSD, " "); return -1; @@ -288,7 +312,7 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns if (TTSP_RESULT_EVENT_FINISH == event) SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Event : TTSP_RESULT_EVENT_FINISH"); if (false == ttsd_data_is_uttid_valid(uid, uttid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] uttid is NOT valid !!!! \n" ); + SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] uttid is NOT valid !!!! " ); SLOG(LOG_DEBUG, TAG_TTSD, "====="); SLOG(LOG_DEBUG, TAG_TTSD, " "); @@ -296,7 +320,7 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns } - SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Result Info : uid(%d), utt(%d), data(%p), data size(%d) \n", + SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Result Info : uid(%d), utt(%d), data(%p), data size(%d) ", uid, uttid, data, data_size); /* add wav data */ @@ -324,16 +348,13 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns temp_data.channels = channels; if (0 != ttsd_data_add_sound_data(uid, temp_data)) { - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] Fail to add sound data : uid(%d)\n", utt_get_param->uid); + SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] Fail to add sound data : uid(%d)", utt_get_param->uid); } if (event == TTSP_RESULT_EVENT_FINISH) { __server_set_is_synthesizing(false); - - if (0 != ttsd_send_start_next_synthesis_message(uid)) { - /* critical error */ - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] IPC ERROR FOR NEXT SYNTHESIS \n"); - } + + g_is_next_synthesis = true; } } @@ -341,20 +362,15 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Event : TTSP_RESULT_EVENT_CANCEL"); __server_set_is_synthesizing(false); - if (0 != ttsd_send_start_next_synthesis_message(uid)) { - /* critical error */ - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] IPC ERROR FOR NEXT SYNTHESIS \n"); - } + g_is_next_synthesis = true; } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Event : TTSP_RESULT_EVENT_CANCEL"); + SLOG(LOG_DEBUG, TAG_TTSD, "[SERVER] Event : etc"); __server_set_is_synthesizing(false); - if (0 != ttsd_send_start_next_synthesis_message(uid)) { - /* critical error */ - SLOG(LOG_ERROR, TAG_TTSD, "[SERVER ERROR] IPC ERROR FOR NEXT SYNTHESIS \n"); - } + + g_is_next_synthesis = true; } if (TTSP_RESULT_EVENT_FINISH == event || TTSP_RESULT_EVENT_CANCEL == event || TTSP_RESULT_EVENT_FAIL == event) { @@ -362,7 +378,7 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns free(utt_get_param); } - SLOG(LOG_DEBUG, TAG_TTSD, "====="); + SLOG(LOG_DEBUG, TAG_TTSD, "===== SYNTHESIS RESULT CALLBACK END"); SLOG(LOG_DEBUG, TAG_TTSD, " "); return 0; @@ -374,29 +390,62 @@ int __synthesis_result_callback(ttsp_result_event_e event, const void* data, uns int ttsd_initialize() { + if (ttsd_config_initialize()) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server WARNING] Fail to initialize config."); + } + /* player init */ if (ttsd_player_init(__player_result_callback)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to initialize player init \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to initialize player init."); return TTSD_ERROR_OPERATION_FAILED; } /* Engine Agent initialize */ if (0 != ttsd_engine_agent_init(__synthesis_result_callback)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to engine agent initialize \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to engine agent initialize."); return TTSD_ERROR_OPERATION_FAILED; } /* set current engine */ if (0 != ttsd_engine_agent_initialize_current_engine()) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] No Engine !!! \n" ); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] No Engine !!!" ); g_is_engine = false; } else g_is_engine = true; + g_timer = NULL; + return TTSD_ERROR_NONE; } +bool __get_client_for_clean_up(int pid, int uid, app_state_e state, void* user_data) +{ + int result = 1; + + result = ttsdc_send_hello(pid, uid); + + if (0 == result) { + SLOG(LOG_DEBUG, TAG_TTSD, "[Server] uid(%d) should be removed.", uid); + ttsd_server_finalize(uid); + } else if (-1 == result) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Hello result has error"); + } + + return true; +} + + +Eina_Bool ttsd_cleanup_client(void *data) +{ + SLOG(LOG_DEBUG, TAG_TTSD, "===== CLEAN UP CLIENT START"); + ttsd_data_foreach_clients(__get_client_for_clean_up, NULL); + SLOG(LOG_DEBUG, TAG_TTSD, "====="); + SLOG(LOG_DEBUG, TAG_TTSD, " "); + + return EINA_TRUE; +} + /* * TTS Server Functions for Client */ @@ -405,7 +454,7 @@ int ttsd_server_initialize(int pid, int uid) { if (false == g_is_engine) { if (0 != ttsd_engine_agent_initialize_current_engine()) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] No Engine !!! \n" ); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] No Engine !!! " ); g_is_engine = false; return TTSD_ERROR_ENGINE_NOT_FOUND; @@ -415,24 +464,24 @@ int ttsd_server_initialize(int pid, int uid) } if (-1 != ttsd_data_is_client(uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Uid has already been registered \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Uid has already been registered "); return TTSD_ERROR_INVALID_PARAMETER; } if (0 == ttsd_data_get_client_count()) { if (0 != ttsd_engine_agent_load_current_engine()) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to load current engine \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to load current engine "); return TTSD_ERROR_OPERATION_FAILED; } } if (0 != ttsd_data_new_client(pid, uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to add client info \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to add client info "); return TTSD_ERROR_OPERATION_FAILED; } if (0 != ttsd_player_create_instance(uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to create player \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to create player "); return TTSD_ERROR_OPERATION_FAILED; } @@ -444,7 +493,7 @@ int ttsd_server_finalize(int uid) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_finalize : uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_finalize : uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } @@ -457,9 +506,9 @@ int ttsd_server_finalize(int uid) /* unload engine, if ref count of client is 0 */ if (0 == ttsd_data_get_client_count()) { if (0 != ttsd_engine_agent_unload_current_engine()) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to unload current engine \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to unload current engine "); } else { - SLOG(LOG_DEBUG, TAG_TTSD, "[Server SUCCESS] unload current engine \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server SUCCESS] unload current engine "); } } @@ -470,7 +519,7 @@ int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_add_queue : uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_add_queue : uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } @@ -478,7 +527,7 @@ int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice char* temp_lang = NULL; ttsp_voice_type_e temp_type; if (true != ttsd_engine_select_valid_voice((const char*)lang, (const ttsp_voice_type_e)voice_type, &temp_lang, &temp_type)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to select valid voice \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to select valid voice "); return TTSD_ERROR_INVALID_VOICE; } else { if (NULL == temp_lang) @@ -497,7 +546,7 @@ int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice /* if state is APP_STATE_READY , APP_STATE_PAUSED , only need to add speak data to queue*/ if (0 != ttsd_data_add_speak_data(uid, data)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_add_queue : Current state of uid is not 'ready' \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_add_queue : Current state of uid is not 'ready' "); return TTSD_ERROR_OPERATION_FAILED; } @@ -505,13 +554,14 @@ int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice /* check if engine use network */ if (ttsd_engine_agent_need_network()) { if (false == ttsd_network_is_connected()) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Disconnect network. Current engine needs network.\n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Disconnect network. Current engine needs network."); return TTSD_ERROR_OPERATION_FAILED; } } - if (0 != __server_start_synthesis(uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to schedule synthesis : uid(%d)\n", uid); + /* mode 2 for add text */ + if (0 != __server_start_synthesis(uid, 2)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail to schedule synthesis : uid(%d)", uid); return TTSD_ERROR_OPERATION_FAILED; } } @@ -519,23 +569,36 @@ int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice return TTSD_ERROR_NONE; } +Eina_Bool __send_interrupt_client(void *data) +{ + int* uid = (int*)data; + + if (NULL != uid) { + int pid = ttsd_data_get_pid(*uid); + /* send message to client about changing state */ + ttsdc_send_set_state_message (pid, *uid, APP_STATE_PAUSED); + free(uid); + } + return EINA_FALSE; +} + int ttsd_server_play(int uid) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid(%d) is NOT valid \n", uid); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid(%d) is NOT valid ", uid); return TTSD_ERROR_INVALID_PARAMETER; } if (APP_STATE_PLAYING == state) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state(%d) is 'play' \n", uid); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state(%d) is 'play' ", uid); return TTSD_ERROR_NONE; } /* check if engine use network */ if (ttsd_engine_agent_need_network()) { if (false == ttsd_network_is_connected()) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Disconnect network. Current engine needs network service!!!.\n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Disconnect network. Current engine needs network service!!!."); return TTSD_ERROR_OUT_OF_NETWORK; } } @@ -544,21 +607,35 @@ int ttsd_server_play(int uid) if (uid != current_uid && -1 != current_uid) { /* Send interrupt message */ - SLOG(LOG_DEBUG, TAG_TTSD, "[Server] Old uid(%d) will be interrupted into 'Pause' state \n", current_uid); - __server_interrupt_client(current_uid); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server] Old uid(%d) will be interrupted into 'Pause' state ", current_uid); + + /* pause player */ + if (0 != ttsd_player_pause(current_uid)) { + SLOG(LOG_WARN, TAG_TTSD, "[Server ERROR] fail to ttsd_player_pause() : uid (%d)", current_uid); + } + + /* change state */ + ttsd_data_set_client_state(current_uid, APP_STATE_PAUSED); + + int* temp_uid = (int*)malloc(sizeof(int)); + *temp_uid = current_uid; + ecore_timer_add(0, __send_interrupt_client, temp_uid); } /* Change current play */ if (0 != ttsd_data_set_client_state(uid, APP_STATE_PLAYING)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to set state : uid(%d)\n", uid); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to set state : uid(%d)", uid); return TTSD_ERROR_OPERATION_FAILED; } if (0 != __server_play_internal(uid, state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to start synthesis : uid(%d)\n", uid); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail to start synthesis : uid(%d)", uid); return TTSD_ERROR_OPERATION_FAILED; } + if (NULL == g_timer) + ecore_timer_add(0, __start_next_synthesis, NULL); + return TTSD_ERROR_NONE; } @@ -567,7 +644,7 @@ int ttsd_server_stop(int uid) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } @@ -578,10 +655,10 @@ int ttsd_server_stop(int uid) ttsd_data_set_client_state(uid, APP_STATE_READY); if (0 != ttsd_player_stop(uid)) - SLOG(LOG_WARN, TAG_TTSD, "[Server] Fail to ttsd_player_stop()\n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server] Fail to ttsd_player_stop()"); if (true == __server_get_current_synthesis()) { - SLOG(LOG_DEBUG, TAG_TTSD, "[Server] TTS-engine is running \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server] TTS-engine is running "); int ret = 0; ret = ttsd_engine_cancel_synthesis(); @@ -591,7 +668,7 @@ int ttsd_server_stop(int uid) __server_set_is_synthesizing(false); } } else { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state is 'ready' \n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state is 'ready' "); } return TTSD_ERROR_NONE; @@ -601,19 +678,19 @@ int ttsd_server_pause(int uid, int* utt_id) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_pause : uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_pause : uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } if (APP_STATE_PLAYING != state) { - SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state is not 'play' \n"); + SLOG(LOG_WARN, TAG_TTSD, "[Server WARNING] Current state is not 'play' "); return TTSD_ERROR_INVALID_STATE; } int ret = 0; ret = ttsd_player_pause(uid); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail player_pause() : ret(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail player_pause() : ret(%d)", ret); return TTSD_ERROR_OPERATION_FAILED; } @@ -626,17 +703,17 @@ int ttsd_server_get_support_voices(int uid, GList** voice_list) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } /* get voice list*/ if (0 != ttsd_engine_get_voice_list(voice_list)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail ttsd_server_get_support_voices() \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] Fail ttsd_server_get_support_voices() "); return TTSD_ERROR_OPERATION_FAILED; } - SLOG(LOG_DEBUG, TAG_TTSD, "[Server SUCCESS] Get supported voices \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server SUCCESS] Get supported voices "); return TTSD_ERROR_NONE; } @@ -645,18 +722,18 @@ int ttsd_server_get_current_voice(int uid, char** language, int* voice_type) { app_state_e state; if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_get_current_voice : uid is not valid \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] ttsd_server_get_current_voice : uid is not valid "); return TTSD_ERROR_INVALID_PARAMETER; } /* get current voice */ int ret = ttsd_engine_get_default_voice(language, (ttsp_voice_type_e*)voice_type); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail ttsd_server_get_support_voices() \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server ERROR] fail ttsd_server_get_support_voices() "); return ret; } - SLOG(LOG_DEBUG, TAG_TTSD, "[Server] Get default language (%s), voice type(%d) \n", *language, *voice_type); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server] Get default language (%s), voice type(%d) ", *language, *voice_type); return TTSD_ERROR_NONE; } @@ -670,7 +747,7 @@ int ttsd_server_setting_initialize(int uid) { if (false == g_is_engine) { if (0 != ttsd_engine_agent_initialize_current_engine()) { - SLOG(LOG_WARN, TAG_TTSD, "[Server Setting WARNING] No Engine !!! \n" ); + SLOG(LOG_WARN, TAG_TTSD, "[Server Setting WARNING] No Engine !!! " ); g_is_engine = false; return TTSD_ERROR_ENGINE_NOT_FOUND; } else { @@ -678,21 +755,21 @@ int ttsd_server_setting_initialize(int uid) } } - if (-1 != ttsd_data_is_client(uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] pid has already been registered \n"); + if (-1 != ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] pid has already been registered "); return TTSD_ERROR_INVALID_PARAMETER; } if (0 == ttsd_data_get_client_count()) { if( 0 != ttsd_engine_agent_load_current_engine() ) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to load current engine \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to load current engine "); return TTSD_ERROR_OPERATION_FAILED; } } /* register pid */ - if (0 != ttsd_data_new_client(uid, uid)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to add client info \n"); + if (0 != ttsd_setting_data_add(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to add client info "); return TTSD_ERROR_OPERATION_FAILED; } @@ -701,21 +778,20 @@ int ttsd_server_setting_initialize(int uid) int ttsd_server_setting_finalize(int uid) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)\n", uid); + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } - ttsd_data_delete_client(uid); + ttsd_setting_data_delete(uid); /* unload engine, if ref count of client is 0 */ if (0 == ttsd_data_get_client_count()) { if (0 != ttsd_engine_agent_unload_current_engine()) - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to unload current engine \n"); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to unload current engine "); else - SLOG(LOG_DEBUG, TAG_TTSD, "[Server Setting SUCCESS] unload current engine \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server Setting SUCCESS] unload current engine "); } return TTSD_ERROR_NONE; @@ -723,16 +799,15 @@ int ttsd_server_setting_finalize(int uid) int ttsd_server_setting_get_engine_list(int uid, GList** engine_list) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } int ret = 0; ret = ttsd_engine_setting_get_engine_list(engine_list); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get engine list : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get engine list : result(%d)", ret); return ret; } @@ -741,16 +816,15 @@ int ttsd_server_setting_get_engine_list(int uid, GList** engine_list) int ttsd_server_setting_get_current_engine(int uid, char** engine_id) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } int ret = 0; ret = ttsd_engine_setting_get_engine(engine_id); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get current engine : result(%d) \n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get current engine : result(%d) ", ret); return ret; } @@ -765,7 +839,7 @@ bool __get_client_cb(int pid, int uid, app_state_e state, void* user_data) ttsd_data_set_client_state(uid, APP_STATE_READY); /* send message */ - if ( 0 != ttsdc_send_interrupt_message(pid, uid, TTSD_INTERRUPTED_STOPPED)) { + if ( 0 != ttsdc_send_set_state_message(pid, uid, APP_STATE_READY)) { /* remove client */ ttsd_data_delete_client(uid); } @@ -775,15 +849,14 @@ bool __get_client_cb(int pid, int uid, app_state_e state, void* user_data) int ttsd_server_setting_set_current_engine(int uid, const char* engine_id) { - /* check if pid is valid */ - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } if (true == ttsd_engine_agent_is_same_engine(engine_id)) { - SLOG(LOG_DEBUG, TAG_TTSD, "[Server Setting] new engine is the same as current engine \n"); + SLOG(LOG_DEBUG, TAG_TTSD, "[Server Setting] new engine is the same as current engine "); return TTSD_ERROR_NONE; } @@ -797,7 +870,7 @@ int ttsd_server_setting_set_current_engine(int uid, const char* engine_id) int ret = 0; ret = ttsd_engine_setting_set_engine(engine_id); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set current engine : result(%d) \n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set current engine : result(%d) ", ret); return ret; } @@ -806,9 +879,9 @@ int ttsd_server_setting_set_current_engine(int uid, const char* engine_id) int ttsd_server_setting_get_voice_list(int uid, char** engine_id, GList** voice_list) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } @@ -816,7 +889,7 @@ int ttsd_server_setting_get_voice_list(int uid, char** engine_id, GList** voice_ int ret = 0; ret = ttsd_engine_setting_get_voice_list(engine_id, voice_list); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get voice list : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get voice list : result(%d)", ret); return ret; } @@ -825,16 +898,16 @@ int ttsd_server_setting_get_voice_list(int uid, char** engine_id, GList** voice_ int ttsd_server_setting_get_default_voice(int uid, char** language, ttsp_voice_type_e* vctype) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } int ret = 0; ret = ttsd_engine_setting_get_default_voice(language, vctype); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get default voice : result(%d) \n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] Fail to get default voice : result(%d) ", ret); return ret; } @@ -843,9 +916,9 @@ int ttsd_server_setting_get_default_voice(int uid, char** language, ttsp_voice_t int ttsd_server_setting_set_default_voice(int uid, const char* language, int vctype) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } @@ -853,7 +926,7 @@ int ttsd_server_setting_set_default_voice(int uid, const char* language, int vct int ret = 0; ret = ttsd_engine_setting_set_default_voice((const char*)language, (const ttsp_voice_type_e)vctype); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set default voice : result(%d) \n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set default voice : result(%d) ", ret); return ret; } @@ -862,16 +935,16 @@ int ttsd_server_setting_set_default_voice(int uid, const char* language, int vct int ttsd_server_setting_get_engine_setting(int uid, char** engine_id, GList** engine_setting_list) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } int ret = 0; ret = ttsd_engine_setting_get_engine_setting_info(engine_id, engine_setting_list); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get engine setting info : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get engine setting info : result(%d)", ret); return ret; } @@ -880,16 +953,16 @@ int ttsd_server_setting_get_engine_setting(int uid, char** engine_id, GList** en int ttsd_server_setting_set_engine_setting(int uid, const char* key, const char* value) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } int ret = 0; ret = ttsd_engine_setting_set_engine_setting(key, value); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set engine setting info : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set engine setting info : result(%d)", ret); return ret; } @@ -898,9 +971,9 @@ int ttsd_server_setting_set_engine_setting(int uid, const char* key, const char* int ttsd_server_setting_get_default_speed(int uid, int* default_speed) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } @@ -908,7 +981,7 @@ int ttsd_server_setting_get_default_speed(int uid, int* default_speed) int ret = 0; ret = ttsd_engine_setting_get_default_speed((ttsp_speed_e*)default_speed); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get default speed : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to get default speed : result(%d)", ret); return ret; } @@ -917,9 +990,9 @@ int ttsd_server_setting_get_default_speed(int uid, int* default_speed) int ttsd_server_setting_set_default_speed(int uid, int default_speed) { - app_state_e state; - if (0 > ttsd_data_get_client_state(uid, &state)) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid \n"); + /* check if uid is valid */ + if (-1 == ttsd_setting_data_is_setting(uid)) { + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] uid is not valid (%s)", uid); return TTSD_ERROR_INVALID_PARAMETER; } @@ -927,32 +1000,11 @@ int ttsd_server_setting_set_default_speed(int uid, int default_speed) int ret = 0; ret = ttsd_engine_setting_set_default_speed((ttsp_speed_e)default_speed); if (0 != ret) { - SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set default speed : result(%d)\n", ret); + SLOG(LOG_ERROR, TAG_TTSD, "[Server Setting ERROR] fail to set default speed : result(%d)", ret); return ret; } return TTSD_ERROR_NONE; } -/* -* Server API for Internal event -*/ - -int ttsd_server_start_next_play(int uid) -{ - SLOG(LOG_DEBUG, TAG_TTSD, "===== NEXT PLAY START"); - - int ret = ttsd_player_next_play(uid); - - SLOG(LOG_DEBUG, TAG_TTSD, "===== "); - SLOG(LOG_DEBUG, TAG_TTSD, " "); - - return ret ; -} - -int ttsd_server_start_next_synthesis(int uid) -{ - return __server_next_synthesis(uid); -} - diff --git a/server/ttsd_server.h b/server/ttsd_server.h index 7b283ce..7dda232 100644 --- a/server/ttsd_server.h +++ b/server/ttsd_server.h @@ -16,6 +16,7 @@ #define __TTSD_SERVER_CORE_H_ #include +#include #ifdef __cplusplus extern "C" { @@ -28,6 +29,8 @@ extern "C" { /** Daemon initialize */ int ttsd_initialize(); +Eina_Bool ttsd_cleanup_client(void *data); + /* * Server API for client */ @@ -49,14 +52,6 @@ int ttsd_server_stop(int uid); int ttsd_server_pause(int uid, int* utt_id); /* -* Server API for Internal event -*/ - -int ttsd_server_start_next_play(int uid); - -int ttsd_server_start_next_synthesis(int uid); - -/* * Server API for setting */ -- 2.7.4