* limitations under the License.
*/
+#include <app_manager.h>
#include <aul.h>
#include <Ecore.h>
#define CLIENT_CLEAN_UP_TIME 500
-
-typedef enum {
- TTSD_SYNTHESIS_CONTROL_DOING = 0,
- TTSD_SYNTHESIS_CONTROL_DONE = 1,
- TTSD_SYNTHESIS_CONTROL_EXPIRED = 2
-} ttsd_synthesis_control_e;
-
typedef struct {
int uid;
int uttid;
/* If current engine exist */
//static bool g_is_engine;
-/* If engine is running */
-static ttsd_synthesis_control_e g_synth_control;
-
static Ecore_Timer* g_check_client_timer = NULL;
static Ecore_Timer* g_wait_timer = NULL;
+static Ecore_Timer* g_terminate_timer = NULL;
static utterance_t g_utt;
static GList *g_proc_list = NULL;
-/* Function definitions */
-static int __synthesis(int uid, const char* credential);
+static bool g_is_paused;
-static int __server_set_synth_control(ttsd_synthesis_control_e control)
-{
- g_synth_control = control;
- return 0;
-}
-static ttsd_synthesis_control_e __server_get_synth_control()
-{
- return g_synth_control;
-}
+/* Function definitions */
+static int __synthesis(int uid, const char* credential);
static Eina_Bool __wait_synthesis(void *data)
{
int uid = ttsd_data_get_current_playing();
if (uid > 0) {
- if (TTSD_SYNTHESIS_CONTROL_DOING == __server_get_synth_control()) {
+ if (TTSD_SYNTHESIS_CONTROL_DOING == ttsd_get_synth_control()) {
return EINA_TRUE;
} else {
g_wait_timer = NULL;
- if (TTSD_SYNTHESIS_CONTROL_DONE == __server_get_synth_control()) {
+ if (TTSD_SYNTHESIS_CONTROL_DONE == ttsd_get_synth_control()) {
/* Start next synthesis */
__synthesis(uid, credential);
}
}
int pid = ttsd_data_get_pid(uid);
- char appid[128] = {0, };
- if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid))) {
+ char appid[1024] = {0, };
+ if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get app id");
}
ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
- if (NULL != speak_data) {
- if (NULL != speak_data->lang) free(speak_data->lang);
- if (NULL != speak_data->text) free(speak_data->text);
-
- speak_data->lang = NULL;
- speak_data->text = NULL;
-
- free(speak_data);
- speak_data = NULL;
- }
+ ttsd_data_clear_speak_data(uid, &speak_data);
return 0;
}
SLOG(LOG_INFO, tts_tag(), "-----------------------------------------------------------");
int ret = 0;
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_DOING);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DOING);
ret = ttsd_engine_start_synthesis(speak_data->lang, speak_data->vctype, speak_data->text, speak_data->speed, appid, credential, NULL);
if (0 != ret) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] * FAIL to start SYNTHESIS !!!! * ");
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
ttsd_server_stop(uid);
g_wait_timer = ecore_timer_add(0.05, __wait_synthesis, (void*)credential);
}
- if (NULL != speak_data) {
- if (NULL != speak_data->lang) free(speak_data->lang);
- if (NULL != speak_data->text) free(speak_data->text);
-
- speak_data->lang = NULL;
- speak_data->text = NULL;
-
- free(speak_data);
- speak_data = NULL;
- }
+ ttsd_data_clear_speak_data(uid, &speak_data);
+ } else {
+ ttsd_data_clear_speak_data(uid, &speak_data);
}
SLOG(LOG_DEBUG, tts_tag(), "@@@ SYNTHESIS END");
int uttid = g_utt.uttid;
int tmp_pid = ttsd_data_get_pid(uid);
- SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Error msg from engine, pid(%d), uid(%d), uttid(%d), error(%d), msg(%s)", tmp_pid, uid, uttid, error, msg);
+ SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Error msg from engine, pid(%d), uid(%d), uttid(%d), error(%d), msg(%s)", tmp_pid, uid, uttid, error, (NULL == msg ? "NULL" : msg));
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
if (0 != ttsd_player_clear(uid))
SLOG(LOG_WARN, tts_tag(), "[Server] Fail to ttsd_player_stop()");
if (false == ttsd_data_is_uttid_valid(uid, uttid)) {
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] uttid is NOT valid !!!! - uid(%d), uttid(%d)", uid, uttid);
SLOG(LOG_DEBUG, tts_tag(), "@@@");
return TTSD_ERROR_OPERATION_FAILED;
}
if (rate <= 0 || audio_type < 0 || audio_type > TTSE_AUDIO_TYPE_MAX) {
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] audio data is invalid");
SLOG(LOG_DEBUG, tts_tag(), "@@@");
return TTSD_ERROR_INVALID_PARAMETER;
if (0 != ttsd_data_add_sound_data(uid, temp_sound_data)) {
SECURE_SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Fail to add sound data : uid(%d)", uid);
+ if (NULL != temp_sound_data->data) {
+ free(temp_sound_data->data);
+ temp_sound_data->data = NULL;
+ }
+
+ free(temp_sound_data);
+ temp_sound_data = NULL;
+
+ return TTSD_ERROR_OPERATION_FAILED;
}
if (event == TTSE_RESULT_EVENT_FINISH) {
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
+ }
+
+ /* If the app state is paused, do not result to play */
+ if (true == g_is_paused) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Server DEBUG] tts_pause is called. Do not request to play");
+ return TTSD_ERROR_NONE;
}
if (0 != ttsd_player_play(uid)) {
}
} else {
SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_ERROR");
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
}
return TTSD_ERROR_NONE;
}
-bool __get_client_cb(int pid, int uid, app_state_e state, void* user_data)
+bool __get_client_cb(int pid, int uid, app_tts_state_e state, void* user_data)
{
/* clear client data */
ttsd_data_clear_data(uid);
return true;
}
-void __config_changed_cb(tts_config_type_e type, const char* str_param, int int_param)
+void __config_changed_cb(tts_config_type_e type, const char* str_param, int int_param, double double_param)
{
switch (type) {
case TTS_CONFIG_TYPE_ENGINE:
}
break;
}
+
+ case TTS_CONFIG_TYPE_BACKGROUND_VOLUME_RATIO:
+ {
+ if (0.0 <= double_param && double_param <= 1.0) {
+ /* set default bg volume ratio */
+ int ret = 0;
+ ret = ttsd_player_set_background_volume_ratio(double_param);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set default bg volume ratio : result(%d)", ret);
+ }
+ }
+ break;
+ }
}
return;
}
-bool __terminate_client(int pid, int uid, app_state_e state, void* user_data)
+bool __terminate_client(int pid, int uid, app_tts_state_e state, void* user_data)
{
SLOG(LOG_INFO, tts_tag(), "@@@ Start to terminate client [%d]", uid);
ttsd_server_finalize(uid);
Eina_Bool ttsd_terminate_daemon(void *data)
{
ttsd_data_foreach_clients(__terminate_client, NULL);
+ g_terminate_timer = NULL;
return EINA_FALSE;
}
{
if (TTSD_MODE_SCREEN_READER == ttsd_get_mode() && false == value) {
SLOG(LOG_INFO, tts_tag(), "[Server] Screen reader is OFF. Start to terminate tts daemon");
- ecore_timer_add(1, ttsd_terminate_daemon, NULL);
+ if (g_terminate_timer) {
+ ecore_timer_del(g_terminate_timer);
+ g_terminate_timer = NULL;
+ }
+ g_terminate_timer = ecore_timer_add(1, ttsd_terminate_daemon, NULL);
} else {
SLOG(LOG_DEBUG, tts_tag(), "[Server] Screen reader is %s", value ? "ON" : "OFF");
}
SLOG(LOG_ERROR, tts_tag(), "[Server WARNING] Fail to initialize config.");
}
+ double ratio;
+ if (0 == ttsd_config_get_bg_volume_ratio(&ratio))
+ {
+ SLOG(LOG_ERROR, tts_tag(), "[Server] get bg volume ratio is %lf", ratio);
+ int ret = ttsd_player_set_background_volume_ratio(ratio);
+ if (0 != ret)
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set bg volume ratio : result(%d)", ret);
+ }
+ else
+ SLOG(LOG_ERROR, tts_tag(), "[Server WARNING] Fail to get bg volume ratio");
+
/* player init */
if (ttsd_player_init()) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to initialize player init.");
return TTSD_ERROR_OPERATION_FAILED;
}
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
ttsd_config_set_screen_reader_callback(__screen_reader_changed_cb);
ttsd_engine_agent_release();
+
+ if (g_wait_timer) {
+ ecore_timer_del(g_wait_timer);
+ g_wait_timer = NULL;
+ SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore waiting timer handle");
+ }
+
+ if (g_terminate_timer) {
+ ecore_timer_del(g_terminate_timer);
+ g_terminate_timer = NULL;
+ SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore terminating timer handle");
+ }
+
if (NULL != g_check_client_timer) {
ecore_timer_del(g_check_client_timer);
g_check_client_timer = NULL;
-
- SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore timer handle");
+ SLOG(LOG_INFO, tts_tag(), "[INFO] Delete ecore checking client timer handle");
}
return TTSD_ERROR_NONE;
}
+int ttsd_terminate()
+{
+ SLOG(LOG_INFO, tts_tag(), "[Server] Terminate");
+
+ ttsd_terminate_daemon(NULL);
+
+ ttsd_dbus_close_connection();
+ ttsd_network_finalize();
+ ttsd_finalize();
+
+ return TTSD_ERROR_NONE;
+}
+
/*
* TTS Server Functions for Client
*/
}
if (0 != ttsd_engine_agent_is_credential_needed(uid, credential_needed)) {
- SLOG(LOG_ERROR, tts_tag(), "Server ERROR] Fail to get credential necessity");
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get credential necessity");
return TTSD_ERROR_OPERATION_FAILED;
}
+
+ if (true == *credential_needed) {
+ char* appid = NULL;
+ if (0 != app_manager_get_app_id(pid, &appid)) {
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get app id, pid(%d)", pid);
+ }
+ bool is_agreed = false;
+ if (0 != ttsd_engine_check_app_agreed(appid, &is_agreed)) {
+ SLOG(LOG_ERROR, tts_tag(), "Server ERROR] Fail to check app agreed");
+ if (!appid)
+ free(appid);
+ return TTSD_ERROR_OPERATION_FAILED;
+ }
+ if (!appid)
+ free(appid);
+
+ if (false == is_agreed) {
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] App is not agreed");
+ return TTSD_ERROR_PERMISSION_DENIED;
+ }
+ }
+
if (0 != ttsd_data_new_client(pid, uid)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to add client info");
return TTSD_ERROR_OPERATION_FAILED;
ttsd_network_finalize();
ttsd_finalize();
ecore_main_loop_quit();
- ecore_shutdown();
return EINA_FALSE;
}
return;
}
-bool __get_client_for_clean_up(int pid, int uid, app_state_e state, void* user_data)
+bool __get_client_for_clean_up(int pid, int uid, app_tts_state_e state, void* user_data)
{
bool exist = false;
int i = 0;
return true;
#if 0
- char appid[128] = {0, };
- if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid))) {
+ char appid[1024] = {0, };
+ if (0 != aul_app_get_appid_bypid(pid, appid, sizeof(appid) - 1)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get app id");
}
ttsd_data_foreach_clients(__get_client_for_clean_up, NULL);
} else {
ecore_timer_add(0, __quit_ecore_loop, NULL);
+ SLOG(LOG_ERROR, tts_tag(), "[Server] Deleted timer");
+ return EINA_FALSE;
}
SLOG(LOG_DEBUG, tts_tag(), "@@@");
{
SLOG(LOG_INFO, tts_tag(), "[Server] Server finalize");
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] ttsd_server_finalize : uid is not valid");
}
int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice_type, int speed, int utt_id, const char* credential)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] ttsd_server_add_queue : uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
}
/* Check whether tts-engine is running or not */
- if (TTSD_SYNTHESIS_CONTROL_DOING == __server_get_synth_control()) {
+ if (TTSD_SYNTHESIS_CONTROL_DOING == ttsd_get_synth_control()) {
SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Engine has already been running.");
} else {
__synthesis(uid, credential);
int ttsd_server_play(int uid, const char* credential)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%d) is NOT valid ", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
}
+ /* check the current playback focus */
+ if (TTSD_MODE_INTERRUPT != ttsd_get_mode()) {
+ bool is_current_interrupt = false;
+ if (0 != ttsd_player_check_current_playback_focus(&is_current_interrupt)) {
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to check the current playback focus");
+ } else {
+ if (true == is_current_interrupt) {
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Current playback focus is set on Interrupt mode. Cannot play default, screen reader, and noti modes.");
+ ttsd_data_clear_data(uid);
+ return TTSD_ERROR_AUDIO_POLICY_BLOCKED;
+ }
+ }
+ }
+
int current_uid = ttsd_data_get_current_playing();
SLOG(LOG_INFO, tts_tag(), "[Server] playing uid (%d)", current_uid);
if (APP_STATE_PAUSED == state) {
SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%d) is 'Pause' state : resume player", uid);
+ g_is_paused = false;
+
/* Resume player */
if (0 != ttsd_player_resume(uid)) {
SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to ttsd_player_resume()");
}
/* Check whether tts-engine is running or not */
- if (TTSD_SYNTHESIS_CONTROL_DOING == __server_get_synth_control()) {
+ if (TTSD_SYNTHESIS_CONTROL_DOING == ttsd_get_synth_control()) {
SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Engine has already been running.");
} else {
__synthesis(uid, credential);
int ttsd_server_stop(int uid)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
SLOG(LOG_INFO, tts_tag(), "[Server] server stop, state(%d)", state);
if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
- if (TTSD_SYNTHESIS_CONTROL_DOING == __server_get_synth_control() && uid == ttsd_data_get_current_playing()) {
+ if (TTSD_SYNTHESIS_CONTROL_DOING == ttsd_get_synth_control() && uid == ttsd_data_get_current_playing()) {
SLOG(LOG_DEBUG, tts_tag(), "[Server] TTS-engine is running");
int ret = 0;
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to cancel synthesis : ret(%d)", ret);
}
- __server_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
+ ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
if (0 != ttsd_player_clear(uid))
SLOG(LOG_WARN, tts_tag(), "[Server] Fail to ttsd_player_stop()");
/* Reset all data */
ttsd_data_clear_data(uid);
+ g_is_paused = false;
return TTSD_ERROR_NONE;
}
int ttsd_server_pause(int uid, int* utt_id)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] ttsd_server_pause : uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
return TTSD_ERROR_INVALID_STATE;
}
+ g_is_paused = true;
+
*utt_id = g_utt.uttid;
SLOG(LOG_INFO, tts_tag(), "[Server] server pause, uid(%d), g_uid(%d), utt_id(%d)", uid, g_utt.uid, *utt_id);
int ttsd_server_get_support_voices(int uid, GList** voice_list)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
int ttsd_server_get_current_voice(int uid, char** language, int* voice_type)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] ttsd_server_get_current_voice : uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
int ttsd_server_set_private_data(int uid, const char* key, const char* data)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%d) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
int ttsd_server_get_private_data(int uid, const char* key, char** data)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%d) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
int ttsd_server_play_pcm(int uid)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%d) is NOT valid ", uid);
return TTSD_ERROR_INVALID_PARAMETER;
return TTSD_ERROR_OPERATION_FAILED;
}
+ if (APP_STATE_PAUSED == state) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%d) is 'Pause' state : resume player", uid);
+
+ /* Resume player */
+ if (0 != ttsd_player_resume(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to ttsd_player_resume()");
+ }
+ } else {
+ if (0 != ttsd_player_play_pcm(uid)) {
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play pcm sound : uid(%d)", uid);
+
+ // Change ready state
+ ttsd_server_stop_pcm(uid);
+
+ int tmp_pid;
+ tmp_pid = ttsd_data_get_pid(uid);
+ ttsdc_send_set_state_message(tmp_pid, uid, APP_STATE_READY);
+ }
+ }
+
return TTSD_ERROR_NONE;
}
int ttsd_server_stop_pcm(int uid)
{
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid is not valid");
return TTSD_ERROR_INVALID_PARAMETER;
SLOG(LOG_INFO, tts_tag(), "[Server] server stop, state(%d)", state);
- if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
- if (0 != ttsd_player_clear(uid))
- SLOG(LOG_WARN, tts_tag(), "[Server] Fail to ttsd_player_stop()");
-
+ if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state || APP_STATE_READY == state) {
ttsd_data_set_client_state(uid, APP_STATE_READY);
}
/* Reset all data */
ttsd_data_clear_data(uid);
+ ttsd_player_stop(uid);
+
+
return TTSD_ERROR_NONE;
}
temp_sound_data = NULL;
}
- if (0 != ttsd_player_play(uid)) {
+/* if (0 != ttsd_player_play(uid)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play sound : uid(%d)", uid);
- /* Change ready state */
+ // Change ready state
ttsd_server_stop(uid);
int tmp_pid;
tmp_pid = ttsd_data_get_pid(uid);
ttsdc_send_set_state_message(tmp_pid, uid, APP_STATE_READY);
}
+*/
} else {
SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_ERROR");
}