On 32bit architecture, signed integer is enough to store uid value. However, on 64bit architecture,
signed integer is not enough because maximum value of pid is 4194304 and value of pid * 1000 is
bigger than the limit of signed integer. And it cause overflow problem.
To solve this issue, this patch changes the data type of variable that stores uid.
Unsigned integer can provides enough space to store uid value on 64bit os.
Change-Id: I7e4cc46ca454c8a8fb38d37a4434eee492aefee9
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>
return TTS_ERROR_OPERATION_FAILED;
}
- int uid = tts_client_get_uid(client);
- SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, uid);
+ unsigned int uid = tts_client_get_uid(client);
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts, client, uid);
if (false == tts_ipc_is_method_set()) {
int pid = getpid();
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
- SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts, client, uid);
+ unsigned int uid = tts_client_get_uid(client);
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts, client, uid);
/* check used callback */
if (0 != tts_client_get_use_callback(client)) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int num_of_client = tts_client_get_size();
- SLOG(LOG_ERROR, TAG_TTSC, "[INFO] num_of_client(%d)", num_of_client);
+ unsigned int num_of_client = tts_client_get_size();
+ SLOG(LOG_ERROR, TAG_TTSC, "[INFO] num_of_client(%u)", num_of_client);
if (0 == num_of_client) {
if (0 != tts_core_deinitialize()) {
static const int INVALID_HANDLE = -1;
/* allocated handle */
-static int g_allocated_handle = 0;
+static unsigned int g_allocated_handle = 0;
/* client list */
static GList *g_client_list = NULL;
static pthread_mutex_t g_client_list_mutex = PTHREAD_MUTEX_INITIALIZER;
-static int __client_generate_uid(int pid)
+static unsigned int __client_generate_uid(unsigned int pid)
{
- int uid = 0;
-
pthread_mutex_lock(&g_allocated_handle_mutex);
g_allocated_handle++;
}
/* generate uid, handle number should be smaller than 1000 */
- uid = pid * 1000 + g_allocated_handle;
+ unsigned int uid = pid * 1000u + g_allocated_handle;
pthread_mutex_unlock(&g_allocated_handle_mutex);
return uid;
return TTS_ERROR_OUT_OF_MEMORY;
}
- temp->handle = __client_generate_uid(getpid());
+ temp->handle = __client_generate_uid((unsigned int)getpid());
/* initialize client data */
client->tts = temp;
*tts = temp;
- SLOG(LOG_ERROR, TAG_TTSC, "[Success] Create client object : uid(%d)", client->uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "[Success] Create client object : uid(%u)", client->uid);
return TTS_ERROR_NONE;
}
while (NULL != iter) {
data = iter->data;
if (tts->handle == data->tts->handle) {
- tts->handle = INVALID_HANDLE;
+ tts->handle = TTS_INVALID_UID;
g_client_list = g_list_remove_link(g_client_list, iter);
while (0 != data->cb_ref_count) {
/* wait for release callback function */
}
- int uid = data->uid;
+ unsigned int uid = data->uid;
free(data->err_msg);
free(data->credential);
g_list_free(iter);
pthread_mutex_unlock(&g_client_list_mutex);
- SLOG(LOG_ERROR, TAG_TTSC, "Client destroy : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "Client destroy : uid(%u)", uid);
return TTS_ERROR_NONE;
}
return NULL;
}
-tts_client_s* tts_client_get_by_uid(const int uid)
+tts_client_s* tts_client_get_by_uid(unsigned int uid)
{
- if (uid < 0) {
+ if (uid == TTS_INVALID_UID) {
SLOG(LOG_ERROR, TAG_TTSC, "out of range : handle");
return NULL;
}
}
pthread_mutex_unlock(&g_client_list_mutex);
- SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid(%d) is not valid", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid(%u) is not valid", uid);
return NULL;
}
-bool tts_client_is_valid_uid(int uid)
+bool tts_client_is_valid_uid(unsigned int uid)
{
if (NULL == tts_client_get_by_uid(uid)) {
SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Uid is not valid");
return client->tts;
}
-int tts_client_get_size()
+unsigned int tts_client_get_size()
{
pthread_mutex_lock(&g_client_list_mutex);
- int size = g_list_length(g_client_list);
+ unsigned int size = g_list_length(g_client_list);
pthread_mutex_unlock(&g_client_list_mutex);
return size;
}
//LCOV_EXCL_STOP
-int tts_client_get_uid(tts_client_s* client)
+unsigned int tts_client_get_uid(tts_client_s* client)
{
if (NULL == client || false == tts_client_is_valid_client(client)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client(%p) is not valid", client);
- return INVALID_HANDLE;
+ return TTS_INVALID_UID;
}
return client->uid;
return client->current_state;
}
-void tts_client_set_start_listening(int uid, bool is_listening_started)
+void tts_client_set_start_listening(unsigned int uid, bool is_listening_started)
{
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
client->start_listening = is_listening_started;
}
-bool tts_client_is_listening_started(int uid)
+bool tts_client_is_listening_started(unsigned int uid)
{
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
/* base info */
tts_h tts;
int pid;
- int uid; /*<< unique id = pid + handle */
+ unsigned int uid; /*<< unique id = pid + handle */
int current_utt_id;
/* callback info */
int tts_client_destroy(tts_h tts);
tts_client_s* tts_client_get(tts_h tts);
-tts_client_s* tts_client_get_by_uid(const int uid);
+tts_client_s* tts_client_get_by_uid(unsigned int uid);
tts_h tts_client_get_handle(tts_client_s* client);
-bool tts_client_is_valid_uid(int uid);
+bool tts_client_is_valid_uid(unsigned int uid);
bool tts_client_is_valid_client(tts_client_s* client);
-int tts_client_get_size();
+unsigned int tts_client_get_size();
int tts_client_use_callback(tts_client_s* client);
int tts_client_not_use_callback(tts_client_s* client);
GList* tts_client_get_client_list();
-int tts_client_get_uid(tts_client_s* client);
+unsigned int tts_client_get_uid(tts_client_s* client);
void tts_client_set_current_state(tts_client_s* client, tts_state_e state);
tts_state_e tts_client_get_current_state(tts_client_s* client);
-void tts_client_set_start_listening(int uid, bool is_listening_started);
-bool tts_client_is_listening_started(int uid);
+void tts_client_set_start_listening(unsigned int uid, bool is_listening_started);
+bool tts_client_is_listening_started(unsigned int uid);
void tts_client_set_mode(tts_client_s* client, tts_mode_e mode);
tts_mode_e tts_client_get_mode(tts_client_s* client);
static Eina_Bool __notify_error_timer_cb(void *data)
{
- int uid = (intptr_t)data;
+ unsigned int uid = (uintptr_t)data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
- SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%u)", uid);
} else {
__client_error_cb(client, client->utt_id, client->reason);
client->notify_error_timer = NULL;
static Eina_Bool __notify_state_timer_cb(void *data)
{
- int uid = (intptr_t)data;
+ unsigned int uid = (uintptr_t)data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
- SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] UID is not valid. (%u)", uid);
} else {
__client_state_changed_cb(client, client->before_state, client->current_state);
client->notify_state_timer = NULL;
return TTS_ERROR_SCREEN_READER_OFF;
}
- int uid = tts_client_get_uid(client);
- SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, uid);
+ unsigned int uid = tts_client_get_uid(client);
+ SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
/* check service engine status */
bool is_launched = __is_engine_launched(tts_client_get_mode(client));
static Eina_Bool __prepare_cb(void *data)
{
- int uid = (intptr_t)data;
+ unsigned int uid = (uintptr_t)data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid.");
static Eina_Bool __prepare_first_cb(void *data)
{
/* send first hello message */
- int uid = (intptr_t)data;
+ unsigned int uid = (uintptr_t)data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Handle is not valid.");
}
}
// TODO: make function duplicated block
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
if (0 != tts_ipc_request_hello_sync(uid)) {
return EINA_TRUE;
}
static bool __supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
{
- int uid = (intptr_t)user_data;
+ unsigned int uid = (uintptr_t)user_data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Uid is not valid. (%d)", uid);
}
// TODO: If use cpp, remove dupliceated code using command class pattern
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
static inline int __request_play(tts_client_s* client)
{
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
ecore_timer_del(client->notify_state_timer);
}
- intptr_t uid = tts_client_get_uid(client);
+ uintptr_t uid = tts_client_get_uid(client);
client->notify_state_timer = ecore_timer_add(0, __notify_state_timer_cb, (void*)uid);
return TTS_ERROR_NONE;
ecore_timer_del(client->notify_error_timer);
}
- intptr_t uid = tts_client_get_uid(client);
+ uintptr_t uid = tts_client_get_uid(client);
client->notify_error_timer = ecore_timer_add(0, __notify_error_timer_cb, (void*)uid);
return TTS_ERROR_NONE;
return NULL;
}
-int tts_core_receive_hello(int uid, int ret, int credential_needed)
+int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed)
{
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
- SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client or ignore this uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client or ignore this uid(%u)", uid);
return TTS_ERROR_OPERATION_FAILED;
}
SLOG(LOG_ERROR, TAG_TTSC, "Register timer for __prepare_first_cb");
ecore_thread_main_loop_begin();
- intptr_t uid = tts_client_get_uid(client);
+ uintptr_t uid = tts_client_get_uid(client);
client->hello_timer = ecore_timer_add(0.0, __prepare_first_cb, (void*)uid);
ecore_thread_main_loop_end();
} else {
return TTS_ERROR_INVALID_PARAMETER;
}
- SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare_sync. tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, tts_client_get_uid(client));
+ SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare_sync. tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, tts_client_get_uid(client));
int cnt = 0;
while (TTS_CONNECTION_RETRY_COUNT > cnt) {
if (false == tts_core_check_screen_reader(client)) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
- SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%d)", tts_client_get_handle(client), client, uid);
+ unsigned int uid = tts_client_get_uid(client);
+ SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
if (client->hello_timer) {
ecore_timer_del(client->hello_timer);
client->hello_timer = NULL;
}
tts_client_set_supported_voice_cb(client, callback, user_data);
- intptr_t uid = tts_client_get_uid(client);
+ uintptr_t uid = tts_client_get_uid(client);
int ret = tts_config_mgr_get_voice_list(engine_id, __supported_voice_cb, (void*)uid);
tts_client_set_supported_voice_cb(client, NULL, NULL);
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = 0;
int count = 0;
bool is_prepared = false;
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
return TTS_ERROR_INVALID_PARAMETER;
}
- int uid = tts_client_get_uid(client);
+ unsigned int uid = tts_client_get_uid(client);
int ret = -1;
bool is_prepared = false;
for (int count = 0; count < TTS_RETRY_COUNT; count++) {
int tts_core_set_private_data(tts_client_s* client, const char* key, const char* data);
int tts_core_get_private_data(tts_client_s* client, const char* key, char** data);
-int tts_core_receive_hello(int uid, int ret, int credential_needed);
+int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed);
int tts_core_handle_service_reset();
#ifdef __cplusplus
static volatile int g_connected_client = 0;
-static int __tts_dbus_add_match(int uid)
+static int __tts_dbus_add_match(unsigned int uid)
{
/* add a rule for daemon error */
char rule_err[256] = {0, };
if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_HELLO)) {
SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get Hello");
- int uid;
+ unsigned int uid;
int ret;
int credential_needed;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &credential_needed,
DBUS_TYPE_INVALID);
SLOG(LOG_ERROR, TAG_TTSC, "@@ tts Get Hello message : Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_ERROR, TAG_TTSC, "@@ tts Get Hello message : uid(%d), credential_needed(%d)", uid, credential_needed);
+ SLOG(LOG_ERROR, TAG_TTSC, "@@ tts Get Hello message : uid(%u), credential_needed(%d)", uid, credential_needed);
if (TTS_ERROR_ALREADY_INITIALIZED == ret && TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED == credential_needed) {
SLOG(LOG_INFO, TAG_TTSC, "@@ tts Get Hello message : already initialized");
ret = 0;
}
else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) {
- int uid = 0;
+ unsigned int uid = 0;
int uttid = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
dbus_error_free(&err);
}
if (0 == tts_core_notify_utt_started(tts_client_get_by_uid(uid), uttid)) {
- SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance started : uid(%d) uttid(%d)", uid, uttid);
+ SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance started : uid(%u) uttid(%d)", uid, uttid);
}
} /* TTSD_METHOD_UTTERANCE_STARTED */
else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) {
- int uid = 0;
+ unsigned int uid = 0;
int uttid = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
dbus_error_free(&err);
}
if (0 == tts_core_notify_utt_completeted(tts_client_get_by_uid(uid), uttid)) {
- SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance completed : uid(%d) uttid(%d)", uid, uttid);
+ SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance completed : uid(%u) uttid(%d)", uid, uttid);
}
} /* TTS_SIGNAL_UTTERANCE_STARTED */
else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_SET_STATE)) {
- int uid = 0;
+ unsigned int uid = 0;
int state = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
dbus_error_free(&err);
}
if (0 == tts_core_notify_state_changed_async(tts_client_get_by_uid(uid), (tts_state_e)state)) {
- SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts state changed : uid(%d) state(%d)", uid, state);
+ SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts state changed : uid(%u) state(%d)", uid, state);
}
} /* TTSD_SIGNAL_SET_STATE */
else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_ERROR)) {
- int uid;
+ unsigned int uid;
int uttid;
int reason;
char* err_msg;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &uttid,
DBUS_TYPE_INT32, &reason,
DBUS_TYPE_STRING, &err_msg,
SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message - Get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%d), error(%d), uttid(%d), err_msg(%s)", uid, reason, uttid, (NULL == err_msg) ? "NULL" : err_msg);
+ SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%u), error(%d), uttid(%d), err_msg(%s)", uid, reason, uttid, (NULL == err_msg) ? "NULL" : err_msg);
tts_core_notify_error_async(tts_client_get_by_uid(uid), reason, uttid, err_msg);
}
} /* TTSD_SIGNAL_ERROR */
return TTS_ERROR_NONE;
}
-int tts_dbus_open_connection(int uid)
+int tts_dbus_open_connection(unsigned int uid)
{
if (NULL != g_conn_sender && NULL != g_conn_listener) {
SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
return TTS_ERROR_NONE;
}
-int tts_dbus_close_connection(int uid)
+int tts_dbus_close_connection(unsigned int uid)
{
g_connected_client--;
return TTS_ERROR_NONE;
}
-int tts_dbus_stop_listening(int uid)
+int tts_dbus_stop_listening(unsigned int uid)
{
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
return 0;
}
-DBusMessage* __tts_dbus_make_message(int uid, const char* method)
+DBusMessage* __tts_dbus_make_message(unsigned int uid, const char* method)
{
if (NULL == method) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
return msg;
}
-int tts_dbus_request_hello(int uid)
+int tts_dbus_request_hello(unsigned int uid)
{
DBusError err;
dbus_error_init(&err);
}
int pid = getpid();
- if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
+ if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return 0;
}
-int tts_dbus_request_hello_sync(int uid)
+int tts_dbus_request_hello_sync(unsigned int uid)
{
DBusError err;
dbus_error_init(&err);
return result;
}
-int tts_dbus_request_initialize(int uid, bool* credential_needed)
+int tts_dbus_request_initialize(unsigned int uid, bool* credential_needed)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : uid(%u)", uid);
}
int pid = getpid();
- if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
+ if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return result;
}
-int tts_dbus_request_finalize(int uid)
+int tts_dbus_request_finalize(unsigned int uid)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%u)", uid);
}
- if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
+ if (true != dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return result;
}
-int tts_dbus_request_set_mode(int uid, tts_mode_e mode)
+int tts_dbus_request_set_mode(unsigned int uid, tts_mode_e mode)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set mode : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set mode : uid(%d), mode(%d)", uid, mode);
+ SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set mode : uid(%u), mode(%d)", uid, mode);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &mode,
DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
return result;
}
-int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
+int tts_dbus_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
{
if (NULL == text || NULL == lang) {
SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : uid(%u), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
}
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &text,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_INT32, &vctype,
return result;
}
-int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
+int tts_dbus_request_set_private_data(unsigned int uid, const char* key, const char* data)
{
if (NULL == key || NULL == data) {
SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%u)", uid);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &key,
DBUS_TYPE_STRING, &data,
DBUS_TYPE_INVALID)) {
return result;
}
-int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
+int tts_dbus_request_get_private_data(unsigned int uid, const char* key, char** data)
{
if (NULL == key || NULL == data) {
SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%u)", uid);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &key,
DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
return result;
}
-int tts_dbus_request_play(int uid, const char* credential)
+int tts_dbus_request_play(unsigned int uid, const char* credential)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : uid(%u)", uid);
}
char *temp = NULL;
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &temp,
DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
return result;
}
-int tts_dbus_request_stop(int uid)
+int tts_dbus_request_stop(unsigned int uid)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : uid(%u)", uid);
}
DBusMessage* result_msg;
int result = TTS_ERROR_OPERATION_FAILED;
- if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
+ if (true != dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return result;
}
-int tts_dbus_request_pause(int uid)
+int tts_dbus_request_pause(unsigned int uid)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : uid(%u)", uid);
}
DBusMessage* result_msg;
int result = TTS_ERROR_OPERATION_FAILED;
- if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
+ if (true != dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
}
//LCOV_EXCL_START
-int tts_dbus_request_play_pcm(int uid)
+int tts_dbus_request_play_pcm(unsigned int uid)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : uid(%u)", uid);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return result;
}
-int tts_dbus_request_stop_pcm(int uid)
+int tts_dbus_request_stop_pcm(unsigned int uid)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : uid(%u)", uid);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID)) {
dbus_message_unref(msg);
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
return result;
}
-int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
+int tts_dbus_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate)
{
DBusMessage* msg;
DBusError err;
SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
return TTS_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : uid(%u)", uid);
}
if (true != dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &event,
DBUS_TYPE_INT32, &audio_type,
DBUS_TYPE_INT32, &rate,
extern "C" {
#endif
-int tts_dbus_open_connection(int uid);
+int tts_dbus_open_connection(unsigned int uid);
-int tts_dbus_close_connection(int uid);
+int tts_dbus_close_connection(unsigned int uid);
-int tts_dbus_stop_listening(int uid);
+int tts_dbus_stop_listening(unsigned int uid);
-int tts_dbus_request_hello(int uid);
+int tts_dbus_request_hello(unsigned int uid);
-int tts_dbus_request_hello_sync(int uid);
+int tts_dbus_request_hello_sync(unsigned int uid);
-int tts_dbus_request_initialize(int uid, bool* credential_needed);
+int tts_dbus_request_initialize(unsigned int uid, bool* credential_needed);
-int tts_dbus_request_finalize(int uid);
+int tts_dbus_request_finalize(unsigned int uid);
-int tts_dbus_request_set_mode(int uid, tts_mode_e mode);
+int tts_dbus_request_set_mode(unsigned int uid, tts_mode_e mode);
-int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
+int tts_dbus_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
-int tts_dbus_request_play(int uid, const char* credential);
+int tts_dbus_request_play(unsigned int uid, const char* credential);
-int tts_dbus_request_stop(int uid);
+int tts_dbus_request_stop(unsigned int uid);
-int tts_dbus_request_pause(int uid);
+int tts_dbus_request_pause(unsigned int uid);
-int tts_dbus_request_set_private_data(int uid, const char* key, const char* data);
+int tts_dbus_request_set_private_data(unsigned int uid, const char* key, const char* data);
-int tts_dbus_request_get_private_data(int uid, const char* key, char** data);
+int tts_dbus_request_get_private_data(unsigned int uid, const char* key, char** data);
-int tts_dbus_request_play_pcm(int uid);
+int tts_dbus_request_play_pcm(unsigned int uid);
-int tts_dbus_request_stop_pcm(int uid);
+int tts_dbus_request_stop_pcm(unsigned int uid);
-int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate);
+int tts_dbus_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate);
#ifdef __cplusplus
}
return (g_ipc_method != TTS_IPC_METHOD_UNDEFINED);
}
-int tts_ipc_open_connection(int uid)
+int tts_ipc_open_connection(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_open_connection");
return g_vtable[OPEN_CONNECTION](uid);
}
-int tts_ipc_close_connection(int uid)
+int tts_ipc_close_connection(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_close_connection");
return g_vtable[CLOSE_CONNECTION](uid);
}
-int tts_ipc_stop_listening(int uid)
+int tts_ipc_stop_listening(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_stop_listening");
return g_vtable[STOP_LISTENING](uid);
}
-int tts_ipc_request_hello(int uid)
+int tts_ipc_request_hello(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_hello");
return g_vtable[REQUEST_HELLO](uid);
}
-int tts_ipc_request_hello_sync(int uid)
+int tts_ipc_request_hello_sync(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_hello_sync");
return g_vtable[REQUEST_HELLO_SYNC](uid);
}
-int tts_ipc_request_initialize(int uid, bool* credential_needed)
+int tts_ipc_request_initialize(unsigned int uid, bool* credential_needed)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_initialize");
return g_vtable[REQUEST_INITIALIZE](uid, credential_needed);
}
-int tts_ipc_request_finalize(int uid)
+int tts_ipc_request_finalize(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_finalize");
return g_vtable[REQUEST_FINALIZE](uid);
}
-int tts_ipc_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
+int tts_ipc_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_add_text");
return g_vtable[REQUEST_ADD_TEXT](uid, text, lang, vctype, speed, uttid, credential);
}
-int tts_ipc_request_set_private_data(int uid, const char* key, const char* data)
+int tts_ipc_request_set_private_data(unsigned int uid, const char* key, const char* data)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_set_private_data");
return g_vtable[REQUEST_SET_PRIVATE_DATA](uid, key, data);
}
-int tts_ipc_request_get_private_data(int uid, const char* key, char** data)
+int tts_ipc_request_get_private_data(unsigned int uid, const char* key, char** data)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_get_private_data");
return g_vtable[REQUEST_GET_PRIVATE_DATA](uid, key, data);
}
-int tts_ipc_request_play(int uid, const char* credential)
+int tts_ipc_request_play(unsigned int uid, const char* credential)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_play");
return g_vtable[REQUEST_PLAY](uid, credential);
}
-int tts_ipc_request_stop(int uid)
+int tts_ipc_request_stop(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_stop");
return g_vtable[REQUEST_STOP](uid);
}
-int tts_ipc_request_pause(int uid)
+int tts_ipc_request_pause(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_pause");
}
//LCOV_EXCL_START
-int tts_ipc_request_play_pcm(int uid)
+int tts_ipc_request_play_pcm(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_play_pcm");
return g_vtable[REQUEST_PLAY_PCM](uid);
}
-int tts_ipc_request_stop_pcm(int uid)
+int tts_ipc_request_stop_pcm(unsigned int uid)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_stop_pcm");
return g_vtable[REQUEST_STOP_PCM](uid);
}
-int tts_ipc_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
+int tts_ipc_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_add_pcm");
}
// LCOV_EXCL_STOP
-int tts_ipc_request_set_mode(int uid, tts_mode_e mode)
+int tts_ipc_request_set_mode(unsigned int uid, tts_mode_e mode)
{
SLOG(LOG_INFO, TAG_TTSC, "[IPC] tts_ipc_request_set_mode");
bool tts_ipc_is_method_set();
-int tts_ipc_open_connection(int uid);
+int tts_ipc_open_connection(unsigned int uid);
-int tts_ipc_close_connection(int uid);
+int tts_ipc_close_connection(unsigned int uid);
-int tts_ipc_stop_listening(int uid);
+int tts_ipc_stop_listening(unsigned int uid);
-int tts_ipc_request_hello(int uid);
+int tts_ipc_request_hello(unsigned int uid);
-int tts_ipc_request_hello_sync(int uid);
+int tts_ipc_request_hello_sync(unsigned int uid);
-int tts_ipc_request_initialize(int uid, bool* credential_needed);
+int tts_ipc_request_initialize(unsigned int uid, bool* credential_needed);
-int tts_ipc_request_finalize(int uid);
+int tts_ipc_request_finalize(unsigned int uid);
-int tts_ipc_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
+int tts_ipc_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
-int tts_ipc_request_play(int uid, const char* credential);
+int tts_ipc_request_play(unsigned int uid, const char* credential);
-int tts_ipc_request_stop(int uid);
+int tts_ipc_request_stop(unsigned int uid);
-int tts_ipc_request_pause(int uid);
+int tts_ipc_request_pause(unsigned int uid);
-int tts_ipc_request_set_private_data(int uid, const char* key, const char* data);
+int tts_ipc_request_set_private_data(unsigned int uid, const char* key, const char* data);
-int tts_ipc_request_get_private_data(int uid, const char* key, char** data);
+int tts_ipc_request_get_private_data(unsigned int uid, const char* key, char** data);
-int tts_ipc_request_play_pcm(int uid);
+int tts_ipc_request_play_pcm(unsigned int uid);
-int tts_ipc_request_stop_pcm(int uid);
+int tts_ipc_request_stop_pcm(unsigned int uid);
-int tts_ipc_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate);
+int tts_ipc_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate);
-int tts_ipc_request_set_mode(int uid, tts_mode_e mode);
+int tts_ipc_request_set_mode(unsigned int uid, tts_mode_e mode);
#ifdef __cplusplus
}
* @brief A structure of handle for identification
*/
struct tts_s {
- int handle;
+ unsigned int handle;
};
#ifdef __cplusplus
#define MAX_CONNECT_CHECK 100
typedef struct {
- int uid;
+ unsigned int uid;
bool connected;
bool connection_requesting;
bool register_callback_invoked;
static GList* g_tidl_infos = NULL;
-static tts_tidl_info_s* __get_tidl_info_s(int uid)
+static tts_tidl_info_s* __get_tidl_info_s(unsigned int uid)
{
GList* iter = NULL;
tts_tidl_info_s* info = NULL;
static void __reconnect(void *data)
{
- int uid = (intptr_t)data;
+ unsigned int uid = (uintptr_t)data;
tts_client_s *client = tts_client_get_by_uid(uid);
if (!client)
if (!client)
return;
- SLOG(LOG_DEBUG, TAG_TTSC, "__notify_cb is invoked pid(%d) uid(%d)", pid, uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_DEBUG, TAG_TTSC, "__notify_cb is invoked pid(%d) uid(%u)", pid, u_uid);
bundle_get_str(msg, TTS_BUNDLE_METHOD, &method);
bundle_get_str(msg, TTS_BUNDLE_REASON, &ret);
if (NULL != credential_needed && NULL != ret) {
- tts_client_set_start_listening(uid, true);
- tts_core_receive_hello(uid, atoi(ret), atoi(credential_needed));
+ tts_client_set_start_listening(u_uid, true);
+ tts_core_receive_hello(u_uid, atoi(ret), atoi(credential_needed));
- tts_tidl_info_s* info = __get_tidl_info_s(uid);
+ tts_tidl_info_s* info = __get_tidl_info_s(u_uid);
if (NULL == info) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get tidl info");
return;
}
info->register_callback_invoked = false;
} else {
- SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get message(TTSD_METHOD_HELLO). pid(%d) uid(%d)", pid, uid);
+ SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get message(TTSD_METHOD_HELLO). pid(%d) uid(%u)", pid, u_uid);
}
} else if (0 == strncmp(TTSD_METHOD_UTTERANCE_STARTED, method, strlen(TTSD_METHOD_UTTERANCE_STARTED))) {
bundle_get_str(msg, TTS_BUNDLE_MESSAGE, &val);
static void __on_connected(rpc_port_proxy_tts_h h, void *user_data)
{
- int uid = (intptr_t)user_data;
+ unsigned int uid = (uintptr_t)user_data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
static void __on_disconnected(rpc_port_proxy_tts_h h, void *user_data)
{
- int uid = (intptr_t)user_data;
+ unsigned int uid = (uintptr_t)user_data;
tts_client_s* client = tts_client_get_by_uid(uid);
if (NULL == client) {
static void __on_rejected(rpc_port_proxy_tts_h h, void *user_data)
{
- int uid = (intptr_t)user_data;
+ unsigned int uid = (uintptr_t)user_data;
tts_client_s *client = tts_client_get_by_uid(uid);
if (NULL == client) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
SLOG(LOG_INFO, TAG_TTSC, "engine app id : %s", app_id);
}
-static rpc_port_proxy_tts_h __create_rpc_port(int uid, const char* engine_app_id)
+static rpc_port_proxy_tts_h __create_rpc_port(unsigned int uid, const char* engine_app_id)
{
rpc_port_proxy_tts_callback_s rpc_callback = {
.connected = __on_connected,
};
rpc_port_proxy_tts_h handle = NULL;
- intptr_t ptr_uid = uid;
+ uintptr_t ptr_uid = uid;
if (0 != rpc_port_proxy_tts_create(engine_app_id, &rpc_callback, (void*)ptr_uid, &handle)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create proxy");
return NULL;
return handle;
}
-int tts_tidl_open_connection(int uid)
+int tts_tidl_open_connection(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_open_connection");
info->uid = uid;
g_tidl_infos = g_list_append(g_tidl_infos, info);
- SLOG(LOG_ERROR, TAG_TTSC, "[TIDL] uid(%d) rpc_h(%p), engine_app_id(%s)", uid, info->rpc_h, info->engine_app_id);
+ SLOG(LOG_ERROR, TAG_TTSC, "[TIDL] uid(%u) rpc_h(%p), engine_app_id(%s)", uid, info->rpc_h, info->engine_app_id);
return TTS_ERROR_NONE;
}
-int tts_tidl_close_connection(int uid)
+int tts_tidl_close_connection(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_close_connection");
return TTS_ERROR_NONE;
}
-int tts_tidl_stop_listening(int uid)
+int tts_tidl_stop_listening(unsigned int uid)
{
if (false == tts_client_is_valid_uid(uid)) {
SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not valid");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_hello(int uid)
+int tts_tidl_request_hello(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_hello_sync(int uid)
+int tts_tidl_request_hello_sync(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_hello");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_initialize(int uid, bool* credential_needed)
+int tts_tidl_request_initialize(unsigned int uid, bool* credential_needed)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_initialize");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_finalize(int uid)
+int tts_tidl_request_finalize(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_finalize");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
+int tts_tidl_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_text");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_set_private_data(int uid, const char* key, const char* data)
+int tts_tidl_request_set_private_data(unsigned int uid, const char* key, const char* data)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_private_data");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_get_private_data(int uid, const char* key, char** data)
+int tts_tidl_request_get_private_data(unsigned int uid, const char* key, char** data)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_get_private_data");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_play(int uid, const char* credential)
+int tts_tidl_request_play(unsigned int uid, const char* credential)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_stop(int uid)
+int tts_tidl_request_stop(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_pause(int uid)
+int tts_tidl_request_pause(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_pause");
}
//LCOV_EXCL_START
-int tts_tidl_request_play_pcm(int uid)
+int tts_tidl_request_play_pcm(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_play_pcm");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_stop_pcm(int uid)
+int tts_tidl_request_stop_pcm(unsigned int uid)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_stop_pcm");
return TTS_ERROR_NONE;
}
-int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
+int tts_tidl_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_add_pcm");
}
// LCOV_EXCL_STOP
-int tts_tidl_request_set_mode(int uid, tts_mode_e mode)
+int tts_tidl_request_set_mode(unsigned int uid, tts_mode_e mode)
{
SLOG(LOG_DEBUG, TAG_TTSC, "[TIDL] tts_tidl_request_set_mode");
extern "C" {
#endif
-int tts_tidl_open_connection(int uid);
+int tts_tidl_open_connection(unsigned int uid);
-int tts_tidl_close_connection(int uid);
+int tts_tidl_close_connection(unsigned int uid);
-int tts_tidl_stop_listening(int uid);
+int tts_tidl_stop_listening(unsigned int uid);
-int tts_tidl_request_hello(int uid);
+int tts_tidl_request_hello(unsigned int uid);
-int tts_tidl_request_hello_sync(int uid);
+int tts_tidl_request_hello_sync(unsigned int uid);
-int tts_tidl_request_initialize(int uid, bool* credential_needed);
+int tts_tidl_request_initialize(unsigned int uid, bool* credential_needed);
-int tts_tidl_request_finalize(int uid);
+int tts_tidl_request_finalize(unsigned int uid);
-int tts_tidl_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
+int tts_tidl_request_add_text(unsigned int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential);
-int tts_tidl_request_play(int uid, const char* credential);
+int tts_tidl_request_play(unsigned int uid, const char* credential);
-int tts_tidl_request_stop(int uid);
+int tts_tidl_request_stop(unsigned int uid);
-int tts_tidl_request_pause(int uid);
+int tts_tidl_request_pause(unsigned int uid);
-int tts_tidl_request_set_private_data(int uid, const char* key, const char* data);
+int tts_tidl_request_set_private_data(unsigned int uid, const char* key, const char* data);
-int tts_tidl_request_get_private_data(int uid, const char* key, char** data);
+int tts_tidl_request_get_private_data(unsigned int uid, const char* key, char** data);
-int tts_tidl_request_play_pcm(int uid);
+int tts_tidl_request_play_pcm(unsigned int uid);
-int tts_tidl_request_stop_pcm(int uid);
+int tts_tidl_request_stop_pcm(unsigned int uid);
-int tts_tidl_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate);
+int tts_tidl_request_add_pcm(unsigned int uid, int event, const char* data, int data_size, int audio_type, int rate);
-int tts_tidl_request_set_mode(int uid, tts_mode_e mode);
+int tts_tidl_request_set_mode(unsigned int uid, tts_mode_e mode);
#ifdef __cplusplus
}
#include "tts_defs.h"
typedef struct {
- int uid;
+ unsigned int uid;
tts_config_engine_changed_cb engine_cb;
tts_config_voice_changed_cb voice_cb;
tts_config_speech_rate_changed_cb speech_cb;
if (NULL != temp_client) {
if (NULL != temp_client->engine_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%u)", temp_client->uid);
temp_client->engine_cb(config_info.engine_id, config_info.setting,
config_info.language, config_info.type,
config_info.auto_voice, config_info.credential, temp_client->user_data);
if (NULL != temp_client) {
if (NULL != temp_client->voice_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%u)", temp_client->uid);
temp_client->voice_cb(before_lang, before_type,
config_info.language, config_info.type,
config_info.auto_voice, temp_client->user_data);
if (NULL != temp_client) {
if (NULL != temp_client->speech_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate changed callback : uid(%u)", temp_client->uid);
temp_client->speech_cb(config_info.speech_rate, temp_client->user_data);
}
}
if (NULL != temp_client) {
if (NULL != temp_client->pitch_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Pitch changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Pitch changed callback : uid(%u)", temp_client->uid);
temp_client->pitch_cb(config_info.pitch, temp_client->user_data);
}
}
if (NULL != temp_client) {
if (NULL != temp_client->bg_volume_ratio_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio changed callback : uid(%u)", temp_client->uid);
temp_client->bg_volume_ratio_cb(config_info.bg_volume_ratio, temp_client->user_data);
}
}
}
}
-int __tts_config_release_client(int uid)
+int __tts_config_release_client(unsigned int uid)
{
GSList *iter = NULL;
tts_config_client_s* temp_client = NULL;
if (NULL != temp_client) {
if (NULL != temp_client->engine_cb) {
- SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%d)", temp_client->uid);
+ SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%u)", temp_client->uid);
temp_client->engine_cb(config_info.engine_id, config_info.setting,
config_info.language, config_info.type,
config_info.auto_voice, config_info.credential, temp_client->user_data);
return 0;
}
-int tts_config_mgr_initialize(int uid, tts_config_client_type_e client_type)
+int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
{
GSList *iter = NULL;
int* get_uid;
get_uid = iter->data;
if (uid == *get_uid) {
- SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] uid(%d) has already registered", uid);
+ SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] uid(%u) has already registered", uid);
return 0;
}
g_config_client_list = g_slist_append(g_config_client_list, temp_client);
- SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%d) but config has already initialized", uid);
+ SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
g_client_type |= client_type;
return 0;
}
-int tts_config_mgr_finalize(int uid, tts_config_client_type_e client_type)
+int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_type)
{
if (0 < __tts_config_release_client(uid)) {
g_client_type &= ~client_type;
return 0;
}
-int tts_config_mgr_set_callback(int uid,
+int tts_config_mgr_set_callback(unsigned int uid,
tts_config_engine_changed_cb engine_cb,
tts_config_voice_changed_cb voice_cb,
tts_config_speech_rate_changed_cb speech_cb,
return 0;
}
-int tts_config_mgr_unset_callback(int uid)
+int tts_config_mgr_unset_callback(unsigned int uid)
{
GSList *iter = NULL;
tts_config_client_s* temp_client = NULL;
return 0;
}
-int tts_config_mgr_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback, void* user_data)
+int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_screen_reader_changed_cb callback, void* user_data)
{
if (NULL == callback) {
SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
return 0;
}
-int tts_config_mgr_unset_screen_reader_callback(int uid)
+int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
{
GSList *iter = NULL;
tts_config_client_s* temp_client = NULL;
typedef void (*tts_config_screen_reader_changed_cb)(bool value, void* user_data);
-int tts_config_mgr_initialize(int uid, tts_config_client_type_e client_type);
+int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type);
-int tts_config_mgr_finalize(int uid, tts_config_client_type_e client_type);
+int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_type);
-int tts_config_mgr_set_callback(int uid,
+int tts_config_mgr_set_callback(unsigned int uid,
tts_config_engine_changed_cb engine_cb,
tts_config_voice_changed_cb voice_cb,
tts_config_speech_rate_changed_cb speech_cb,
tts_config_bg_volume_ratio_changed_cb bg_volume_ratio_cb,
void* user_data);
-int tts_config_mgr_unset_callback(int uid);
+int tts_config_mgr_unset_callback(unsigned int uid);
/* Only for screen reader option */
-int tts_config_mgr_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback, void* user_data);
+int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_screen_reader_changed_cb callback, void* user_data);
-int tts_config_mgr_unset_screen_reader_callback(int uid);
+int tts_config_mgr_unset_screen_reader_callback(unsigned int uid);
int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data);
#define TTS_ERROR_ALREADY_INITIALIZED -999
#define TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED -1
+#define TTS_INVALID_UID 0
+
/******************************************************************************************
* Defines for vconf key
*******************************************************************************************/
int PKGMGR_MDPARSER_PLUGIN_INSTALL(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA INSTALL");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
if (0 >= g_list_length(list)) {
LOGE("[ERROR] No Engine Metadata");
int PKGMGR_MDPARSER_PLUGIN_UNINSTALL(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA UNINSTALL");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
GList *iter = NULL;
metadata *md = NULL;
int PKGMGR_MDPARSER_PLUGIN_UPGRADE(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA UPGRADE");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
PKGMGR_MDPARSER_PLUGIN_UNINSTALL(pkgid, appid, list);
PKGMGR_MDPARSER_PLUGIN_INSTALL(pkgid, appid, list);
uid_t tmp_uid = 0;
gid_t tmp_gid = 0;
- LOGD("uid(%d)", uid);
+ LOGD("uid(%u)", uid);
if (globalapp_uid == uid) {
/* Global app */
uid_t globalapp_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
- LOGD("uid(%d)", uid);
+ LOGD("uid(%u)", uid);
if (globalapp_uid == uid) {
/* Global app */
int PKGMGR_MDPARSER_PLUGIN_INSTALL(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA INSTALL");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
int ret = -1;
ret = pkgmgr_installer_info_get_target_uid(&g_uid);
LOGE("[ERROR] Fail to get target uid");
return 0;
} else {
- LOGD("uid(%d)", g_uid);
- printf("[Parser Debug][DEBUG] uid(%d)", g_uid);
+ LOGD("uid(%u)", g_uid);
+ printf("[Parser Debug][DEBUG] uid(%u)", g_uid);
}
uid_t globalapp_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
LOGD("[DEBUG] user info");
if (NULL != home_dir) {
- LOGD("[DEBUG] uid(%d), gid(%d), user_type(%s), home_dir(%s)", uid, gid, user_type, home_dir);
+ LOGD("[DEBUG] uid(%u), gid(%u), user_type(%s), home_dir(%s)", uid, gid, user_type, home_dir);
FREE(g_dir_config_base);
FREE(g_dir_home);
FREE(g_dir_engine_base);
int PKGMGR_MDPARSER_PLUGIN_UNINSTALL(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA UNINSTALL");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
int ret = -1;
ret = pkgmgr_installer_info_get_target_uid(&g_uid);
LOGE("[ERROR] Fail to get target uid");
return 0;
} else {
- LOGD("uid(%d)", g_uid);
- printf("[Parser Debug][DEBUG] uid(%d)", g_uid);
+ LOGD("uid(%u)", g_uid);
+ printf("[Parser Debug][DEBUG] uid(%u)", g_uid);
}
uid_t globalapp_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
if (globalapp_uid == g_uid) {
g_user_type = g_strdup("admin");
- LOGD("[DEBUG] g_user_type: %s (%d)", g_user_type, globalapp_uid);
+ LOGD("[DEBUG] g_user_type: %s (%u)", g_user_type, globalapp_uid);
} else {
g_guser = gum_user_get_sync(g_uid, FALSE);
if (NULL == g_guser) {
g_object_get(G_OBJECT(g_guser), "usertype", &g_ut, NULL);
g_user_type = g_strdup(gum_user_type_to_string(g_ut));
- LOGD("[DEBUG] g_user_type: %s (%d)", g_user_type, globalapp_uid);
+ LOGD("[DEBUG] g_user_type: %s (%u)", g_user_type, globalapp_uid);
}
if (NULL == g_user_type) {
int PKGMGR_MDPARSER_PLUGIN_UPGRADE(const char *pkgid, const char *appid, GList *list)
{
LOGD("METADATA UPGRADE");
- LOGD("pkgid(%s) appid(%s) list(%d)", pkgid, appid, g_list_length(list));
+ LOGD("pkgid(%s) appid(%s) list(%u)", pkgid, appid, g_list_length(list));
PKGMGR_MDPARSER_PLUGIN_UNINSTALL(pkgid, appid, list);
PKGMGR_MDPARSER_PLUGIN_INSTALL(pkgid, appid, list);
--- /dev/null
+#!/usr/bin/env bash
+#
+# Copyright (C) 2018 The SAM Tool Authors. All rights reserved.
+#
+# SAM (S/W Architecture Maturity)
+#
+# Samsung Research,
+# Samsung Electronics Co., Ltd.
+#
+# This software and its documentation are confidential and proprietary
+# information of Samsung Electronics Co., Ltd. No part of the software and
+# documents may be copied, reproduced, transmitted, translated, or reduced to
+# any electronic medium or machine-readable form without the prior written
+# consent of Samsung Electronics.
+#
+# Samsung Electronics makes no representations with respect to the contents,
+# and assumes no responsibility for any errors that might appear in the
+# software and documents. This publication and the contents here of are subject
+# to change without notice.
+#
+
+################################
+# Project Name
+################################
+SAM_PRJ_NAME="tts_refactoring"
+
+
+################################
+# Source Code
+################################
+BUILD_CMD="gbs build -A armv7l -P tizen_latest --include-all --clean"
+CLEAN_CMD="gbs build -A armv7l -P tizen_latest --include-all --clean"
+SRC_PATH=$PWD
+SRC_LANG="auto_c_cpp" # Supported languages : c, java
+SRC_SCOPE="/home/abuild/rpmbuild/BUILD/tts-1.65.4;$SRC_PATH" # Scoping list
+#SRC_EXCLUDE="config/src_exclude.cfg" # Excluding list
+
+
+################################
+# SCRA
+################################
+SCRA_SKIP=FALSE # Options : TRUE, FALSE
+SCRA_RAW_DATA_PATH=".scap/workspace/scra"
+SCRA_ROOT_TO_CUT="/home/abuild/rpmbuild/BUILD/tts-1.65.4"
+
+
+################################
+# PMD CPD (Duplicated Code)
+################################
+PMD_SKIP=FALSE # Options : TRUE, FALSE
+PMD_RAW_DATA_PATH=".scap/workspace/pmd"
+PMD_USE_BUILT_PATH=FALSE # Options : TRUE, FALSE
+PMD_ROOT_TO_CUT=$SRC_PATH
+#PMD_EXCLUDE_LIST="config/src_exclude.cfg" # Excluding list of PMD
+#PMD_RESULT_DETAIL_MODE=FALSE # Options : TRUE, FALSE
+#PMD_HEAP_SIZE=2048m
+#PMD_ENCODING="utf-8"
+
+
+################################
+# Analysis Hub (SCAP)
+################################
+SCAP_TOOL_PATH="hub/code-analysis-hub/bin/scap"
+SCAP=$SCAP_TOOL_PATH
+
+
+################################
+# Advanced Option
+################################
+#ADVANCED_SAM_OPTION="config/sam.cfg"
return 0;
}
-int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
+int ttsd_config_save_error(unsigned int uid, int uttid, const char* lang, int vctype, const char* text,
const char* func, int line, const char* message)
{
SLOG(LOG_DEBUG, tts_tag(), "@@@@@ TTS ERROR LOG @@@@@");
- SLOG(LOG_DEBUG, tts_tag(), "uid(%d) uttid(%d)", uid, uttid);
-
-
+ SLOG(LOG_DEBUG, tts_tag(), "uid(%u) uttid(%d)", uid, uttid);
SLOG(LOG_DEBUG, tts_tag(), "Function(%s) Line(%d)", (NULL == func) ? "NULL" : func, line);
SLOG(LOG_DEBUG, tts_tag(), "Message(%s)", (NULL == message) ? "NULL" : message);
SLOG(LOG_DEBUG, tts_tag(), "Lang(%s), type(%d)", (NULL == lang) ? "NULL" : lang, vctype);
/*
-* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
+* Copyright (c) 2011-2016 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
int ttsd_config_get_bg_volume_ratio(double* ratio);
-int ttsd_config_save_error(int uid, int uttid, const char* lang, int vctype, const char* text,
+int ttsd_config_save_error(unsigned int uid, int uttid, const char* lang, int vctype, const char* text,
const char* func, int line, const char* message);
#ifdef __cplusplus
typedef struct
{
int pid;
- int uid;
+ unsigned int uid;
int utt_id_stopped;
app_tts_state_e state;
ttsd_mode_e mode;
unsigned int i = 0;
for (auto& appData : g_app_list) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%d), state(%d)", i, appData.pid, appData.uid, appData.state);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, appData.pid, appData.uid, appData.state);
i++;
}
return g_synth_control.load();
}
-static app_data_s* __get_client_app_data(int uid)
+static app_data_s* __get_client_app_data(unsigned int uid)
{
for (auto& app_data : g_app_list) {
if (app_data.uid == uid) {
return nullptr;
}
-int ttsd_data_new_client(int pid, int uid)
+int ttsd_data_new_client(int pid, unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
if(nullptr != __get_client_app_data(uid) ) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is already registered (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is already registered (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
__data_show_list();
#endif
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] New client. pid(%d), uid(%d)", app.pid, app.uid);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] New client. pid(%d), uid(%u)", app.pid, app.uid);
return TTSD_ERROR_NONE;
}
app_data.utt_id_stopped = removed_last_uttid;
}
- int uid = app_data.uid;
+ unsigned int uid = app_data.uid;
for (auto& sound_data : app_data.m_wav_data) {
if (nullptr == sound_data) {
continue;
}
- SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] uid(%d), event(%d) data(%p) size(%d) rate(%d) utt(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] uid(%u), event(%d) data(%p) size(%d) rate(%d) utt(%d)",
sound_data, uid, sound_data->event, sound_data->data, sound_data->data_size, sound_data->rate, sound_data->utt_id);
if (nullptr != sound_data->data) {
app_data.m_wav_data.clear();
}
-int ttsd_data_delete_client(int uid)
+int ttsd_data_delete_client(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
int index = 0;
}
if (index >= (int)g_app_list.size()) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
__data_show_list();
#endif
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Client is deleted. uid(%d), index(%d)", uid, index);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Client is deleted. uid(%u), index(%d)", uid, index);
return TTSD_ERROR_NONE;
}
-int ttsd_data_is_client(int uid)
+int ttsd_data_is_client(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
int vsize = g_app_list.size();
}
}
- SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no corresponding client. uid(%d)", uid);
+ SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no corresponding client. uid(%u)", uid);
return -1;
}
return num_client;
}
-int ttsd_data_get_pid(int uid)
+int ttsd_data_get_pid(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return -1;
}
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%d), pid(%d)", uid, app_data->pid);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u), pid(%d)", uid, app_data->pid);
return app_data->pid;
}
-int ttsd_data_set_ipc_method(int uid, tts_ipc_method_e method)
+int ttsd_data_set_ipc_method(unsigned int uid, tts_ipc_method_e method)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-tts_ipc_method_e ttsd_data_get_ipc_method(int uid)
+tts_ipc_method_e ttsd_data_get_ipc_method(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTS_IPC_METHOD_UNDEFINED;
}
return app_data->ipc_method;
}
-int ttsd_data_set_mode(int uid, ttsd_mode_e mode)
+int ttsd_data_set_mode(unsigned int uid, ttsd_mode_e mode)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-ttsd_mode_e ttsd_data_get_mode(int uid)
+ttsd_mode_e ttsd_data_get_mode(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_MODE_DEFAULT;
}
return app_data->mode;
}
-int ttsd_data_get_speak_data_size(int uid)
+int ttsd_data_get_speak_data_size(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return app_data->m_speak_data.size();
}
-int ttsd_data_set_used_voice(int uid, const char* lang, int type)
+int ttsd_data_set_used_voice(unsigned int uid, const char* lang, int type)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return -1; /* Need to load voice*/
}
-int ttsd_data_reset_used_voice(int uid, ttsd_used_voice_cb callback)
+int ttsd_data_reset_used_voice(unsigned int uid, ttsd_used_voice_cb callback)
{
unique_lock<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_add_speak_data(int uid, speak_data_s* data)
+int ttsd_data_add_speak_data(unsigned int uid, speak_data_s* data)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
try {
list<speak_data_s*>& speakData = app_data->m_speak_data;
return 0;
}
-int ttsd_data_get_speak_data(int uid, speak_data_s** data)
+int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid(%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_add_sound_data(int uid, sound_data_s* data)
+int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_INVALID_PARAMETER;
}
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] uid(%u)", uid);
try {
list<sound_data_s*>& wavData = app_data->m_wav_data;
return 0;
}
-int ttsd_data_get_sound_data(int uid, sound_data_s** data)
+int ttsd_data_get_sound_data(unsigned int uid, sound_data_s** data)
{
SLOG(LOG_DEBUG, tts_tag(), "[DATA] sound_data_s: %p", *data);
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_get_sound_data_size(int uid)
+int ttsd_data_get_sound_data_size(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return -1;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_clear_data(int uid)
+int ttsd_data_clear_data(unsigned int uid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_get_client_state(int uid, app_tts_state_e* state)
+int ttsd_data_get_client_state(unsigned int uid, app_tts_state_e* state)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_NONE;
}
-static int __get_playing_app_uid()
+static unsigned int __get_playing_app_uid()
{
for (auto& app : g_app_list) {
if (APP_STATE_PLAYING == app.state) {
return -1;
}
-int ttsd_data_set_client_state(int uid, app_tts_state_e state)
+int ttsd_data_set_client_state(unsigned int uid, app_tts_state_e state)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
/* The client of playing state of all clients is only one. need to check state. */
int playing_uid = __get_playing_app_uid();
if (APP_STATE_PLAYING == state && 0 < playing_uid) {
- SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] A playing client has already existed. playing app uid(%d)", playing_uid);
+ SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] A playing client has already existed. playing app uid(%u)", playing_uid);
return TTSD_ERROR_OPERATION_FAILED;
}
return TTSD_ERROR_NONE;
}
-int ttsd_data_get_current_playing()
+unsigned int ttsd_data_get_current_playing()
{
lock_guard<mutex> lock(g_app_data_mutex);
- int uid = __get_playing_app_uid();
+ unsigned int uid = __get_playing_app_uid();
- SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Current playing uid(%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[DATA INFO] Current playing uid(%u)", uid);
return uid;
}
lock.unlock();
for (int i = 0; i < vsize; i++) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%d), state(%d)", i, temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%u), state(%d)", i, temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state);
if (false == callback(temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state, user_data)) {
break;
}
return 0;
}
-bool ttsd_data_is_uttid_valid(int uid, int uttid)
+bool ttsd_data_is_uttid_valid(unsigned int uid, int uttid)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
if (nullptr == app_data) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%u)", uid);
return false;
}
return number;
}
-int ttsd_data_save_error_log(int uid, FILE* fp)
+int ttsd_data_save_error_log(unsigned int uid, FILE* fp)
{
lock_guard<mutex> lock(g_app_data_mutex);
app_data_s* app_data = __get_client_app_data(uid);
typedef void (* ttsd_used_voice_cb)(const char* lang, int type);
-int ttsd_data_new_client(int pid, int uid);
+int ttsd_data_new_client(int pid, unsigned int uid);
-int ttsd_data_delete_client(int uid);
+int ttsd_data_delete_client(unsigned int uid);
-int ttsd_data_is_client(int uid);
+int ttsd_data_is_client(unsigned int uid);
int ttsd_data_get_client_count();
-int ttsd_data_get_pid(int uid);
+int ttsd_data_get_pid(unsigned int uid);
-int ttsd_data_set_ipc_method(int uid, tts_ipc_method_e method);
+int ttsd_data_set_ipc_method(unsigned int uid, tts_ipc_method_e method);
-tts_ipc_method_e ttsd_data_get_ipc_method(int uid);
+tts_ipc_method_e ttsd_data_get_ipc_method(unsigned int uid);
-int ttsd_data_set_mode(int uid, ttsd_mode_e mode);
+int ttsd_data_set_mode(unsigned int uid, ttsd_mode_e mode);
-ttsd_mode_e ttsd_data_get_mode(int uid);
+ttsd_mode_e ttsd_data_get_mode(unsigned int uid);
/* speak data */
-int ttsd_data_add_speak_data(int uid, speak_data_s* data);
+int ttsd_data_add_speak_data(unsigned int uid, speak_data_s* data);
-int ttsd_data_get_speak_data(int uid, speak_data_s** data);
+int ttsd_data_get_speak_data(unsigned int uid, speak_data_s** data);
-int ttsd_data_get_speak_data_size(int uid);
+int ttsd_data_get_speak_data_size(unsigned int uid);
int ttsd_data_clear_speak_data(speak_data_s** speak_data);
/* sound data */
-int ttsd_data_add_sound_data(int uid, sound_data_s* data);
+int ttsd_data_add_sound_data(unsigned int uid, sound_data_s* data);
-int ttsd_data_get_sound_data(int uid, sound_data_s** data);
+int ttsd_data_get_sound_data(unsigned int uid, sound_data_s** data);
-int ttsd_data_get_sound_data_size(int uid);
+int ttsd_data_get_sound_data_size(unsigned int uid);
int ttsd_data_clear_sound_data(sound_data_s** sound_data);
-int ttsd_data_clear_data(int uid);
+int ttsd_data_clear_data(unsigned int uid);
-int ttsd_data_set_used_voice(int uid, const char* lang, int type);
+int ttsd_data_set_used_voice(unsigned int uid, const char* lang, int type);
-int ttsd_data_reset_used_voice(int uid, ttsd_used_voice_cb callback);
+int ttsd_data_reset_used_voice(unsigned int uid, ttsd_used_voice_cb callback);
-int ttsd_data_get_client_state(int uid, app_tts_state_e* state);
+int ttsd_data_get_client_state(unsigned int uid, app_tts_state_e* state);
-int ttsd_data_set_client_state(int uid, app_tts_state_e state);
+int ttsd_data_set_client_state(unsigned int uid, app_tts_state_e state);
-int ttsd_data_get_current_playing();
+unsigned int ttsd_data_get_current_playing();
-typedef bool(*ttsd_data_get_client_cb)(int pid, int uid, app_tts_state_e state, void* user_data);
+typedef bool(*ttsd_data_get_client_cb)(int pid, unsigned int uid, app_tts_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);
+bool ttsd_data_is_uttid_valid(unsigned int uid, int uttid);
int ttsd_data_get_same_pid_client_count(int pid);
/* For error handing */
-int ttsd_data_save_error_log(int uid, FILE* fp);
+int ttsd_data_save_error_log(unsigned int uid, FILE* fp);
#ifdef __cplusplus
return NULL;
}
-int ttsdc_send_hello(int pid, int uid, int ret, int credential_needed)
+int ttsdc_send_hello(int pid, unsigned int uid, int ret, int credential_needed)
{
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Dbus connection is not available");
TTSD_METHOD_HELLO); /* name of the signal */
if (NULL == msg) {
- SLOG(LOG_ERROR, tts_tag(), "<<<< [Dbus ERROR] Fail to create hello message : uid(%d), ret(%d), credential_needed(%d)", uid, ret, credential_needed);
+ SLOG(LOG_ERROR, tts_tag(), "<<<< [Dbus ERROR] Fail to create hello message : uid(%u), ret(%d), credential_needed(%d)", uid, ret, credential_needed);
return -1;
} else {
- SLOG(LOG_INFO, tts_tag(), "<<<< [Dbus] Send hello message : uid(%d), ret(%d), credential_needed(%d)", uid, ret, credential_needed);
+ SLOG(LOG_INFO, tts_tag(), "<<<< [Dbus] Send hello message : uid(%u), ret(%d), credential_needed(%d)", uid, ret, credential_needed);
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &credential_needed, DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &credential_needed, DBUS_TYPE_INVALID);
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Fail to Send");
return 0;
}
-static int __send_message(int pid, int uid, int data, const char *method)
+static int __send_message(int pid, unsigned int uid, int data, const char *method)
{
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Dbus connection is not available");
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Fail to create message : %s", method);
return -1;
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[Dbus] Send %s message : uid(%d) data(%d)", method, uid, data);
+ SLOG(LOG_DEBUG, tts_tag(), "[Dbus] Send %s message : uid(%u) data(%d)", method, uid, data);
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &data, DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INT32, &data, DBUS_TYPE_INVALID);
if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Fail to Send");
return 0;
}
-int ttsdc_dbus_send_utt_start_message(int pid, int uid, int uttid)
+int ttsdc_dbus_send_utt_start_message(int pid, unsigned int uid, int uttid)
{
return __send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_STARTED);
}
-int ttsdc_dbus_send_utt_finish_message(int pid, int uid, int uttid)
+int ttsdc_dbus_send_utt_finish_message(int pid, unsigned int uid, int uttid)
{
return __send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_COMPLETED);
}
-int ttsdc_dbus_send_set_state_message(int pid, int uid, int state)
+int ttsdc_dbus_send_set_state_message(int pid, unsigned int uid, int state)
{
return __send_message(pid, uid, state, TTSD_METHOD_SET_STATE);
}
-int ttsdc_dbus_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg)
+int ttsdc_dbus_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg)
{
if (NULL == g_conn_sender) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Dbus connection is not available");
TTSD_METHOD_ERROR); /* name of the signal */
if (NULL == msg) {
- SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Fail to create error message : uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] Fail to create error message : uid(%u)", uid);
return -1;
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &uttid,
DBUS_TYPE_INT32, &reason,
DBUS_TYPE_STRING, &err_msg,
if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, tts_tag(), "[Dbus ERROR] <<<< error message : Out Of Memory !");
} else {
- SLOG(LOG_DEBUG, tts_tag(), "<<<< Send error message : uid(%d), reason(%s), uttid(%d), err_msg(%s)",
+ SLOG(LOG_DEBUG, tts_tag(), "<<<< Send error message : uid(%u), reason(%s), uttid(%d), err_msg(%s)",
uid, __ttsd_get_error_code(reason), uttid, (NULL == err_msg) ? "NULL" : err_msg);
dbus_connection_flush(g_conn_sender);
}
int ttsd_dbus_close_connection();
-int ttsdc_send_hello(int pid, int uid, int ret, int credential_needed);
+int ttsdc_send_hello(int pid, unsigned int uid, int ret, int credential_needed);
-int ttsdc_dbus_send_utt_start_message(int pid, int uid, int uttid);
+int ttsdc_dbus_send_utt_start_message(int pid, unsigned int uid, int uttid);
-int ttsdc_dbus_send_utt_finish_message(int pid, int uid, int uttid);
+int ttsdc_dbus_send_utt_finish_message(int pid, unsigned int uid, int uttid);
-int ttsdc_dbus_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg);
+int ttsdc_dbus_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg);
-int ttsdc_dbus_send_set_state_message(int pid, int uid, int state);
+int ttsdc_dbus_send_set_state_message(int pid, unsigned int uid, int state);
#ifdef __cplusplus
#include "ttsd_dbus_server.h"
#include "ttsd_server.h"
-extern int ttsd_data_get_pid(const int uid);
+extern int ttsd_data_get_pid(const unsigned int uid);
/*
* Dbus Client-Daemon Server
dbus_error_init(&err);
int pid;
- int uid;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ unsigned int uid;
+ dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : get arguments error (%s)", err.message);
dbus_error_free(&err);
} else {
- SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : pid(%d), uid(%u)", pid, uid);
bool is_initialized = false;
bool is_credential_needed = false;
int credential_needed = 0;
credential_needed = 1;
}
} else {
- SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : already initialized. pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_INFO, tts_tag(), "[IN] ttsd hello : already initialized. pid(%d), uid(%u)", pid, uid);
ret = TTS_ERROR_ALREADY_INITIALIZED;
credential_needed = TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED;
}
- SLOG(LOG_INFO, tts_tag(), "[INFO] send_hello. pid(%d), uid(%d), ret(%d), credential_needed(%d)", pid, uid, ret, credential_needed);
+ SLOG(LOG_INFO, tts_tag(), "[INFO] send_hello. pid(%d), uid(%u), ret(%d), credential_needed(%d)", pid, uid, ret, credential_needed);
ttsdc_send_hello(pid, uid, ret, credential_needed);
}
dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS INITIALIZE");
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts initialize : pid(%d), uid(%d)", pid , uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts initialize : pid(%d), uid(%u)", pid , uid);
ret = ttsd_server_initialize(pid, uid, TTS_IPC_METHOD_DBUS, &credential_needed);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = 0;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS FINALIZE");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts finalize : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts finalize : uid(%u)", uid);
ret = ttsd_server_finalize(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int tmp_mode;
ttsd_mode_e mode;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &tmp_mode,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[IN] tts set mode. uid(%d), mode(%d)", uid, mode);
+ SLOG(LOG_DEBUG, tts_tag(), "[IN] tts set mode. uid(%u), mode(%d)", uid, mode);
ret = ttsd_server_set_mode(uid, mode);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = 0;
GList* voice_list = NULL;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS GET VOICES");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] get supported voices : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] get supported voices : uid(%u)", uid);
ret = ttsd_server_get_support_voices(uid, &voice_list);
}
if (0 == ret) {
/* Append voice size */
- int size = g_list_length(voice_list);
+ unsigned int size = g_list_length(voice_list);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
SLOG(LOG_ERROR, tts_tag(), "[OUT ERROR] tts supported voices : Fail to append type");
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* lang = NULL;
int voice_type;
int ret;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS GET DEFAULT VOICE");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts get default voice : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts get default voice : uid(%u)", uid);
ret = ttsd_server_get_current_voice(uid, &lang, &voice_type);
}
DBusError err;
dbus_error_init(&err);
- int uid, voicetype, speed, uttid;
+ unsigned int uid, voicetype, speed, uttid;
char *text, *lang, *credential;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &text,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_INT32, &voicetype,
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), uttid(%d), credential(%s)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts add text : uid(%u), text(%s), lang(%s), type(%d), speed(%d), uttid(%d), credential(%s)",
uid, (NULL == text) ? "NULL" : text, (NULL == lang) ? "NULL" : lang, voicetype, speed, uttid, (NULL == credential) ? "NULL" : credential);
ret = ttsd_server_add_queue(uid, text, lang, voicetype, speed, uttid, credential);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* credential;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &credential,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts play : uid(%d), credential(%s)", uid, (NULL == credential) ? "NULL" : credential);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts play : uid(%u), credential(%s)", uid, (NULL == credential) ? "NULL" : credential);
ret = ttsd_server_play(uid, credential);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS STOP");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts stop : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts stop : uid(%u)", uid);
ret = ttsd_server_stop(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int uttid;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PAUSE");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts pause : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts pause : uid(%u)", uid);
ret = ttsd_server_pause(uid, &uttid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* key;
char* data;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &key,
DBUS_TYPE_STRING, &data,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* key = NULL;
char* data = NULL;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &key,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[IN] tts get private data(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[IN] tts get private data : uid(%u)", uid);
ret = ttsd_server_get_private_data(uid, key, &data);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PLAY PCM");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts play pcm : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts play pcm : uid(%u)", uid);
ret = ttsd_server_play_pcm(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS STOP PCM");
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts stop pcm : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts stop pcm : uid(%u)", uid);
ret = ttsd_server_stop_pcm(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int event;
int audio_type;
int rate;
int ret = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &event,
DBUS_TYPE_INT32, &audio_type,
DBUS_TYPE_INT32, &rate,
dbus_error_free(&err);
ret = TTSD_ERROR_OPERATION_FAILED;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts add pcm : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[IN] tts add pcm : uid(%u)", uid);
ret = ttsd_server_add_pcm(uid, event, (void*)data, data_size, audio_type, rate);
}
ret = g_engine_info->callbacks->is_valid_voice(g_engine_info->default_lang, g_engine_info->default_vctype, &is_valid);
if (0 == ret) {
if (true == is_valid) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s), type(%d)",
+ SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s), type(%d)",
g_engine_info->default_lang, g_engine_info->default_vctype);
} else {
SLOG(LOG_WARN, tts_tag(), "[Engine Agent WARNING] Fail to set origin default voice : lang(%s), type(%d)",
/* set default pitch */
ret = g_engine_info->callbacks->set_pitch(g_engine_info->default_pitch);
if (0 != ret) {
- SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to set pitch : pitch(%d), result(%s)",
+ SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Fail to set pitch : pitch(%d), result(%s)",
g_engine_info->default_pitch, __ttsd_get_engine_error_code(ret));
return ret;
} else {
return false;
}
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Select voice : input lang(%s), input type(%d), default lang(%s), default type(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Select voice : input lang(%s), input type(%d), default lang(%s), default type(%d)",
(NULL == lang) ? "NULL" : lang, type, (NULL == g_engine_info->default_lang) ? "NULL" : g_engine_info->default_lang, g_engine_info->default_vctype);
/* case 1 : Both are default */
ret = g_engine_info->callbacks->is_valid_voice(language, vctype, &is_valid);
if (0 == ret) {
if (true == is_valid) {
- SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Current voice is valid : lang(%s), type(%d)",
+ SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Current voice is valid : lang(%s), type(%d)",
(NULL == g_engine_info->default_lang) ? "NULL" : g_engine_info->default_lang, g_engine_info->default_vctype);
} else {
SLOG(LOG_WARN, tts_tag(), "[Engine Agent WARNING] Current voice is invalid : lang(%s), type(%d)",
/* load voice */
ret = g_engine_info->callbacks->load_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] load voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = true;
} else {
/* Unload voice */
ret = g_engine_info->callbacks->unload_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = false;
} else {
return 0;
}
-int ttsd_engine_agent_is_credential_needed(int uid, bool* credential_needed)
+int ttsd_engine_agent_is_credential_needed(unsigned int uid, bool* credential_needed)
{
if (NULL == credential_needed) {
SLOG(LOG_ERROR, tts_tag(), "[Engine Agent ERROR] Invalid Parameter");
/* load voice */
ret = g_engine_info->callbacks->load_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Load voice : lang(%s), type(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Load voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = true;
} else {
/* unload voice */
ret = g_engine_info->callbacks->unload_voice(data->lang, data->type);
if (0 == ret) {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent SUCCESS] Unload voice : lang(%s), type(%d)",
data->lang, data->type);
data->is_loaded = false;
} else {
}
return TTSD_ERROR_INVALID_VOICE;
} else {
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), speed(%d), text(%s), credential(%s)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), speed(%d), text(%s), credential(%s)",
(NULL == temp_lang) ? "NULL" : temp_lang, temp_type, speed, (NULL == text) ? "NULL" : text, (NULL == credential) ? "NULL" : credential);
}
/*
-* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
+* Copyright (c) 2011-2016 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
int ttsd_engine_agent_set_default_pitch(int pitch);
-int ttsd_engine_agent_is_credential_needed(int uid, bool* credential_needed);
+int ttsd_engine_agent_is_credential_needed(unsigned int uid, bool* credential_needed);
int ttsd_engine_set_private_data(const char* key, const char* data);
return TTSD_ERROR_NONE;
}
-int ttsdc_ipc_send_utt_start_message(int pid, int uid, int uttid)
+int ttsdc_ipc_send_utt_start_message(int pid, unsigned int uid, int uttid)
{
SLOG(LOG_INFO, tts_tag(), "[IPC] ttsdc_ipc_send_utt_start_message");
if (0 > ttsd_data_is_client(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_OPERATION_FAILED;
}
-int ttsdc_ipc_send_utt_finish_message(int pid, int uid, int uttid)
+int ttsdc_ipc_send_utt_finish_message(int pid, unsigned int uid, int uttid)
{
SLOG(LOG_INFO, tts_tag(), "[IPC] ttsdc_ipc_send_utt_finish_message");
if (0 > ttsd_data_is_client(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_OPERATION_FAILED;
}
-int ttsdc_ipc_send_set_state_message(int pid, int uid, int state)
+int ttsdc_ipc_send_set_state_message(int pid, unsigned int uid, int state)
{
SLOG(LOG_INFO, tts_tag(), "[IPC] ttsdc_ipc_send_set_state_message");
if (0 > ttsd_data_is_client(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_OPERATION_FAILED;
}
-int ttsdc_ipc_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg)
+int ttsdc_ipc_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg)
{
SLOG(LOG_INFO, tts_tag(), "[IPC] ttsdc_ipc_send_error_message");
if (0 > ttsd_data_is_client(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] uid is not valid (%u)", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
int ttsd_ipc_close_connection();
-int ttsdc_ipc_send_hello(int pid, int uid, int ret, int credential_needed);
+int ttsdc_ipc_send_hello(int pid, unsigned int uid, int ret, int credential_needed);
-int ttsdc_ipc_send_utt_start_message(int pid, int uid, int uttid);
+int ttsdc_ipc_send_utt_start_message(int pid, unsigned int uid, int uttid);
-int ttsdc_ipc_send_utt_finish_message(int pid, int uid, int uttid);
+int ttsdc_ipc_send_utt_finish_message(int pid, unsigned int uid, int uttid);
-int ttsdc_ipc_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg);
+int ttsdc_ipc_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg);
-int ttsdc_ipc_send_set_state_message(int pid, int uid, int state);
+int ttsdc_ipc_send_set_state_message(int pid, unsigned int uid, int state);
#ifdef __cplusplus
}
} audio_state_e;
typedef struct {
- int uid; /** client id */
+ unsigned int uid; /** client id */
app_tts_state_e state; /** client state */
/* Current utterance information */
return true;
}
-player_s* __player_get_item(int uid)
+player_s* __player_get_item(unsigned int uid)
{
GList *iter = NULL;
player_s *data = NULL;
return;
}
- int uid = g_playing_info->uid;
+ unsigned int uid = g_playing_info->uid;
ttsd_mode_e mode = ttsd_data_get_mode(uid);
switch (mode) {
ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
int pid = ttsd_data_get_pid(uid);
if (pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get pid. uid(%d)", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get pid. uid(%u)", uid);
} else {
/* send message to client about changing state */
- SLOG(LOG_INFO, tts_tag(), "[Player INFO] Player paused. pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Player paused. pid(%d), uid(%u)", pid, uid);
ttsdc_ipc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
}
break;
(TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
int pid = ttsd_data_get_pid(player->uid);
if (pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%d)", player->uid);
+ SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
ttsd_data_clear_sound_data(&sound_data);
__set_playing_status(true);
if (0 != ttsdc_ipc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
- SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%u), uttid(%d)",
pid, player->uid, sound_data->utt_id);
}
- SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%u), uttid(%d)", player->uid, sound_data->utt_id);
} // (TTSE_RESULT_EVENT_START == sound_data->event || (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event))
/* Save last event to check utterance start */
int pid = ttsd_data_get_pid(player->uid);
if (pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%d)", player->uid);
+ SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
ttsd_data_clear_sound_data(&sound_data);
__set_playing_status(false);
if (0 != ttsdc_ipc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
- SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%u), uttid(%d)",
pid, player->uid, sound_data->utt_id);
} else {
- SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%u), uttid(%d)", player->uid, sound_data->utt_id);
}
} // TTSE_RESULT_EVENT_FINISH == sound_data->event
- SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%d), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%u), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
ttsd_data_clear_sound_data(&sound_data);
pthread_mutex_unlock(&g_play_thread_mutex);
continue;
} // (AUDIO_STATE_READY == g_audio_state || AUDIO_STATE_WAIT_FOR_PLAYING == g_audio_state)
char* temp_data = sound_data->data;
- SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)",
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%u), utt_id(%d), len(%d)",
temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len);
#ifdef BUF_SAVE_MODE
/* write pcm buffer */
int pid = ttsd_data_get_pid(player->uid);
if (pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%d)", player->uid);
+ SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid. uid(%u)", player->uid);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
ttsd_data_clear_sound_data(&sound_data);
__set_playing_status(false);
if (0 != ttsdc_ipc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
- SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
+ SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%u), uttid(%d)",
pid, player->uid, sound_data->utt_id);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
return;
}
- SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%u), uttid(%d)", player->uid, sound_data->utt_id);
} // ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) && (TTSE_RESULT_EVENT_FINISH == sound_data->event))
ttsd_data_clear_sound_data(&sound_data);
return 0;
}
-int ttsd_player_create_instance(int uid)
+int ttsd_player_create_instance(unsigned int uid)
{
if (false == g_player_init) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
/* Check uid is duplicated */
if (NULL != __player_get_item(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%u) is already registered", uid);
return -1;
}
new_client->idx = 0;
new_client->paused_data = NULL;
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%u)", uid);
g_player_list = g_list_append(g_player_list, new_client);
return 0;
}
-int ttsd_player_destroy_instance(int uid)
+int ttsd_player_destroy_instance(unsigned int uid)
{
pthread_mutex_lock(&g_player_control_mutex);
if (false == g_player_init) {
player_s* current;
current = __player_get_item(uid);
if (NULL == current) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%u) is not valid", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return -1;
}
return 0;
}
-int ttsd_player_play(int uid)
+int ttsd_player_play(unsigned int uid)
{
pthread_mutex_lock(&g_player_control_mutex);
if (false == g_player_init) {
if (NULL != g_playing_info) {
if (uid == g_playing_info->uid) {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%u) has already played", g_playing_info->uid);
pthread_mutex_unlock(&g_player_control_mutex);
return 0;
} else {
- SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%u)", g_playing_info->uid);
pthread_mutex_unlock(&g_player_control_mutex);
ttsd_player_stop(g_playing_info->uid);
pthread_mutex_lock(&g_player_control_mutex);
}
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%u)", uid);
/* Check uid */
player_s* current;
current = __player_get_item(uid);
if (NULL == current) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%u) is not valid", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return -1;
}
return 0;
}
-int ttsd_player_stop(int uid)
+int ttsd_player_stop(unsigned int uid)
{
pthread_mutex_lock(&g_player_control_mutex);
return ret;
}
- SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%u)", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return 0;
}
-int ttsd_player_clear(int uid)
+int ttsd_player_clear(unsigned int uid)
{
if (false == g_player_init) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
player_s* current;
current = __player_get_item(uid);
if (NULL == current) {
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%u) is not valid", uid);
return -1;
}
current->is_paused_data = false;
current->idx = 0;
- SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%u)", uid);
return 0;
}
-int ttsd_player_pause(int uid)
+int ttsd_player_pause(unsigned int uid)
{
pthread_mutex_lock(&g_player_control_mutex);
- SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%u)", uid);
if (false == g_player_init) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
player_s* current;
current = __player_get_item(uid);
if (NULL == current) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%u) is not valid", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return -1;
}
if (NULL != g_playing_info) {
if (uid == g_playing_info->uid) {
/* release current playing info */
- SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%u)", uid);
g_playing_info = NULL;
} else {
/* error case */
}
__set_playing_status(false);
- SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%u)", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return 0;
}
-int ttsd_player_resume(int uid)
+int ttsd_player_resume(unsigned int uid)
{
pthread_mutex_lock(&g_player_control_mutex);
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%u)", uid);
if (false == g_player_init) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
player_s* current;
current = __player_get_item(uid);
if (NULL == current) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%u) is not valid", uid);
pthread_mutex_unlock(&g_player_control_mutex);
return -1;
}
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(data->uid, &state)) {
- SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
+ SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%u) is not valid", data->uid);
pthread_mutex_unlock(&g_player_control_mutex);
ttsd_player_destroy_instance(data->uid);
pthread_mutex_lock(&g_player_control_mutex);
return TTSD_ERROR_NONE;
}
-int ttsd_player_wait_to_play(int uid)
+int ttsd_player_wait_to_play(unsigned int uid)
{
- SLOG(LOG_INFO, tts_tag(), "[Player INFO] wait to play (%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] wait to play (%u)", uid);
g_audio_state = AUDIO_STATE_WAIT_FOR_PLAYING;
int ttsd_player_release(void);
-int ttsd_player_create_instance(int uid);
+int ttsd_player_create_instance(unsigned int uid);
-int ttsd_player_destroy_instance(int uid);
+int ttsd_player_destroy_instance(unsigned int uid);
-int ttsd_player_play(int uid);
+int ttsd_player_play(unsigned int uid);
-int ttsd_player_stop(int uid);
+int ttsd_player_stop(unsigned int uid);
-int ttsd_player_clear(int uid);
+int ttsd_player_clear(unsigned int uid);
-int ttsd_player_pause(int uid);
+int ttsd_player_pause(unsigned int uid);
-int ttsd_player_resume(int uid);
+int ttsd_player_resume(unsigned int uid);
int ttsd_player_all_stop();
int ttsd_player_set_background_volume_ratio(double ratio);
-int ttsd_player_wait_to_play(int uid);
+int ttsd_player_wait_to_play(unsigned int uid);
#ifdef __cplusplus
}
static int g_file_num;
typedef struct {
- int uid;
+ unsigned int uid;
int uttid;
} utterance_t;
/* Function definitions */
-static int __synthesis(int uid, const char* credential);
+static int __synthesis(unsigned int uid, const char* credential);
static Eina_Bool __wait_synthesis(void *data)
{
/* get current play */
char* credential = (char*)data;
- int uid = ttsd_data_get_current_playing();
+ unsigned int uid = ttsd_data_get_current_playing();
if (uid > 0) {
ttsd_synthesis_control_e synth_control = ttsd_get_synth_control();
return EINA_FALSE;
}
-static int __synthesis(int uid, const char* credential)
+static int __synthesis(unsigned int uid, const char* credential)
{
SLOG(LOG_DEBUG, tts_tag(), "@@@ SYNTHESIS START");
int pid = ttsd_data_get_pid(uid);
if (pid <= 0) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get pid. uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get pid. uid(%u)", uid);
return -1;
}
g_utt.uttid = speak_data->utt_id;
SLOG(LOG_INFO, tts_tag(), "-----------------------------------------------------------");
- SLOG(LOG_INFO, tts_tag(), "ID : uid (%d), uttid(%d) ", g_utt.uid, g_utt.uttid);
+ SLOG(LOG_INFO, tts_tag(), "ID : uid (%u), uttid(%d) ", g_utt.uid, g_utt.uttid);
SLOG(LOG_INFO, tts_tag(), "Voice : langauge(%s), type(%d), speed(%d)", speak_data->lang, speak_data->vctype, speak_data->speed);
SLOG(LOG_INFO, tts_tag(), "Text : %s", speak_data->text);
SLOG(LOG_INFO, tts_tag(), "Credential : %s", credential);
int pid = ttsd_data_get_pid(uid);
if (pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to send set_state_message. uid(%d)", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to send set_state_message. uid(%u)", uid);
} else {
ttsdc_ipc_send_set_state_message(pid, uid, APP_STATE_READY);
}
*/
int ttsd_send_error(ttse_error_e error, const char* msg)
{
- int uid = g_utt.uid;
+ unsigned int uid = g_utt.uid;
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, (NULL == msg ? "NULL" : msg));
+ SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Error msg from engine, pid(%d), uid(%u), uttid(%d), error(%d), msg(%s)", tmp_pid, uid, uttid, error, (NULL == msg ? "NULL" : msg));
ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_EXPIRED);
{
SLOG(LOG_DEBUG, tts_tag(), "@@@ SEND SYNTHESIS RESULT START");
- int uid = g_utt.uid;
+ unsigned int uid = g_utt.uid;
int uttid = g_utt.uttid;
if (false == ttsd_data_is_uttid_valid(uid, uttid)) {
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_ERROR, tts_tag(), "[SERVER ERROR] uttid is NOT valid !!!! - uid(%u), uttid(%d)", uid, uttid);
SLOG(LOG_DEBUG, tts_tag(), "@@@");
return TTSD_ERROR_INVALID_PARAMETER;
}
return TTSD_ERROR_INVALID_PARAMETER;
}
- SLOG(LOG_INFO, tts_tag(), "[Server] uid(%d), current state(%d)", uid, state);
+ SLOG(LOG_INFO, tts_tag(), "[Server] uid(%u), current state(%d)", uid, state);
if (APP_STATE_CREATED == state || APP_STATE_READY == state) {
ttsd_set_synth_control(TTSD_SYNTHESIS_CONTROL_DONE);
SLOG(LOG_WARN, tts_tag(), "[SERVER WARNING] Current state is %d. The synthesized result is ignored.", state);
/* Synthesis is success */
if (TTSE_RESULT_EVENT_START == event) {
SLOG(LOG_INFO, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_START");
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Result Info : uid(%d), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Result Info : uid(%u), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
uid, uttid, data, data_size, audio_type, rate);
clock_gettime(CLOCK_MONOTONIC_RAW, &g_start_playing);
SLOG(LOG_INFO, tts_tag(), "[Server] File num(%d), Avg Latency(%lf), Min(%lf), Max(%lf)", g_file_num, (g_avg_latency / (double)g_file_num), g_min_latency, g_max_latency);
} else if (TTSE_RESULT_EVENT_FINISH == event) {
SLOG(LOG_INFO, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_FINISH");
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Result Info : uid(%d), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Result Info : uid(%u), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
uid, uttid, data, data_size, audio_type, rate);
} else {
/*if (TTSE_RESULT_EVENT_CONTINUE == event) SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_CONTINUE");*/
if (NULL != temp_sound_data->data) {
memcpy(temp_sound_data->data, data, data_size);
temp_sound_data->data_size = data_size;
- SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%d), event(%d) sound_data(%p) data(%p) size(%d)",
+ SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%u), event(%d) sound_data(%p) data(%p) size(%d)",
uid, event, temp_sound_data, temp_sound_data->data, temp_sound_data->data_size);
} else {
SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
temp_sound_data->rate = rate;
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);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Fail to add sound data : uid(%u)", uid);
if (NULL != temp_sound_data->data) {
free(temp_sound_data->data);
temp_sound_data->data = NULL;
return TTSD_ERROR_NONE;
}
-bool __get_client_cb(int pid, int uid, app_tts_state_e state, void* user_data)
+bool __get_client_cb(int pid, unsigned int uid, app_tts_state_e state, void* user_data)
{
/* clear client data */
ttsd_data_clear_data(uid);
return;
}
-bool __terminate_client(int pid, int uid, app_tts_state_e state, void* user_data)
+bool __terminate_client(int pid, unsigned 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);
* TTS Server Functions for Client
*/
-int ttsd_server_is_already_initialized(int pid, int uid, bool* is_initialized)
+int ttsd_server_is_already_initialized(int pid, unsigned int uid, bool* is_initialized)
{
if (-1 != ttsd_data_is_client(uid))
*is_initialized = true;
else
*is_initialized = false;
- SLOG(LOG_INFO, tts_tag(), "[Server INFO] Pid(%d), Uid(%d) is %s", pid, uid, *is_initialized ? "already initialized" : "not initialized yet");
+ SLOG(LOG_INFO, tts_tag(), "[Server INFO] Pid(%d), uid(%u) is %s", pid, uid, *is_initialized ? "already initialized" : "not initialized yet");
return TTSD_ERROR_NONE;
}
-int ttsd_server_initialize(int pid, int uid, tts_ipc_method_e method, bool* credential_needed)
+int ttsd_server_initialize(int pid, unsigned int uid, tts_ipc_method_e method, bool* credential_needed)
{
SLOG(LOG_INFO, tts_tag(), "[Server] Server initialize");
return;
}
-bool __get_client_for_clean_up(int pid, int uid, app_tts_state_e state, void* user_data)
+bool __get_client_for_clean_up(int pid, unsigned int uid, app_tts_state_e state, void* user_data)
{
bool exist = false;
int i = 0;
iter = g_list_nth(g_proc_list, i);
if (NULL != iter) {
if (pid == GPOINTER_TO_INT(iter->data)) {
- SLOG(LOG_DEBUG, tts_tag(), "uid (%d) is running", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "uid (%u) is running", uid);
exist = true;
break;
}
}
if (false == exist) {
- SLOG(LOG_ERROR, tts_tag(), "uid (%d) should be removed", uid);
+ SLOG(LOG_ERROR, tts_tag(), "uid (%u) should be removed", uid);
ttsd_server_finalize(uid);
}
result = ttsdc_send_hello(pid, uid);
if (0 == result) {
- SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%d) should be removed.", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%u) should be removed.", uid);
ttsd_server_finalize(uid);
} else if (-1 == result) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Hello result has error");
}
}
-int ttsd_server_finalize(int uid)
+int ttsd_server_finalize(unsigned int uid)
{
SLOG(LOG_INFO, tts_tag(), "[Server] Server finalize");
SLOG(LOG_INFO, tts_tag(), "[Server] File num(%d), Avg Latency(%lf), Min(%lf), Max(%lf)", g_file_num, (g_avg_latency / (double)g_file_num), g_min_latency, g_max_latency);
return TTSD_ERROR_NONE;
}
-int ttsd_server_set_mode(int uid, ttsd_mode_e mode)
+int ttsd_server_set_mode(unsigned int uid, ttsd_mode_e mode)
{
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);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%u) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
if (0 != ret) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set mode : ret(%d)", ret);
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Set mode. uid(%d), mode(%d)", uid, mode);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Set mode. uid(%u), mode(%d)", uid, mode);
}
return ret;
}
-int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice_type, int speed, int utt_id, const char* credential)
+int ttsd_server_add_queue(unsigned int uid, const char* text, const char* lang, int voice_type, int speed, int utt_id, const char* credential)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
Eina_Bool __send_interrupt_client(void *data)
{
- intptr_t puid = (intptr_t)data;
- int uid = (int)puid;
-
+ unsigned int uid = (uintptr_t)data;
int pid = ttsd_data_get_pid(uid);
if (pid <= 0) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get pid. uid(%d), pid(%d)", uid, pid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to get pid. uid(%u), pid(%d)", uid, pid);
return EINA_FALSE;
}
return EINA_FALSE;
}
-int ttsd_server_play(int uid, const char* credential)
+int ttsd_server_play(unsigned int uid, const char* credential)
{
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);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%u) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
if (APP_STATE_PLAYING == state) {
- SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Current state(%d) is 'play' ", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Current state of (%u) is 'PLAYING'", uid);
return TTSD_ERROR_NONE;
}
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);
+ unsigned int current_uid = ttsd_data_get_current_playing();
+ SLOG(LOG_INFO, tts_tag(), "[Server] playing uid (%u)", current_uid);
if (uid != current_uid && -1 != current_uid) {
if (TTSD_MODE_DEFAULT != ttsd_data_get_mode(current_uid)) {
/* Send interrupt message */
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%d) will be interrupted into 'Stop' state ", current_uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%u) will be interrupted into 'Stop' state ", current_uid);
/* pause player */
if (0 != ttsd_server_stop(current_uid)) {
- SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to stop server and player : uid (%d)", current_uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to stop server and player : uid (%u)", current_uid);
}
- intptr_t pcurrent_uid = (intptr_t)current_uid;
- ecore_timer_add(0, __send_interrupt_client, (void*)pcurrent_uid);
+ uintptr_t p_current_uid = (uintptr_t)current_uid;
+ ecore_timer_add(0, __send_interrupt_client, (void*)p_current_uid);
} else {
/* Default mode policy of interrupt is "Pause" */
/* Send interrupt message */
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%d) will be interrupted into 'Pause' state ", current_uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%u) will be interrupted into 'Pause' state ", current_uid);
/* pause player */
if (0 != ttsd_player_pause(current_uid)) {
- SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to ttsd_player_pause() : uid (%d)", current_uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to ttsd_player_pause() : uid (%u)", current_uid);
}
/* change state */
ttsd_data_set_client_state(current_uid, APP_STATE_PAUSED);
- intptr_t pcurrent_uid = (intptr_t)current_uid;
- ecore_timer_add(0, __send_interrupt_client, (void*)pcurrent_uid);
+ uintptr_t p_current_uid = (uintptr_t)current_uid;
+ ecore_timer_add(0, __send_interrupt_client, (void*)p_current_uid);
}
}
/* Change current play */
if (0 != ttsd_player_wait_to_play(uid)) {
- SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to set to wait for playing : uid(%d)", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to set to wait for playing : uid(%u)", uid);
}
if (0 != ttsd_data_set_client_state(uid, APP_STATE_PLAYING)) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set state : uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set state : uid(%u)", uid);
return TTSD_ERROR_OPERATION_FAILED;
}
if (APP_STATE_PAUSED == state) {
- SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%d) is 'Pause' state : resume player", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%u) is 'Pause' state : resume player", uid);
g_is_paused = false;
SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to ttsd_player_resume()");
}
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Play player. uid(%d)", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Play player. uid(%u)", uid);
if (0 != ttsd_player_play(uid)) {
SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to ttsd_player_play()");
return TTSD_ERROR_NONE;
}
-int ttsd_server_stop(int uid)
+int ttsd_server_stop(unsigned int uid)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
return TTSD_ERROR_NONE;
}
-int ttsd_server_pause(int uid, int* utt_id)
+int ttsd_server_pause(unsigned int uid, int* utt_id)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &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);
+ SLOG(LOG_INFO, tts_tag(), "[Server] server pause, uid(%u), g_uid(%u), utt_id(%d)", uid, g_utt.uid, *utt_id);
int ret = 0;
ret = ttsd_player_pause(uid);
return TTSD_ERROR_NONE;
}
-int ttsd_server_get_support_voices(int uid, GList** voice_list)
+int ttsd_server_get_support_voices(unsigned int uid, GList** voice_list)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
return TTSD_ERROR_NONE;
}
-int ttsd_server_get_current_voice(int uid, char** language, int* voice_type)
+int ttsd_server_get_current_voice(unsigned int uid, char** language, int* voice_type)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
return TTSD_ERROR_NONE;
}
-int ttsd_server_set_private_data(int uid, const char* key, const char* data)
+int ttsd_server_set_private_data(unsigned int uid, const char* key, const char* data)
{
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);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%u) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
if (APP_STATE_READY != state) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Current state(%d) is NOT 'READY'", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Current state of (%u) is NOT 'READY'", uid);
return TTSD_ERROR_INVALID_STATE;
}
return ret;
}
-int ttsd_server_get_private_data(int uid, const char* key, char** data)
+int ttsd_server_get_private_data(unsigned int uid, const char* key, char** data)
{
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);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%u) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
if (APP_STATE_READY != state) {
- SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Current state(%d) is NOT 'READY'", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Current state of (%u) is NOT 'READY'", uid);
return TTSD_ERROR_INVALID_STATE;
}
return ret;
}
-int ttsd_server_play_pcm(int uid)
+int ttsd_server_play_pcm(unsigned int uid)
{
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);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] uid(%u) is NOT valid", uid);
return TTSD_ERROR_INVALID_PARAMETER;
}
if (APP_STATE_PLAYING == state) {
- SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Current state(%d) is 'play' ", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Current state of (%u) is 'PLAYING'", uid);
return TTSD_ERROR_NONE;
}
- int current_uid = ttsd_data_get_current_playing();
- SLOG(LOG_INFO, tts_tag(), "[Server] playing uid (%d)", current_uid);
+ unsigned int current_uid = ttsd_data_get_current_playing();
+ SLOG(LOG_INFO, tts_tag(), "[Server] playing uid (%u)", current_uid);
if (uid != current_uid && -1 != current_uid) {
if (TTSD_MODE_DEFAULT != ttsd_data_get_mode(current_uid)) {
/* Send interrupt message */
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%d) will be interrupted into 'Stop' state ", current_uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%u) will be interrupted into 'Stop' state ", current_uid);
/* pause player */
if (0 != ttsd_server_stop(current_uid)) {
- SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to stop server and player : uid (%d)", current_uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to stop server and player : uid (%u)", current_uid);
}
- intptr_t pcurrent_uid = (intptr_t)current_uid;
- ecore_timer_add(0, __send_interrupt_client, (void*)pcurrent_uid);
+ uintptr_t p_current_uid = (uintptr_t)current_uid;
+ ecore_timer_add(0, __send_interrupt_client, (void*)p_current_uid);
} else {
/* Default mode policy of interrupt is "Pause" */
/* Send interrupt message */
- SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%d) will be interrupted into 'Pause' state ", current_uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] Old uid(%u) will be interrupted into 'Pause' state ", current_uid);
/* pause player */
if (0 != ttsd_player_pause(current_uid)) {
- SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to ttsd_player_pause() : uid (%d)", current_uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server ERROR] Fail to ttsd_player_pause() : uid (%u)", current_uid);
}
/* change state */
ttsd_data_set_client_state(current_uid, APP_STATE_PAUSED);
- intptr_t pcurrent_uid = (intptr_t)current_uid;
- ecore_timer_add(0, __send_interrupt_client, (void*)pcurrent_uid);
+ uintptr_t p_current_uid = (uintptr_t)current_uid;
+ ecore_timer_add(0, __send_interrupt_client, (void*)p_current_uid);
}
}
/* Change current play */
if (0 != ttsd_data_set_client_state(uid, APP_STATE_PLAYING)) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set state : uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to set state : uid(%u)", uid);
return TTSD_ERROR_OPERATION_FAILED;
}
if (APP_STATE_PAUSED == state) {
- SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%d) is 'Pause' state : resume player", uid);
+ SLOG(LOG_DEBUG, tts_tag(), "[Server] uid(%u) is 'Pause' state : resume player", uid);
/* Resume player */
if (0 != ttsd_player_resume(uid)) {
}
} else {
if (0 != ttsd_player_play(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play pcm sound : uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play pcm sound : uid(%u)", uid);
// Change ready state
ttsd_server_stop_pcm(uid);
int tmp_pid = ttsd_data_get_pid(uid);
if (tmp_pid <= 0) {
- SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to send set_state_message. uid(%d)", uid);
+ SLOG(LOG_WARN, tts_tag(), "[Server WARNING] Fail to send set_state_message. uid(%u)", uid);
} else {
ttsdc_ipc_send_set_state_message(tmp_pid, uid, APP_STATE_READY);
}
return TTSD_ERROR_NONE;
}
-int ttsd_server_stop_pcm(int uid)
+int ttsd_server_stop_pcm(unsigned int uid)
{
app_tts_state_e state;
if (0 > ttsd_data_get_client_state(uid, &state)) {
return TTSD_ERROR_NONE;
}
-int ttsd_server_add_pcm(int uid, int event, void* data, int data_size, int audio_type, int rate)
+int ttsd_server_add_pcm(unsigned int uid, int event, void* data, int data_size, int audio_type, int rate)
{
SLOG(LOG_DEBUG, tts_tag(), "@@@ ADD PCM");
if (TTSE_RESULT_EVENT_START == event || TTSE_RESULT_EVENT_CONTINUE == event || TTSE_RESULT_EVENT_FINISH == event) {
if (TTSE_RESULT_EVENT_START == event) {
SLOG(LOG_INFO, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_START");
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] PCM Info : uid(%d), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] PCM Info : uid(%u), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
uid, uttid, data, data_size, audio_type, rate);
} else if (TTSE_RESULT_EVENT_FINISH == event) {
SLOG(LOG_INFO, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_FINISH");
- SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] PCM Info : uid(%d), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[SERVER] PCM Info : uid(%u), utt(%d), data(%p), data size(%d) audiotype(%d) rate(%d)",
uid, uttid, data, data_size, audio_type, rate);
} else {
/*if (TTSE_RESULT_EVENT_CONTINUE == event) SLOG(LOG_DEBUG, tts_tag(), "[SERVER] Event : TTSE_RESULT_EVENT_CONTINUE");*/
if (NULL != temp_sound_data->data) {
memcpy(temp_sound_data->data, data, data_size);
temp_sound_data->data_size = data_size;
- SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%d), event(%d) sound_data(%p) data(%p) size(%d)",
+ SLOG(LOG_INFO, tts_tag(), "[DEBUG][memcpy] uid(%u), event(%d) sound_data(%p) data(%p) size(%d)",
uid, event, temp_sound_data, temp_sound_data->data, temp_sound_data->data_size);
} else {
SLOG(LOG_ERROR, tts_tag(), "Fail to allocate memory");
temp_sound_data->rate = rate;
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);
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[SERVER ERROR] Fail to add sound data : uid(%u)", uid);
if (NULL != temp_sound_data->data) {
free(temp_sound_data->data);
}
/* if (0 != ttsd_player_play(uid)) {
- SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play sound : uid(%d)", uid);
+ SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to play sound : uid(%u)", uid);
// Change ready state
ttsd_server_stop(uid);
* Server API for client
*/
-int ttsd_server_is_already_initialized(int pid, int uid, bool* is_initialized);
+int ttsd_server_is_already_initialized(int pid, unsigned int uid, bool* is_initialized);
-int ttsd_server_initialize(int pid, int uid, tts_ipc_method_e method, bool* credential_needed);
+int ttsd_server_initialize(int pid, unsigned int uid, tts_ipc_method_e method, bool* credential_needed);
-int ttsd_server_finalize(int uid);
+int ttsd_server_finalize(unsigned int uid);
-int ttsd_server_set_mode(int uid, ttsd_mode_e mode);
+int ttsd_server_set_mode(unsigned int uid, ttsd_mode_e mode);
-int ttsd_server_get_support_voices(int uid, GList** voice_list);
+int ttsd_server_get_support_voices(unsigned int uid, GList** voice_list);
-int ttsd_server_get_current_voice(int uid, char** language, int* voice_type);
+int ttsd_server_get_current_voice(unsigned int uid, char** language, int* voice_type);
-int ttsd_server_add_queue(int uid, const char* text, const char* lang, int voice_type, int speed, int utt_id, const char* credential);
+int ttsd_server_add_queue(unsigned int uid, const char* text, const char* lang, int voice_type, int speed, int utt_id, const char* credential);
-int ttsd_server_play(int uid, const char* credential);
+int ttsd_server_play(unsigned int uid, const char* credential);
-int ttsd_server_stop(int uid);
+int ttsd_server_stop(unsigned int uid);
-int ttsd_server_pause(int uid, int* utt_id);
+int ttsd_server_pause(unsigned int uid, int* utt_id);
-int ttsd_server_set_private_data(int uid, const char* key, const char* data);
+int ttsd_server_set_private_data(unsigned int uid, const char* key, const char* data);
-int ttsd_server_get_private_data(int uid, const char* key, char** data);
+int ttsd_server_get_private_data(unsigned int uid, const char* key, char** data);
-int ttsd_server_play_pcm(int uid);
+int ttsd_server_play_pcm(unsigned int uid);
-int ttsd_server_stop_pcm(int uid);
+int ttsd_server_stop_pcm(unsigned int uid);
-int ttsd_server_add_pcm(int uid, int event, void* data, int data_size, int audio_type, int rate);
+int ttsd_server_add_pcm(unsigned int uid, int event, void* data, int data_size, int audio_type, int rate);
#ifdef __cplusplus
}
#include "ttsd_tidl.h"
typedef struct {
- int uid;
+ unsigned int uid;
rpc_port_stub_tts_notify_cb_h notify_cb_h;
} tts_tidl_proxy_info_s;
static pthread_mutex_t g_tidl_proxy_infos_mutex = PTHREAD_MUTEX_INITIALIZER;
-static tts_tidl_proxy_info_s* __get_tidl_proxy_info_s(int uid)
+static tts_tidl_proxy_info_s* __get_tidl_proxy_info_s(unsigned int uid)
{
GList* iter = NULL;
tts_tidl_proxy_info_s* info = NULL;
return NULL;
}
-void __send_msg(int pid, int uid, bundle* msg)
+void __send_msg(int pid, unsigned int uid, bundle* msg)
{
- SLOG(LOG_INFO, tts_tag(), "[TIDL] start : send msg : pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_INFO, tts_tag(), "[TIDL] start : send msg : pid(%d), uid(%u)", pid, uid);
pthread_mutex_lock(&g_tidl_proxy_infos_mutex);
tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(uid);
if (NULL == info) {
- SLOG(LOG_ERROR, tts_tag(), "[TIDL] Uid is not valid. pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_ERROR, tts_tag(), "[TIDL] Uid is not valid. pid(%d), uid(%u)", pid, uid);
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
return;
}
return;
}
- if (0 != rpc_port_stub_tts_notify_cb_invoke(handle, pid, uid, msg)) {
+ if (0 != rpc_port_stub_tts_notify_cb_invoke(handle, pid, (int)uid, msg)) {
SLOG(LOG_ERROR, tts_tag(), "[Server ERROR] Fail to send msg");
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
return;
}
- SLOG(LOG_INFO, tts_tag(), "send msg : pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_INFO, tts_tag(), "send msg : pid(%d), uid(%u)", pid, uid);
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
}
rpc_port_stub_tts_context_get_tag(context, &tag);
if (NULL != tag) {
- int uid = (intptr_t)tag;
- SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS FINALIZE. uid(%d)", uid);
+ unsigned int uid = (uintptr_t)tag;
+ SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS FINALIZE. uid(%u)", uid);
if (0 != ttsd_server_finalize(uid)) {
return;
static void __register_cb(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_stub_tts_notify_cb_h callback, void* user_data)
{
- SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%d)", uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK uid(%u)", u_uid);
bool is_initialized = false;
- ttsd_server_is_already_initialized(pid, uid, &is_initialized);
+ ttsd_server_is_already_initialized(pid, u_uid, &is_initialized);
int ret = -1;
int credential_needed = 0;
if (false == is_initialized) {
bool is_credential_needed = false;
- ret = ttsd_server_initialize(pid, uid, TTS_IPC_METHOD_TIDL, &is_credential_needed);
+ ret = ttsd_server_initialize(pid, u_uid, TTS_IPC_METHOD_TIDL, &is_credential_needed);
if (0 != ret) {
SLOG(LOG_ERROR, tts_tag(), "[IN ERROR] ttsd Hello : server initialize, ret(%d)", ret);
}
credential_needed = TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED;
}
- intptr_t ptr_uid = uid;
+ uintptr_t ptr_uid = u_uid;
rpc_port_stub_tts_context_set_tag(context, (void*)ptr_uid);
pthread_mutex_lock(&g_tidl_proxy_infos_mutex);
- tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(uid);
+ tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(u_uid);
if (NULL == info) {
info = (tts_tidl_proxy_info_s*)calloc(1, sizeof(tts_tidl_proxy_info_s));
if (NULL == info) {
return;
}
- info->uid = uid;
+ info->uid = u_uid;
g_tidl_proxy_infos = g_list_append(g_tidl_proxy_infos, info);
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
SLOG(LOG_INFO, tts_tag(), "create player instance");
- ttsdc_tidl_send_hello(pid, uid, ret, credential_needed);
+ ttsdc_tidl_send_hello(pid, u_uid, ret, credential_needed);
SLOG(LOG_ERROR, tts_tag(), "<<<<<<<<<<<");
return;
static int __register_cb_sync(rpc_port_stub_tts_context_h context, int pid, int uid, rpc_port_stub_tts_notify_cb_h callback, void* user_data)
{
- SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK synchronously uid(%d)", uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS REGISTER CALLBACK synchronously uid(%u)", u_uid);
- intptr_t ptr_uid = uid;
+ uintptr_t ptr_uid = u_uid;
rpc_port_stub_tts_context_set_tag(context, (void*)ptr_uid);
pthread_mutex_lock(&g_tidl_proxy_infos_mutex);
- tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(uid);
+ tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(u_uid);
if (NULL == info) {
info = (tts_tidl_proxy_info_s*)calloc(1, sizeof(tts_tidl_proxy_info_s));
if (NULL == info) {
return TTSD_ERROR_OPERATION_FAILED;
}
- info->uid = uid;
+ info->uid = u_uid;
g_tidl_proxy_infos = g_list_append(g_tidl_proxy_infos, info);
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
static int __set_mode_cb(rpc_port_stub_tts_context_h context, int uid, int mode, void* user_data)
{
- //ttsd_set_mode(mode);
- SLOG(LOG_INFO, tts_tag(), "[Server] Set client mode. uid (%d), mode (%d)", uid, mode);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_INFO, tts_tag(), "[Server] Set client mode. uid (%u), mode (%d)", u_uid, mode);
int ret = -1;
- ret = ttsd_server_set_mode(uid, mode);
+ ret = ttsd_server_set_mode(u_uid, mode);
if (TTSD_ERROR_NONE != ret) {
SLOG(LOG_ERROR, tts_tag(), "[Server] Fail to set mode. uid is not invalid");
return ret;
return TTSE_ERROR_NONE;
}
-int ttsdc_tidl_send_hello(int pid, int uid, int ret, int credential_needed)
+int ttsdc_tidl_send_hello(int pid, unsigned int uid, int ret, int credential_needed)
{
- SLOG(LOG_INFO, tts_tag(), "[TIDL] ttsdc_tidl_send_hello : pid(%d), uid(%d), credential_needed(%d)", pid, uid, credential_needed);
+ SLOG(LOG_INFO, tts_tag(), "[TIDL] ttsdc_tidl_send_hello : pid(%d), uid(%u), credential_needed(%d)", pid, uid, credential_needed);
char tmp_val[10] = {0, };
char ret_val[12] = {0, };
bundle* msg = bundle_create();
if (NULL == msg) {
- SLOG(LOG_ERROR, tts_tag(), "[TIDL] Fail to create bundle: pid(%d), uid(%d)", pid, uid);
+ SLOG(LOG_ERROR, tts_tag(), "[TIDL] Fail to create bundle: pid(%d), uid(%u)", pid, uid);
return TTSD_ERROR_OUT_OF_MEMORY;
}
static int __initialize_cb(rpc_port_stub_tts_context_h context, int pid, int uid, bool *credential_needed, void *user_data)
{
- SECURE_SLOG(LOG_ERROR, tts_tag(), "[IN] tts initialize : pid(%d), uid(%d)", pid , uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SECURE_SLOG(LOG_ERROR, tts_tag(), "[IN] tts initialize : pid(%d), uid(%u)", pid, u_uid);
- if (0 != ttsd_server_initialize(pid, uid, TTS_IPC_METHOD_TIDL, credential_needed)) {
+ if (0 != ttsd_server_initialize(pid, u_uid, TTS_IPC_METHOD_TIDL, credential_needed)) {
return TTSD_ERROR_OPERATION_FAILED;
}
static int __finalize_cb(rpc_port_stub_tts_context_h context, int uid, void *user_data)
{
- SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS FINALIZE. uid(%d)", uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_ERROR, tts_tag(), ">>>>> TTS FINALIZE. uid(%u)", u_uid);
- if (0 != ttsd_server_finalize(uid)) {
+ if (0 != ttsd_server_finalize(u_uid)) {
return -1;
}
pthread_mutex_lock(&g_tidl_proxy_infos_mutex);
- tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(uid);
+ tts_tidl_proxy_info_s* info = __get_tidl_proxy_info_s(u_uid);
if (NULL == info) {
SLOG(LOG_ERROR, tts_tag(), "[TIDL ERROR] Fail to set notify callback");
pthread_mutex_unlock(&g_tidl_proxy_infos_mutex);
{
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS ADD TEXT");
- if (0 != ttsd_server_add_queue(uid, text, lang, vctype, speed, uttid, credential)) {
+ if (0 != ttsd_server_add_queue((unsigned int)uid, text, lang, vctype, speed, uttid, credential)) {
return -1;
}
{
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS STOP");
- if (0 != ttsd_server_stop(uid)) {
+ if (0 != ttsd_server_stop((unsigned int)uid)) {
return -1;
}
int uttid;
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PLAYER PAUE");
- if (0 != ttsd_server_pause(uid, &uttid)) {
+ if (0 != ttsd_server_pause((unsigned int)uid, &uttid)) {
return -1;
}
{
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PLAY PCM");
- if (0 != ttsd_server_play_pcm(uid)) {
+ if (0 != ttsd_server_play_pcm((unsigned int)uid)) {
return -1;
}
{
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS STOP PCM");
- if (0 != ttsd_server_stop_pcm(uid)) {
+ if (0 != ttsd_server_stop_pcm((unsigned int)uid)) {
return -1;
}
{
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS SET PRIVATE DATA");
- if (0 != ttsd_server_set_private_data(uid, key, data)) {
+ if (0 != ttsd_server_set_private_data((unsigned int)uid, key, data)) {
return -1;
}
SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS GET PRIVATE DATA");
char *tmp = NULL;
- if (0 != ttsd_server_get_private_data(uid, key, &tmp)) {
+ if (0 != ttsd_server_get_private_data((unsigned int)uid, key, &tmp)) {
free(tmp);
return TTSD_ERROR_OPERATION_FAILED;
}
static int __play_cb(rpc_port_stub_tts_context_h context, int uid, const char *credential, void *user_data)
{
- SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PLAY (%d)", uid);
- if (0 != ttsd_server_play(uid, credential)) {
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS PLAY (%d)", u_uid);
+ if (0 != ttsd_server_play(u_uid, credential)) {
return -1;
}
SLOG(LOG_DEBUG, tts_tag(), "<<<<<");
static int __add_pcm_cb(rpc_port_stub_tts_context_h context, int uid, int event, rpc_port_stub_array_char_h pcm_data, int data_size, int audio_type, int rate, void *user_data)
{
- SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS ADD PCM (%d)", uid);
+ unsigned int u_uid = (unsigned int)uid;
+ SLOG(LOG_DEBUG, tts_tag(), ">>>>> TTS ADD PCM (%d)", u_uid);
char* pcm_data_raw = NULL;
int pcm_data_size = 0;
rpc_port_stub_array_char_get(pcm_data, &pcm_data_raw, &pcm_data_size);
- int ret = ttsd_server_add_pcm(uid, event, (void *)pcm_data_raw, data_size, audio_type, rate);
+ int ret = ttsd_server_add_pcm(u_uid, event, (void *)pcm_data_raw, data_size, audio_type, rate);
free(pcm_data_raw);
SLOG(LOG_DEBUG, tts_tag(), "<<<<<");
return TTSE_ERROR_NONE;
}
-static int __send_message(int pid, int uid, int data, const char *method)
+static int __send_message(int pid, unsigned int uid, int data, const char *method)
{
SLOG(LOG_DEBUG, tts_tag(), "[TIDL] ttsdc_tidl_send_message");
return TTSE_ERROR_NONE;
}
-int ttsdc_tidl_send_utt_start_message(int pid, int uid, int uttid)
+int ttsdc_tidl_send_utt_start_message(int pid, unsigned int uid, int uttid)
{
return __send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_STARTED);
}
-int ttsdc_tidl_send_utt_finish_message(int pid, int uid, int uttid)
+int ttsdc_tidl_send_utt_finish_message(int pid, unsigned int uid, int uttid)
{
return __send_message(pid, uid, uttid, TTSD_METHOD_UTTERANCE_COMPLETED);
}
-int ttsdc_tidl_send_set_state_message(int pid, int uid, int state)
+int ttsdc_tidl_send_set_state_message(int pid, unsigned int uid, int state)
{
return __send_message(pid, uid, state, TTSD_METHOD_SET_STATE);
}
-int ttsdc_tidl_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg)
+int ttsdc_tidl_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg)
{
SLOG(LOG_DEBUG, tts_tag(), "[TIDL] ttsdc_tidl_send_error_message");
int ttsd_tidl_close_connection();
-int ttsdc_tidl_send_hello(int pid, int uid, int ret, int credential_needed);
+int ttsdc_tidl_send_hello(int pid, unsigned int uid, int ret, int credential_needed);
-int ttsdc_tidl_send_utt_start_message(int pid, int uid, int uttid);
+int ttsdc_tidl_send_utt_start_message(int pid, unsigned int uid, int uttid);
-int ttsdc_tidl_send_utt_finish_message(int pid, int uid, int uttid);
+int ttsdc_tidl_send_utt_finish_message(int pid, unsigned int uid, int uttid);
-int ttsdc_tidl_send_set_state_message(int pid, int uid, int state);
+int ttsdc_tidl_send_set_state_message(int pid, unsigned int uid, int state);
-int ttsdc_tidl_send_error_message(int pid, int uid, int uttid, int reason, char* err_msg);
+int ttsdc_tidl_send_error_message(int pid, unsigned int uid, int uttid, int reason, char* err_msg);
#ifdef __cplusplus
}
projects / platform / core / uifw / tts.git / commitdiff