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