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