On 32bit architecture, signed integer is enough to store uid value. However, on 64bit architecture,
signed integer is not enough because maximum value of pid is 4194304 and value of pid * 1000 is
bigger than the limit of signed integer. And it cause overflow problem.
To solve this issue, this patch changes the data type of variable that stores uid.
Unsigned integer can provides enough space to store uid value on 64bit os.
Change-Id: I32fd8cbc81e2553524cb43cd357eda077f9ceeea
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>
while (NULL != iter) {
data = iter->data;
if (NULL != data->default_lang_changed_cb) {
- SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
+ SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%u)", data->uid);
data->default_lang_changed_cb(data->stt, before_language, current_language,
data->default_lang_changed_user_data);
}
return ret;
}
- SLOG(LOG_INFO, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
+ SLOG(LOG_INFO, TAG_STTC, "[Success] uid(%u)", client->uid);
SLOG(LOG_DEBUG, TAG_STTC, "=====");
SLOG(LOG_DEBUG, TAG_STTC, " ");
}
#endif
//LCOV_EXCL_STOP
- SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
+ SLOG(LOG_INFO, TAG_STTC, "[SUCCESS] uid(%u)", client->uid);
client->before_state = client->current_state;
client->current_state = STT_STATE_READY;
return ret;
}
-int __stt_cb_set_volume(int uid, float volume)
+int __stt_cb_set_volume(unsigned int uid, float volume)
{
stt_client_s* client = NULL;
return;
}
-int __stt_cb_error(int uid, int reason, char* err_msg)
+int __stt_cb_error(unsigned int uid, int reason, char* err_msg)
{
//LCOV_EXCL_START
if (-1 == uid) {
return EINA_FALSE;
}
-int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
+int __stt_cb_result(unsigned int uid, int event, char** data, int data_count, const char* msg)
{
stt_client_s* client = NULL;
return STT_ERROR_NONE;
}
-int __stt_cb_set_state(int uid, int state)
+int __stt_cb_set_state(unsigned int uid, int state)
{
stt_client_s* client = stt_client_get_by_uid(uid);
if (NULL == client) {
return;
}
-int __stt_cb_speech_status(int uid, int status)
+int __stt_cb_speech_status(unsigned int uid, int status)
{
stt_client_s* client = stt_client_get_by_uid(uid);
if (NULL == client) {
/* Max number of handle */
static const int g_max_handle = 999;
/* allocated handle */
-static int g_allocated_handle = 0;
+static unsigned int g_allocated_handle = 0;
/* client list */
static GList *g_client_list = NULL;
/* private functions */
-static int __client_generate_uid(int pid)
+static unsigned int __client_generate_uid(unsigned int pid)
{
g_allocated_handle++;
}
/* generate uid, handle number should be smaller than 1000 */
- return pid * 1000 + g_allocated_handle;
+ return pid * 1000u + g_allocated_handle;
}
int stt_client_new(stt_h* stt)
free(client);
return STT_ERROR_OUT_OF_MEMORY;
}
- temp->handle = __client_generate_uid(getpid());
+ temp->handle = __client_generate_uid((unsigned int)getpid());
/* initialize client data */
client->stt = temp;
return NULL;
}
-stt_client_s* stt_client_get_by_uid(const int uid)
+stt_client_s* stt_client_get_by_uid(unsigned int uid)
{
- if (uid < 0) {
+ if (STT_INVALID_UID == uid) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] out of range : handle"); //LCOV_EXCL_LINE
return NULL;
}
return NULL;
}
-int stt_client_get_size()
+unsigned int stt_client_get_size()
{
return g_list_length(g_client_list);
}
/* base info */
stt_h stt;
int pid;
- int uid; /*<< unique id = pid + handle */
+ unsigned int uid; /*<< unique id = pid + handle */
stt_recognition_result_cb recognition_result_cb;
void* recognition_result_user_data;
stt_client_s* stt_client_get(stt_h stt);
-stt_client_s* stt_client_get_by_uid(const int uid);
+stt_client_s* stt_client_get_by_uid(unsigned int uid);
-int stt_client_get_size();
+unsigned int stt_client_get_size();
int stt_client_use_callback(stt_client_s* client);
void __stt_dbus_service_free();
-extern int __stt_cb_error(int uid, int reason, char* err_msg);
+extern int __stt_cb_error(unsigned int uid, int reason, char* err_msg);
-extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
+extern int __stt_cb_result(unsigned int uid, int event, char** data, int data_count, const char* msg);
-extern int __stt_cb_set_state(int uid, int state);
+extern int __stt_cb_set_state(unsigned int uid, int state);
-extern int __stt_cb_set_volume(int uid, float volume);
+extern int __stt_cb_set_volume(unsigned int uid, float volume);
-extern int __stt_cb_speech_status(int uid, int status);
+extern int __stt_cb_speech_status(unsigned int uid, int status);
//LCOV_EXCL_START
char* __stt_get_service_name(char* engine_id)
if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
- int uid = 0;
+ unsigned int uid = 0;
int response = -1;
- 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);
if (dbus_error_is_set(&err)) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
dbus_error_free(&err);
}
- if (uid > 0) {
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
+ if (uid > STT_INVALID_UID) {
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%u)", uid);
/* check uid */
stt_client_s* client = stt_client_get_by_uid(uid);
else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
- int uid = 0;
+ unsigned int uid = 0;
int state = -1;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &state,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
}
- if (uid > 0 && state >= 0) {
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
+ if (uid > STT_INVALID_UID && state >= 0) {
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%u), state(%d)", uid, state);
__stt_cb_set_state(uid, state);
} else {
SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state"); //LCOV_EXCL_LINE
else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
- int uid = 0;
+ unsigned int uid = 0;
float volume = 0;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &volume,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
}
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%u), volume(%f)", uid, volume);
__stt_cb_set_volume(uid, volume);
/* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
- int uid = 0;
+ unsigned int uid = 0;
DBusMessageIter args;
dbus_message_iter_init(msg, &args);
dbus_message_iter_next(&args);
}
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%u) event(%d) message(%s) count(%d) result id(%d)",
uid, temp_event, temp_msg, temp_count, temp_result_id);
if (temp_count <= 0) {
else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
- int uid;
+ unsigned int uid;
int reason;
char* err_msg;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &reason,
DBUS_TYPE_STRING, &err_msg,
DBUS_TYPE_INVALID);
SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message); //LCOV_EXCL_LINE
dbus_error_free(&err);
} else {
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%u), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
__stt_cb_error(uid, reason, err_msg);
}
else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SPEECH_STATUS)) {
SLOG(LOG_DEBUG, TAG_STTC, "===== Speech status");
- int uid = 0;
+ unsigned int uid = 0;
int status = -1;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &status,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
}
- if (uid > 0 && status >= 0) {
- SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt speech status : uid(%d), status(%d)", uid, status);
+ if (uid > STT_INVALID_UID && status >= 0) {
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt speech status : uid(%u), status(%d)", uid, status);
__stt_cb_speech_status(uid, status);
} else {
SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set status : invalid uid or status"); //LCOV_EXCL_LINE
}
}
-int stt_dbus_request_hello(int uid)
+int stt_dbus_request_hello(unsigned int uid)
{
stt_client_s* client = stt_client_get_by_uid(uid);
SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request stt hello : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request stt hello : uid(%u)", uid);
}
if (g_conn_sender) {
}
-int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
+int stt_dbus_request_initialize(unsigned int uid, bool* silence_supported, bool* credential_needed)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%u)", uid);
}
int pid = getpid();
dbus_message_append_args(msg,
DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
DBusError err;
return result;
}
-int stt_dbus_request_finalize(int uid)
+int stt_dbus_request_finalize(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%u)", uid);
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
DBusMessage* result_msg;
int result = STT_ERROR_OPERATION_FAILED;
}
//LCOV_EXCL_START
-int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
+int stt_dbus_request_set_current_engine(unsigned int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%u), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &engine_id,
DBUS_TYPE_INVALID);
return result;
}
-int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
+int stt_dbus_request_check_app_agreed(unsigned int uid, const char* appid, bool* value)
{
if (NULL == appid || NULL == value) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%u) appid(%s)", uid, appid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &appid,
DBUS_TYPE_INVALID);
return result;
}
-int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
+int stt_dbus_request_get_support_langs(unsigned int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
{
if (NULL == stt || NULL == callback) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%u)", uid);
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
return result;
}
-int stt_dbus_request_get_default_lang(int uid, char** language)
+int stt_dbus_request_get_default_lang(unsigned int uid, char** language)
{
if (NULL == language) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
DBusError err;
}
//LCOV_EXCL_STOP
-int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
+int stt_dbus_request_set_private_data(unsigned int uid, const char* key, const char* data)
{
if (NULL == key || NULL == data) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt 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 stt_dbus_request_get_private_data(int uid, const char* key, char** data)
+int stt_dbus_request_get_private_data(unsigned int uid, const char* key, char** data)
{
if (NULL == key || NULL == data) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt 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)) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args"); //LCOV_EXCL_LINE
-int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
+int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* type, bool* support)
{
if (NULL == support || NULL == type) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%u) type(%s)", uid, type);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INVALID);
return result;
}
-int stt_dbus_request_set_start_sound(int uid, const char* file)
+int stt_dbus_request_set_start_sound(unsigned int uid, const char* file)
{
if (NULL == file) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%u) file(%s)", uid, file);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &file,
DBUS_TYPE_INVALID);
return result;
}
-int stt_dbus_request_unset_start_sound(int uid)
+int stt_dbus_request_unset_start_sound(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
DBusError err;
return result;
}
-int stt_dbus_request_set_stop_sound(int uid, const char* file)
+int stt_dbus_request_set_stop_sound(unsigned int uid, const char* file)
{
if (NULL == file) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%u) file(%s)", uid, file);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &file,
DBUS_TYPE_INVALID);
return result;
}
-int stt_dbus_request_unset_stop_sound(int uid)
+int stt_dbus_request_unset_stop_sound(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
DBusError err;
return result;
}
-int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
+int stt_dbus_request_start(unsigned int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
{
if (NULL == lang || NULL == type || NULL == appid) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%u), language(%s), type(%s)", uid, lang, type);
}
char *temp = NULL;
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INT32, &silence,
#endif
}
-int stt_dbus_request_stop(int uid)
+int stt_dbus_request_stop(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
#if 1
if (g_conn_sender) {
#endif
}
-int stt_dbus_request_cancel(int uid)
+int stt_dbus_request_cancel(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message"); //LCOV_EXCL_LINE
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
#if 1
if (g_conn_sender) {
}
//LCOV_EXCL_START
-int stt_dbus_request_start_file(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
+int stt_dbus_request_start_file(unsigned int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
{
if (NULL == lang || NULL == type || NULL == appid) {
SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start file : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start file : uid(%d), language(%s), type(%s), appid(%s), filepath(%s), audio_type(%d), sample_rate(%d)", uid, lang, type, appid, filepath, audio_type, sample_rate);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start file : uid(%u), language(%s), type(%s), appid(%s), filepath(%s), audio_type(%d), sample_rate(%d)", uid, lang, type, appid, filepath, audio_type, sample_rate);
}
char *temp = NULL;
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INT32, &silence,
return 0;
}
-int stt_dbus_request_cancel_file(int uid)
+int stt_dbus_request_cancel_file(unsigned int uid)
{
DBusMessage* msg;
SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel file : Fail to make message");
return STT_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%u)", uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
if (g_conn_sender) {
int stt_dbus_close_connection();
-int stt_dbus_request_hello(int uid);
+int stt_dbus_request_hello(unsigned int uid);
-int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed);
+int stt_dbus_request_initialize(unsigned int uid, bool* silence_supported, bool* credential_needed);
-int stt_dbus_request_finalize(int uid);
+int stt_dbus_request_finalize(unsigned int uid);
-int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed);
+int stt_dbus_request_set_current_engine(unsigned int uid, const char* engine_id, bool* silence_supported, bool* credential_needed);
-int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value);
+int stt_dbus_request_check_app_agreed(unsigned int uid, const char* appid, bool* value);
-int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data);
+int stt_dbus_request_get_support_langs(unsigned int uid, stt_h stt, stt_supported_language_cb callback, void* user_data);
-int stt_dbus_request_get_default_lang(int uid, char** language);
+int stt_dbus_request_get_default_lang(unsigned int uid, char** language);
-int stt_dbus_request_set_private_data(int uid, const char* key, const char* data);
+int stt_dbus_request_set_private_data(unsigned int uid, const char* key, const char* data);
-int stt_dbus_request_get_private_data(int uid, const char* key, char** data);
+int stt_dbus_request_get_private_data(unsigned int uid, const char* key, char** data);
-int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support);
+int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* type, bool* support);
-int stt_dbus_request_set_start_sound(int uid, const char* file);
+int stt_dbus_request_set_start_sound(unsigned int uid, const char* file);
-int stt_dbus_request_unset_start_sound(int uid);
+int stt_dbus_request_unset_start_sound(unsigned int uid);
-int stt_dbus_request_set_stop_sound(int uid, const char* file);
+int stt_dbus_request_set_stop_sound(unsigned int uid, const char* file);
-int stt_dbus_request_unset_stop_sound(int uid);
+int stt_dbus_request_unset_stop_sound(unsigned int uid);
-int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential);
+int stt_dbus_request_start(unsigned int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential);
-int stt_dbus_request_stop(int uid);
+int stt_dbus_request_stop(unsigned int uid);
-int stt_dbus_request_cancel(int uid);
+int stt_dbus_request_cancel(unsigned int uid);
-int stt_dbus_request_start_file(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate);
+int stt_dbus_request_start_file(unsigned int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate);
-int stt_dbus_request_cancel_file(int uid);
+int stt_dbus_request_cancel_file(unsigned int uid);
#ifdef __cplusplus
}
* @brief A structure of handle for identification
*/
struct stt_s {
- int handle;
+ unsigned int handle;
};
typedef enum {
typedef struct {
- int uid;
+ unsigned int uid;
stt_config_engine_changed_cb engine_cb;
stt_config_lang_changed_cb lang_cb;
stt_config_bool_changed_cb bool_cb;
return;
}
-void __stt_config_release_client(int uid)
+void __stt_config_release_client(unsigned int uid)
{
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
return;
}
-int stt_config_mgr_initialize(int uid)
+int stt_config_mgr_initialize(unsigned int uid)
{
GSList *iter = NULL;
int* get_uid;
get_uid = iter->data;
if (uid == *get_uid) {
- SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] uid(%d) has already registered", uid);
+ SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] uid(%u) has already registered", uid);
return 0;
}
/* Add uid */
g_config_client_list = g_slist_append(g_config_client_list, temp_client);
- SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] Add uid(%d) but config has already initialized", uid);
+ SLOG(LOG_WARN, TAG_STTCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
return STT_CONFIG_ERROR_NONE;
}
return STT_CONFIG_ERROR_NONE;
}
-int stt_config_mgr_finalize(int uid)
+int stt_config_mgr_finalize(unsigned int uid)
{
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
return STT_CONFIG_ERROR_NONE;
}
-int stt_config_mgr_set_callback(int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data)
+int stt_config_mgr_set_callback(unsigned int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data)
{
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
}
//LCOV_EXCL_START
-int stt_config_mgr_unset_callback(int uid)
+int stt_config_mgr_unset_callback(unsigned int uid)
{
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
typedef bool (*stt_config_result_time_cb)(int index, int event, const char* text, long start_time, long end_time, void* user_data);
-int stt_config_mgr_initialize(int uid);
+int stt_config_mgr_initialize(unsigned int uid);
-int stt_config_mgr_finalize(int uid);
+int stt_config_mgr_finalize(unsigned int uid);
-int stt_config_mgr_set_callback(int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data);
+int stt_config_mgr_set_callback(unsigned int uid, stt_config_engine_changed_cb engine_cb, stt_config_lang_changed_cb lang_cb, stt_config_bool_changed_cb bool_cb, void* user_data);
-int stt_config_mgr_unset_callback(int uid);
+int stt_config_mgr_unset_callback(unsigned int uid);
int stt_config_mgr_get_engine_list(stt_config_supported_engine_cb callback, void* user_data);
#define STT_PRIVILEGE_RECORDER "http://tizen.org/privilege/recorder"
#define STT_PRIVILEGE_APPLAUNCH "http://tizen.org/privilege/appmanager.launch"
+#define STT_INVALID_UID 0
+
/******************************************************************************************
* Defines for log tag
*******************************************************************************************/
uid_t globalapp_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
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 */
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)
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);
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);
#include "sttd_main.h"
+#include "stt_defs.h"
#include "sttd_client_data.h"
/* Client list */
static GSList *g_client_list = NULL;
-static int g_cur_recog_uid = 0;
+static unsigned int g_cur_recog_uid = 0;
int client_show_list()
{
/*Get handle data from list*/
data = iter->data;
- SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[%dth] uid(%d), state(%d)", i, data->uid, data->state);
+ SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[%dth] uid(%u), state(%d)", i, data->uid, data->state);
/*Get next item*/
iter = g_slist_next(iter);
return 0;
}
-GSList* __client_get_item(int uid)
+GSList* __client_get_item(unsigned int uid)
{
GSList *iter = NULL;
client_info_s *data = NULL;
return NULL;
}
-int sttd_client_add(int pid, int uid)
+int sttd_client_add(int pid, unsigned int uid)
{
/*Check uid is duplicated*/
GSList *tmp = NULL;
return 0;
}
-int sttd_client_delete(int uid)
+int sttd_client_delete(unsigned int uid)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
/*Get handle*/
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-int sttd_client_get_start_sound(int uid, char** filename)
+int sttd_client_get_start_sound(unsigned int uid, char** filename)
{
if (NULL == filename) {
SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Filename is NULL");
return 0;
}
-int sttd_client_set_start_sound(int uid, const char* filename)
+int sttd_client_set_start_sound(unsigned int uid, const char* filename)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-int sttd_client_get_stop_sound(int uid, char** filename)
+int sttd_client_get_stop_sound(unsigned int uid, char** filename)
{
if (NULL == filename) {
SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Filename is NULL");
return 0;
}
-int sttd_client_set_stop_sound(int uid, const char* filename)
+int sttd_client_set_stop_sound(unsigned int uid, const char* filename)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-int sttd_client_get_state(int uid, app_state_e* state)
+int sttd_client_get_state(unsigned int uid, app_state_e* state)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
return 0;
}
-int sttd_client_set_state(int uid, app_state_e state)
+int sttd_client_set_state(unsigned int uid, app_state_e state)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return count;
}
-int sttd_client_get_pid(int uid)
+int sttd_client_get_pid(unsigned int uid)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] sttd_client_get_pid : uid(%d) is not found", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] sttd_client_get_pid : uid(%u) is not found", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return -1;
}
-int sttd_cliet_set_timer(int uid, Ecore_Timer* timer)
+int sttd_cliet_set_timer(unsigned int uid, Ecore_Timer* timer)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-int sttd_cliet_get_timer(int uid, Ecore_Timer** timer)
+int sttd_cliet_get_timer(unsigned int uid, Ecore_Timer** timer)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
}
#endif
-int sttd_client_get_list(int** uids, int* uid_count)
+int sttd_client_get_list(unsigned int** uids, int* uid_count)
{
if (NULL == uids || NULL == uid_count)
return -1;
if (0 == count)
return -1;
- int *tmp;
- tmp = (int*)calloc(count, sizeof(int));
+ unsigned int* tmp = (unsigned int*)calloc(count, sizeof(unsigned int));
if (NULL == tmp) {
SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] Fail to allocate memory");
return STTD_ERROR_OUT_OF_MEMORY;
return 0;
}
-int stt_client_set_current_recognition(int uid)
+int stt_client_set_current_recognition(unsigned int uid)
{
- if (0 != g_cur_recog_uid) {
+ if (STT_INVALID_UID != g_cur_recog_uid) {
return -1;
}
return 0;
}
-int stt_client_get_current_recognition()
+unsigned int stt_client_get_current_recognition()
{
return g_cur_recog_uid;
}
int stt_client_unset_current_recognition()
{
- g_cur_recog_uid = 0;
+ g_cur_recog_uid = STT_INVALID_UID;
return 0;
}
-int stt_client_set_app_agreed(int uid)
+int stt_client_set_app_agreed(unsigned int uid)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-bool stt_client_get_app_agreed(int uid)
+bool stt_client_get_app_agreed(unsigned int uid)
{
GSList *tmp = NULL;
client_info_s* hnd = NULL;
tmp = __client_get_item(uid);
if (NULL == tmp) {
- SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%d) is NOT valid", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Client Data ERROR] uid(%u) is NOT valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
typedef struct {
int pid;
- int uid;
+ unsigned int uid;
char* start_beep;
char* stop_beep;
typedef bool (*time_callback)(int index, int event, const char* text, long start_time, long end_time, void *user_data);
-int sttd_client_add(int pid, int uid);
+int sttd_client_add(int pid, unsigned int uid);
-int sttd_client_delete(int uid);
+int sttd_client_delete(unsigned int uid);
-int sttd_client_get_start_sound(int uid, char** filename);
+int sttd_client_get_start_sound(unsigned int uid, char** filename);
-int sttd_client_set_start_sound(int uid, const char* filename);
+int sttd_client_set_start_sound(unsigned int uid, const char* filename);
-int sttd_client_get_stop_sound(int uid, char** filename);
+int sttd_client_get_stop_sound(unsigned int uid, char** filename);
-int sttd_client_set_stop_sound(int uid, const char* filename);
+int sttd_client_set_stop_sound(unsigned int uid, const char* filename);
-int sttd_client_get_state(int uid, app_state_e* state);
+int sttd_client_get_state(unsigned int uid, app_state_e* state);
-int sttd_client_set_state(int uid, app_state_e state);
+int sttd_client_set_state(unsigned int uid, app_state_e state);
int sttd_client_get_ref_count();
-int sttd_client_get_pid(int uid);
+int sttd_client_get_pid(unsigned int uid);
#if 0
int sttd_client_get_current_recording();
int sttd_client_get_current_thinking();
-int sttd_cliet_set_timer(int uid, Ecore_Timer* timer);
+int sttd_cliet_set_timer(unsigned int uid, Ecore_Timer* timer);
-int sttd_cliet_get_timer(int uid, Ecore_Timer** timer);
+int sttd_cliet_get_timer(unsigned int uid, Ecore_Timer** timer);
#endif
-int sttd_client_get_list(int** uids, int* uid_count);
+int sttd_client_get_list(unsigned int** uids, int* uid_count);
-int stt_client_set_current_recognition(int uid);
+int stt_client_set_current_recognition(unsigned int uid);
-int stt_client_get_current_recognition();
+unsigned int stt_client_get_current_recognition();
int stt_client_unset_current_recognition();
-int stt_client_set_app_agreed(int uid);
+int stt_client_set_app_agreed(unsigned int uid);
-bool stt_client_get_app_agreed(int uid);
+bool stt_client_get_app_agreed(unsigned int uid);
#ifdef __cplusplus
void __sttd_dbus_service_free();
-int sttdc_send_hello(int uid)
+int sttdc_send_hello(unsigned int uid)
{
int pid = sttd_client_get_pid(uid);
if (0 > pid) {
DBusMessage* msg = NULL;
- SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] Send hello message : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] Send hello message : uid(%u)", uid);
msg = dbus_message_new_method_call(
service_name,
return STTD_ERROR_OUT_OF_MEMORY;
}
- dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+ dbus_message_append_args(msg, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
return result;
}
-int sttdc_send_set_volume(int uid, float volume)
+int sttdc_send_set_volume(unsigned int uid, float volume)
{
int pid = sttd_client_get_pid(uid);
DBusMessage* msg;
- /* SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] Send set volume : uid(%d), volume(%f) volume size(%d)", uid, volume, sizeof(float)); */
+ /* SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] Send set volume : uid(%u), volume(%f) volume size(%d)", uid, volume, sizeof(float)); */
msg = dbus_message_new_signal(
STT_CLIENT_SERVICE_OBJECT_PATH, /* object name of the signal */
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &volume,
DBUS_TYPE_INVALID);
if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Dbus ERROR] Fail to send message : Out Of Memory !");
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send set volume : uid(%d), volume(%f)", uid, volume);
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send set volume : uid(%u), volume(%f)", uid, volume);
dbus_connection_flush(g_conn_sender);
}
return 0;
}
-int sttdc_send_set_state(int uid, int state)
+int sttdc_send_set_state(unsigned int uid, int state)
{
int pid = sttd_client_get_pid(uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &state,
DBUS_TYPE_INVALID);
if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Dbus ERROR] Fail to send change state message : Out Of Memory !");
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send change state message : uid(%d), state(%d)", uid, state);
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send change state message : uid(%u), state(%d)", uid, state);
dbus_connection_flush(g_conn_sender);
}
return 0;
}
-int sttdc_send_speech_status(int uid, int status)
+int sttdc_send_speech_status(unsigned int uid, int status)
{
int pid = sttd_client_get_pid(uid);
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &status,
DBUS_TYPE_INVALID);
if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Dbus ERROR] Fail to send speech status message : Out Of Memory !");
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send speech status message : uid(%d), status(%d)", uid, status);
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<< Send speech status message : uid(%u), status(%d)", uid, status);
dbus_connection_flush(g_conn_sender);
}
return 0;
}
-int sttdc_send_result(int uid, int event, const char** data, int data_count, const char* result_msg)
+int sttdc_send_result(unsigned int uid, int event, const char** data, int data_count, const char* result_msg)
{
int pid = sttd_client_get_pid(uid);
if (0 > pid) {
snprintf(target_if_name, sizeof(target_if_name), "%s%d", STT_CLIENT_SERVICE_INTERFACE, pid);
DBusMessage* msg = NULL;
- SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] send result signal : uid(%d), event(%d), result count(%d) result id(%d)",
+ SLOG(LOG_DEBUG, TAG_STTD, "[Dbus] send result signal : uid(%u), event(%d), result count(%d) result id(%d)",
uid, event, data_count, g_internal_result_id);
msg = dbus_message_new_signal(
dbus_message_iter_init_append(msg, &args);
/* Append uid & type */
- dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &uid);
+ dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &uid);
char* msg_temp;
dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &event);
return 0;
}
-int sttdc_send_error_signal(int uid, int reason, const char *err_msg)
+int sttdc_send_error_signal(unsigned int uid, int reason, const char *err_msg)
{
int pid = sttd_client_get_pid(uid);
if (0 > pid) {
}
dbus_message_append_args(msg,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INT32, &reason,
DBUS_TYPE_STRING, &err_msg,
DBUS_TYPE_INVALID);
if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
SLOG(LOG_ERROR, TAG_STTD, "[Dbus ERROR] <<<< error message : Out Of Memory !");
} else {
- SLOG(LOG_ERROR, TAG_STTD, "<<<< Send error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
+ SLOG(LOG_ERROR, TAG_STTD, "<<<< Send error message : uid(%u), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
dbus_connection_flush(g_conn_sender);
}
int sttd_dbus_close_connection();
-int sttdc_send_hello(int uid);
+int sttdc_send_hello(unsigned int uid);
-int sttdc_send_set_volume(int uid, float volume);
+int sttdc_send_set_volume(unsigned int uid, float volume);
-int sttdc_send_set_state(int uid, int state);
+int sttdc_send_set_state(unsigned int uid, int state);
-int sttdc_send_result(int uid, int event, const char** data, int data_count, const char* result_msg);
+int sttdc_send_result(unsigned int uid, int event, const char** data, int data_count, const char* result_msg);
-int sttdc_send_error_signal(int uid, int reason, const char *err_msg);
+int sttdc_send_error_signal(unsigned int uid, int reason, const char *err_msg);
-int sttdc_send_speech_status(int uid, int status);
+int sttdc_send_speech_status(unsigned int uid, int status);
#ifdef __cplusplus
dbus_error_init(&err);
int pid;
- int uid;
+ unsigned int uid;
bool silence_supported = false;
bool credential_needed = false;
dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%u)", pid , uid);
ret = sttd_server_initialize(pid, uid, &silence_supported, &credential_needed);
}
int int_silence_supported = (int)silence_supported;
int int_credential_needed = (int)credential_needed;
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &int_silence_supported,
DBUS_TYPE_INT32, &int_credential_needed,
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
ret, silence_supported, credential_needed);
} else {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Finalize");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%u)", uid);
ret = sttd_server_finalize(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
GSList* engine_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, TAG_STTD, ">>>>> STT Get supported engines");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%u)", uid);
ret = sttd_server_get_supported_engines(uid, &engine_list);
}
if (NULL != engine) {
if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
- SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
+ SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
engine->engine_id, engine->engine_name, engine->ug_name);
dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* engine_id;
bool silence_supported = false;
bool credential_needed = false;
int ret = STTD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &engine_id,
DBUS_TYPE_INVALID);
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%u), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
}
int int_silence_supported = (int)silence_supported;
int int_credential_needed = (int)credential_needed;
- dbus_message_append_args(reply,
- DBUS_TYPE_INT32, &ret,
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &int_silence_supported,
DBUS_TYPE_INT32, &int_credential_needed,
DBUS_TYPE_INVALID);
if (0 == ret) {
- SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
ret, silence_supported, credential_needed);
} else {
SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* engine = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Get current engine");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%u)", uid);
ret = sttd_server_get_current_engine(uid, &engine);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* appid;
int ret = STTD_ERROR_OPERATION_FAILED;
bool available = false;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_STRING, &appid,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_STRING, &appid,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%u)", uid);
ret = sttd_server_check_app_agreed(uid, appid, &available);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &available,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
GSList* lang_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, TAG_STTD, ">>>>> STT Get supported langs");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%u)", uid);
ret = sttd_server_get_supported_languages(uid, &lang_list);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* lang = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Get default langs");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%u)", uid);
ret = sttd_server_get_current_langauage(uid, &lang);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* key;
char* data;
int ret = STTD_ERROR_OPERATION_FAILED;
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);
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%u)", uid);
ret = sttd_server_set_private_data(uid, key, data);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* key = NULL;
char* data = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
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 = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%u), key(%s)", uid, (NULL == key) ? "NULL" : key);
ret = sttd_server_get_private_data(uid, key, &data);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* type = NULL;
int support = -1;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%u)", uid);
ret = sttd_server_is_recognition_type_supported(uid, type, &support);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INT32, &support,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* file = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%u) file(%s)", uid, file);
ret = sttd_server_set_start_sound(uid, file);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT unset start sound");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%u)", uid);
ret = sttd_server_set_start_sound(uid, NULL);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* file = NULL;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%u) file(%s)", uid, file);
ret = sttd_server_set_stop_sound(uid, file);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT unset stop sound");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%u)", uid);
ret = sttd_server_set_stop_sound(uid, NULL);
}
if (NULL != reply) {
/* Append result and language */
- dbus_message_append_args(reply,
+ dbus_message_append_args(reply,
DBUS_TYPE_INT32, &ret,
DBUS_TYPE_INVALID);
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* lang;
char* type;
char* appid;
char* credential;
int ret = STTD_ERROR_OPERATION_FAILED;
- dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INT32, &silence,
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%u), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
, uid, lang, type, silence, appid, credential);
ret = sttd_server_start(uid, lang, type, silence, appid, credential);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Stop");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%u)", uid);
ret = sttd_server_stop(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Cancel");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%u)", uid);
ret = sttd_server_cancel(uid);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
char* lang;
char* type;
char* appid;
int ret = STTD_ERROR_OPERATION_FAILED;
dbus_message_get_args(msg, &err,
- DBUS_TYPE_INT32, &uid,
+ DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_STRING, &lang,
DBUS_TYPE_STRING, &type,
DBUS_TYPE_INT32, &silence,
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) filepath(%s), audio_type(%d), sample_rate(%d)"
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file : uid(%u), lang(%s), type(%s), silence(%d) appid(%s) filepath(%s), audio_type(%d), sample_rate(%d)"
, uid, lang, type, silence, appid, filepath, audio_type, sample_rate);
ret = sttd_server_start_file(uid, lang, type, silence, appid, credential, filepath, audio_type, sample_rate);
}
DBusError err;
dbus_error_init(&err);
- int uid;
+ unsigned int uid;
int ret = STTD_ERROR_OPERATION_FAILED;
- 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, TAG_STTD, ">>>>> STT Cancel File");
dbus_error_free(&err);
ret = STTD_ERROR_OPERATION_FAILED;
} else {
- SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel file : uid(%d)", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel file : uid(%u)", uid);
ret = sttd_server_cancel_file(uid);
}
return 0;
}
-int sttd_engine_agent_is_credential_needed(int uid, bool* credential)
+int sttd_engine_agent_is_credential_needed(unsigned int uid, bool* credential)
{
if (false == g_agent_init) {
SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] Not Initialized");
}
if (NULL == g_engine_info) {
- SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%d) is not valid", uid);
+ SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] uid(%u) is not valid", uid);
return STTD_ERROR_INVALID_PARAMETER;
}
return 0;
}
-int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
+int sttd_engine_agent_recognize_start_engine(unsigned int uid, const char* lang, const char* recognition_type,
int silence, const char* appid, const char* credential, void* user_param)
{
if (false == g_agent_init) {
return 0;
}
-int sttd_engine_agent_recognize_start_recorder(int uid, const char* appid)
+int sttd_engine_agent_recognize_start_recorder(unsigned int uid, const char* appid)
{
if (NULL == g_engine_info) {
SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
return 0;
}
-int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
+int sttd_engine_agent_recognize_start_file(unsigned int uid, const char* filepath)
{
if (NULL == g_engine_info) {
SECURE_SLOG(LOG_ERROR, TAG_STTD, "[Engine Agent ERROR] The engine is not valid");
int sttd_engine_agent_send_error(stte_error_e error, const char* msg)
{
/* check uid */
- int uid = stt_client_get_current_recognition();
+ unsigned int uid = stt_client_get_current_recognition();
char* err_msg = NULL;
int ret = STTD_ERROR_NONE;
#define ENGINE_PATH_SIZE 256
-typedef int (*result_callback)(stte_result_event_e event, const char* type,
+typedef int (*result_callback)(stte_result_event_e event, const char* type,
const char** data, int data_count, const char* msg, void *user_data);
-typedef bool (*result_time_callback)(int index, stte_result_time_event_e event, const char* text,
+typedef bool (*result_time_callback)(int index, stte_result_time_event_e event, const char* text,
long start_time, long end_time, void *user_data);
typedef int (*speech_status_callback)(stte_speech_status_e status, void *user_data);
*/
/** Init / Release engine agent */
-int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb,
+int sttd_engine_agent_init(result_callback result_cb, result_time_callback time_cb,
speech_status_callback speech_status_cb, error_callback error_cb);
int sttd_engine_agent_release();
int sttd_engine_agent_get_option_supported(bool* silence);
-int sttd_engine_agent_is_credential_needed(int uid, bool* credential);
+int sttd_engine_agent_is_credential_needed(unsigned int uid, bool* credential);
int sttd_engine_agent_is_recognition_type_supported(const char* type, bool* support);
int sttd_engine_agent_check_app_agreed(const char* appid, bool* result);
/** Control engine */
-int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const char* recognition_type,
+int sttd_engine_agent_recognize_start_engine(unsigned int uid, const char* lang, const char* recognition_type,
int silence, const char* appid, const char* credential, void* user_param);
-int sttd_engine_agent_recognize_start_recorder(int uid, const char* appid);
+int sttd_engine_agent_recognize_start_recorder(unsigned int uid, const char* appid);
-int sttd_engine_agent_recognize_start_file(int uid, const char* filepath);
+int sttd_engine_agent_recognize_start_file(unsigned int uid, const char* filepath);
int sttd_engine_agent_set_recording_data(const void* data, unsigned int length);
} sttd_recorder_state;
typedef struct {
- int uid;
+ unsigned int uid;
audio_in_h audio_h;
stte_audio_type_e audio_type;
} stt_recorder_s;
return STTD_ERROR_OUT_OF_MEMORY;
}
- recorder->uid = -1;
+ recorder->uid = STT_INVALID_UID;
recorder->audio_h = temp_in_h;
recorder->audio_type = type;
}
#endif
-int sttd_recorder_start(int uid, const char* appid)
+int sttd_recorder_start(unsigned int uid, const char* appid)
{
if (STTD_RECORDER_STATE_RECORDING == g_recorder_state)
return 0;
return STTD_ERROR_INVALID_PARAMETER;
}
- g_recorder->uid = -1;
+ g_recorder->uid = STT_INVALID_UID;
int ret = -1;
#ifndef TV_BT_MODE
return 0;
}
-int sttd_recorder_start_file(int uid, const char *filepath)
+int sttd_recorder_start_file(unsigned int uid, const char *filepath)
{
if (STTD_RECORDER_STATE_RECORDING == g_recorder_state)
return 0;
return STTD_ERROR_INVALID_PARAMETER;
}
- g_recorder->uid = -1;
+ g_recorder->uid = STT_INVALID_UID;
g_recorder_state = STTD_RECORDER_STATE_READY;
return 0;
int sttd_recorder_destroy();
-int sttd_recorder_start(int uid, const char* appid);
+int sttd_recorder_start(unsigned int uid, const char* appid);
int sttd_recorder_stop();
-int sttd_recorder_start_file(int uid, const char *filepath);
+int sttd_recorder_start_file(unsigned int uid, const char *filepath);
int sttd_recorder_stop_file();
#include "sttd_engine_agent.h"
#include "sttd_main.h"
#include "sttd_recorder.h"
+#include "stt_defs.h"
#include "sttd_server.h"
{
SLOG(LOG_INFO, TAG_STTD, "===== Stop by silence detection");
- int uid = 0;
-
- uid = stt_client_get_current_recognition();
+ unsigned int uid = stt_client_get_current_recognition();
int ret;
- if (0 != uid) {
+ if (STT_INVALID_UID != uid) {
ret = sttd_server_stop(uid);
if (0 > ret) {
__cancel_recognition_internal();
}
int ret = 0;
- int uid = 0;
- uid = stt_client_get_current_recognition();
+ unsigned int uid = stt_client_get_current_recognition();
app_state_e state = 0;
ret = sttd_client_get_state(uid, &state);
int __server_audio_recorder_callback(const void* data, const unsigned int length)
{
- int uid = -1;
int ret;
if (NULL == data || 0 == length) {
return -1;
}
- uid = stt_client_get_current_recognition();
- if (0 != uid) {
+ unsigned int uid = stt_client_get_current_recognition();
+ if (STT_INVALID_UID != uid) {
ret = sttd_engine_agent_set_recording_data(data, length);
if (ret < 0) {
ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
SLOG(LOG_INFO, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
/* check uid */
- int uid = stt_client_get_current_recognition();
+ unsigned int uid = stt_client_get_current_recognition();
app_state_e state;
- if (0 == uid || 0 != sttd_client_get_state(uid, &state)) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+ if (STT_INVALID_UID == uid || 0 != sttd_client_get_state(uid, &state)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid (%u)", uid);
SLOG(LOG_DEBUG, TAG_STTD, "=====");
SLOG(LOG_DEBUG, TAG_STTD, " ");
pthread_mutex_unlock(&stte_result_mutex);
return STTD_ERROR_OPERATION_FAILED;
}
- SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
+ SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%u), event(%d)", uid, event);
/* send result to client */
if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
{
SLOG(LOG_INFO, TAG_STTD, "===== Speech status detected Callback");
- int uid = stt_client_get_current_recognition();
- if (0 != uid) {
+ unsigned int uid = stt_client_get_current_recognition();
+ if (STT_INVALID_UID != uid) {
app_state_e state;
if (0 != sttd_client_get_state(uid, &state)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is not valid ");
#if 0
/* need to change state of app to ready */
- int uid;
+ unsigned int uid;
uid = stt_client_get_current_recognition();
if (0 != uid) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%d)", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server] Set ready state of uid(%u)", uid);
sttd_server_cancel(uid);
sttdc_send_set_state(uid, (int)APP_STATE_READY);
Eina_Bool sttd_cleanup_client(void *data)
{
- int* client_list = NULL;
+ unsigned int* client_list = NULL;
int client_count = 0;
int i = 0;
int j = 0;
iter = g_list_nth(g_proc_list, j);
if (NULL != iter) {
if (pid == GPOINTER_TO_INT(iter->data)) {
- SLOG(LOG_DEBUG, TAG_STTD, "uid (%d) is running", client_list[i]);
+ SLOG(LOG_DEBUG, TAG_STTD, "uid (%u) is running", client_list[i]);
exist = true;
break;
}
}
if (false == exist) {
- SLOG(LOG_ERROR, TAG_STTD, "uid (%d) should be removed", client_list[i]);
+ SLOG(LOG_ERROR, TAG_STTD, "uid (%u) should be removed", client_list[i]);
sttd_server_finalize(client_list[i]);
}
#if 0
result = sttdc_send_hello(client_list[i]);
if (0 == result) {
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", client_list[i]);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%u) should be removed.", client_list[i]);
sttd_server_finalize(client_list[i]);
} else if (-1 == result) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Hello result has error");
* STT Server Functions for Client
*/
-int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
+int sttd_server_initialize(int pid, unsigned int uid, bool* silence, bool* credential)
{
int ret = STTD_ERROR_NONE;
return EINA_FALSE;
}
-int sttd_server_finalize(int uid)
+int sttd_server_finalize(unsigned int uid)
{
SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter Finalize");
return STTD_ERROR_NONE;
}
-int sttd_server_get_supported_engines(int uid, GSList** engine_list)
+int sttd_server_get_supported_engines(unsigned int uid, GSList** engine_list)
{
/* Check if uid is valid */
app_state_e state;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
return STTD_ERROR_NONE;
}
-int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence, bool* credential)
+int sttd_server_set_current_engine(unsigned int uid, const char* engine_id, bool* silence, bool* credential)
{
/* Check if uid is valid */
app_state_e state;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
- SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%d), engine_id(%s)", uid, engine_id);
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%u), engine_id(%s)", uid, engine_id);
int ret;
ret = sttd_engine_agent_load_current_engine(NULL);
return STTD_ERROR_NONE;
}
-int sttd_server_get_current_engine(int uid, char** engine_id)
+int sttd_server_get_current_engine(unsigned int uid, char** engine_id)
{
/* Check if uid is valid */
app_state_e state;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
- SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%d)", uid);
+ SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%u)", uid);
int ret;
ret = sttd_engine_agent_get_current_engine(engine_id);
return STTD_ERROR_NONE;
}
-int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
+int sttd_server_check_app_agreed(unsigned int uid, const char* appid, bool* available)
{
/* Check if uid is valid */
app_state_e state;
/* Check state of uid */
if (APP_STATE_READY != state) {
- SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%d) is not Ready", uid);
+ SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] The state of uid(%u) is not Ready", uid);
return STTD_ERROR_INVALID_STATE;
}
}
-int sttd_server_get_supported_languages(int uid, GSList** lang_list)
+int sttd_server_get_supported_languages(unsigned int uid, GSList** lang_list)
{
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
-int sttd_server_get_current_langauage(int uid, char** current_lang)
+int sttd_server_get_current_langauage(unsigned int uid, char** current_lang)
{
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
-int sttd_server_set_private_data(int uid, const char* key, const char* data)
+int sttd_server_set_private_data(unsigned int uid, const char* key, const char* data)
{
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
-int sttd_server_get_private_data(int uid, const char* key, char** data)
+int sttd_server_get_private_data(unsigned int uid, const char* key, char** data)
{
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
-int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support)
+int sttd_server_is_recognition_type_supported(unsigned int uid, const char* type, int* support)
{
/* check if uid is valid */
app_state_e state;
return STTD_ERROR_NONE;
}
-int sttd_server_set_start_sound(int uid, const char* file)
+int sttd_server_set_start_sound(unsigned int uid, const char* file)
{
/* check if uid is valid */
app_state_e state;
return 0;
}
-int sttd_server_set_stop_sound(int uid, const char* file)
+int sttd_server_set_stop_sound(unsigned int uid, const char* file)
{
/* check if uid is valid */
app_state_e state;
Eina_Bool __check_recording_state(void *data)
{
/* current uid */
- int uid = stt_client_get_current_recognition();
+ unsigned int uid = stt_client_get_current_recognition();
if (0 == uid)
return EINA_FALSE;
app_state_e state;
if (0 != sttdc_send_get_state(uid, (int*)&state)) {
/* client is removed */
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%d) should be removed.", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid(%u) should be removed.", uid);
sttd_server_finalize(uid);
return EINA_FALSE;
}
if (APP_STATE_READY == state) {
/* Cancel stt */
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Ready'. The STT service should cancel recording", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%u) is 'Ready'. The STT service should cancel recording", uid);
sttd_server_cancel(uid);
} else if (APP_STATE_PROCESSING == state) {
/* Cancel stt and send change state */
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%d) is 'Processing'. The STT service should cancel recording", uid);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] The state of uid(%u) is 'Processing'. The STT service should cancel recording", uid);
sttd_server_cancel(uid);
sttdc_send_set_state(uid, (int)APP_STATE_READY);
} else {
g_recording_timer = NULL;
}
- int uid = 0;
- uid = stt_client_get_current_recognition();
- if (0 != uid) {
+ unsigned int uid = stt_client_get_current_recognition();
+ if (STT_INVALID_UID != uid) {
/* cancel engine recognition */
int ret = sttd_server_stop(uid);
if (0 != ret) {
void __sttd_server_recorder_start(void* data)
{
- intptr_t puid = (intptr_t)data;
- int uid = (int)puid;
+ uintptr_t puid = (uintptr_t)data;
+ unsigned int uid = (unsigned int)puid;
int current_uid = stt_client_get_current_recognition();
if (uid != current_uid) {
return;
}
-int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential)
+int sttd_server_start(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential)
{
if (NULL == lang || NULL == recognition_type) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Input parameter is NULL");
}
/* engine start recognition */
- SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
+ SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%u), lang(%s), recog_type(%s)",
uid, lang, recognition_type);
if (NULL != sound)
SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
/* 2. Request wav play */
if (NULL != sound) {
int id = 0;
- intptr_t puid = (intptr_t)uid;
+ uintptr_t puid = (uintptr_t)uid;
sound_stream_info_h wav_stream_info_h;
if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter __time_out_for_processing");
/* current uid */
- int uid = stt_client_get_current_recognition();
- if (0 == uid) return EINA_FALSE;
+ unsigned int uid = stt_client_get_current_recognition();
+ if (STT_INVALID_UID == uid) return EINA_FALSE;
SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by timeout for processing");
void __sttd_server_engine_stop(void* data)
{
- intptr_t puid = (intptr_t)data;
- int uid = (int)puid;
+ uintptr_t puid = (uintptr_t)data;
+ unsigned int uid = (unsigned int)puid;
/* change uid state */
sttd_client_set_state(uid, APP_STATE_PROCESSING);
return;
}
-int sttd_server_stop(int uid)
+int sttd_server_stop(unsigned int uid)
{
/* check if uid is valid */
app_state_e state;
/* 2. Request wav play */
if (NULL != sound) {
int id = 0;
- intptr_t puid = (intptr_t)uid;
+ uintptr_t puid = (uintptr_t)uid;
sound_stream_info_h wav_stream_info_h;
if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
return STTD_ERROR_NONE;
}
-int sttd_server_cancel(int uid)
+int sttd_server_cancel(unsigned int uid)
{
SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter sttd_server_cancel");
return STTD_ERROR_NONE;
}
-int sttd_server_start_file(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential,
+int sttd_server_start_file(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential,
const char* filepath, stte_audio_type_e audio_type, int sample_rate)
{
if (NULL == lang || NULL == recognition_type || NULL == filepath) {
}
/* engine start recognition */
- SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s), appid(%s), file(%s), audio_type(%d), sample_rate(%d)", uid, lang, recognition_type, appid, filepath, audio_type, sample_rate);
+ SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%u), lang(%s), recog_type(%s), appid(%s), file(%s), audio_type(%d), sample_rate(%d)", uid, lang, recognition_type, appid, filepath, audio_type, sample_rate);
/* 1. Set audio session */
ret = sttd_recorder_set_audio_session();
return STTD_ERROR_NONE;
}
-int sttd_server_cancel_file(int uid)
+int sttd_server_cancel_file(unsigned int uid)
{
/* check if uid is valid */
app_state_e state;
* API for client
*/
-int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential);
+int sttd_server_initialize(int pid, unsigned int uid, bool* silence, bool* credential);
-int sttd_server_finalize(int uid);
+int sttd_server_finalize(unsigned int uid);
-int sttd_server_get_supported_engines(int uid, GSList** engine_list);
+int sttd_server_get_supported_engines(unsigned int uid, GSList** engine_list);
-int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence, bool* credential);
+int sttd_server_set_current_engine(unsigned int uid, const char* engine_id, bool* silence, bool* credential);
-int sttd_server_get_current_engine(int uid, char** engine_id);
+int sttd_server_get_current_engine(unsigned int uid, char** engine_id);
-int sttd_server_check_app_agreed(int uid, const char* appid, bool* available);
+int sttd_server_check_app_agreed(unsigned int uid, const char* appid, bool* available);
-int sttd_server_get_supported_languages(int uid, GSList** lang_list);
+int sttd_server_get_supported_languages(unsigned int uid, GSList** lang_list);
-int sttd_server_get_current_langauage(int uid, char** current_lang);
+int sttd_server_get_current_langauage(unsigned int uid, char** current_lang);
-int sttd_server_set_private_data(int uid, const char* key, const char* data);
+int sttd_server_set_private_data(unsigned int uid, const char* key, const char* data);
-int sttd_server_get_private_data(int uid, const char* key, char** data);
+int sttd_server_get_private_data(unsigned int uid, const char* key, char** data);
-int sttd_server_set_engine_data(int uid, const char* key, const char* value);
+int sttd_server_set_engine_data(unsigned int uid, const char* key, const char* value);
-int sttd_server_is_recognition_type_supported(int uid, const char* type, int* support);
+int sttd_server_is_recognition_type_supported(unsigned int uid, const char* type, int* support);
-int sttd_server_set_start_sound(int uid, const char* file);
+int sttd_server_set_start_sound(unsigned int uid, const char* file);
-int sttd_server_set_stop_sound(int uid, const char* file);
+int sttd_server_set_stop_sound(unsigned int uid, const char* file);
-int sttd_server_get_audio_volume(int uid, float* current_volume);
+int sttd_server_get_audio_volume(unsigned int uid, float* current_volume);
-int sttd_server_start(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential);
+int sttd_server_start(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential);
-int sttd_server_stop(int uid);
+int sttd_server_stop(unsigned int uid);
-int sttd_server_cancel(int uid);
+int sttd_server_cancel(unsigned int uid);
-int sttd_server_start_file(int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential, const char* filepath, stte_audio_type_e audio_type, int sample_rate);
+int sttd_server_start_file(unsigned int uid, const char* lang, const char* recognition_type, int silence, const char* appid, const char* credential, const char* filepath, stte_audio_type_e audio_type, int sample_rate);
-int sttd_server_cancel_file(int uid);
+int sttd_server_cancel_file(unsigned int uid);
#ifdef __cplusplus
projects / platform / core / uifw / stt.git / commitdiff