return result;
}
-
-
int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* type, bool* support)
{
if (NULL == support || NULL == type) {
return result;
}
+int stt_dbus_request_get_audio_format(unsigned int uid, stt_audio_type_e* type, int* rate, int* num_of_channels)
+{
+ if (NULL == type || NULL == rate || NULL == num_of_channels) {
+ SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
+ return STT_ERROR_INVALID_PARAMETER;
+ }
+
+ DBusMessage* msg = dbus_message_new_method_call(
+ g_server_service_name,
+ g_server_service_object,
+ g_server_service_interface,
+ STT_METHOD_GET_AUDIO_FORMAT);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get audio format : Fail to make message"); //LCOV_EXCL_LINE
+ return STT_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get audio format : uid(%u)", uid);
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_INVALID);
+
+ DBusError err;
+ dbus_error_init(&err);
+
+ int result = STT_ERROR_OPERATION_FAILED;
+ int temp_type = -1;
+ int temp_rate = -1;
+ int temp_num_of_channels = -1;
+
+ DBusMessage* result_msg = __stt_dbus_send_message_with_reply_and_block(msg, g_waiting_time);
+ if (NULL != result_msg) {
+ dbus_message_get_args(result_msg, &err,
+ DBUS_TYPE_INT32, &result,
+ DBUS_TYPE_INT32, &temp_type,
+ DBUS_TYPE_INT32, &temp_rate,
+ DBUS_TYPE_INT32, &temp_num_of_channels,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ //LCOV_EXCL_START
+ SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ result = STT_ERROR_OPERATION_FAILED;
+ //LCOV_EXCL_STOP
+ }
+ dbus_message_unref(result_msg);
+ result_msg = NULL;
+
+ if (0 == result) {
+ *type = (stt_audio_type_e)temp_type;
+ *rate = temp_rate;
+ *num_of_channels = temp_num_of_channels;
+ SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get audio format : result = %d, type = %d, rate = %d, number of channels = %d",
+ result, temp_type, temp_rate, temp_num_of_channels);
+ } else {
+ SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get audio format : result = %d", result); //LCOV_EXCL_LINE
+ }
+ } else {
+ SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
+ stt_dbus_reconnect();
+ result = STT_ERROR_TIMED_OUT;
+ }
+
+ return result;
+}
+
DBusMessage* __stt_dbus_create_message(char* method_string)
{
DBusMessage* msg;
return ret;
}
+int stt_dbus_request_start_audio_streaming(unsigned int uid, const char* language, const char* type, int silence, const char* appid, const char* credential, const char* audio_id)
+{
+ if (NULL == language || NULL == type || NULL == appid || NULL == audio_id) {
+ SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
+ return STT_ERROR_INVALID_PARAMETER;
+ }
+
+ /* create a signal & check for errors */
+ DBusMessage* msg = dbus_message_new_method_call(
+ g_server_service_name,
+ g_server_service_object,
+ g_server_service_interface,
+ STT_METHOD_START_AUDIO_STREAMING);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start audio streaming : Fail to make message"); //LCOV_EXCL_LINE
+ return STT_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start audio streaming : uid(%u), language(%s), type(%s)", uid, language, type);
+ }
+
+ const char *temp = NULL == credential ? "NULL" : credential;
+ dbus_message_append_args(msg,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_STRING, &language,
+ DBUS_TYPE_STRING, &type,
+ DBUS_TYPE_INT32, &silence,
+ DBUS_TYPE_STRING, &appid,
+ DBUS_TYPE_STRING, &temp,
+ DBUS_TYPE_STRING, &audio_id,
+ DBUS_TYPE_INVALID);
+
+ int ret = __stt_dbus_send_message_without_reply(msg, STT_METHOD_START_AUDIO_STREAMING);
+ return ret;
+}
+
+int stt_dbus_request_send_audio_streaming(unsigned int uid, const char* data, size_t data_size)
+{
+ if (NULL == data || 0 == data_size) {
+ SLOG(LOG_ERROR, TAG_STTC, "Data is null or data size is 0"); //LCOV_EXCL_LINE
+ return STT_ERROR_INVALID_PARAMETER;
+ }
+
+ /* create a signal & check for errors */
+ DBusMessage* msg = dbus_message_new_method_call(
+ g_server_service_name,
+ g_server_service_object,
+ g_server_service_interface,
+ STT_METHOD_SEND_AUDIO_STREAMING);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_STTC, ">>>> stt send audio streaming : Fail to make message"); //LCOV_EXCL_LINE
+ return STT_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt send audio streaming : uid(%u), data_size(%zu)", uid, data_size);
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+ &data, data_size,
+ DBUS_TYPE_INVALID);
+
+ int ret = __stt_dbus_send_message_without_reply(msg, STT_METHOD_SEND_AUDIO_STREAMING);
+ return ret;
+}
+
+int stt_dbus_request_stop_audio_streaming(unsigned int uid)
+{
+ /* create a signal & check for errors */
+ DBusMessage* msg = dbus_message_new_method_call(
+ g_server_service_name,
+ g_server_service_object,
+ g_server_service_interface,
+ STT_METHOD_STOP_AUDIO_STREAMING);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop audio streaming : Fail to make message"); //LCOV_EXCL_LINE
+ return STT_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop audio streaming : uid(%u)", uid);
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_INVALID);
+
+ int ret = __stt_dbus_send_message_without_reply(msg, STT_METHOD_STOP_AUDIO_STREAMING);
+ return ret;
+}
+
int stt_dbus_request_cancel(unsigned int uid)
{
DBusMessage* msg;
int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* type, bool* support);
+int stt_dbus_request_get_audio_format(unsigned int uid, stt_audio_type_e* type, int* rate, int* num_of_channels);
+
int stt_dbus_request_set_start_sound(unsigned int uid, const char* file);
int stt_dbus_request_unset_start_sound(unsigned int uid);
int stt_dbus_request_stop(unsigned int uid);
+int stt_dbus_request_start_audio_streaming(unsigned int uid, const char* language, const char* type, int silence, const char* appid, const char* credential, const char* audio_id);
+
+int stt_dbus_request_send_audio_streaming(unsigned int uid, const char* data, size_t data_size);
+
+int stt_dbus_request_stop_audio_streaming(unsigned int uid);
+
int stt_dbus_request_cancel(unsigned int uid);
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);
#define STT_METHOD_GET_SUPPORT_LANGS "stt_method_get_support_langs"
#define STT_METHOD_GET_CURRENT_LANG "stt_method_get_current_lang"
#define STT_METHOD_IS_TYPE_SUPPORTED "stt_method_is_recognition_type_supported"
+#define STT_METHOD_GET_AUDIO_FORMAT "stt_method_get_audio_format"
#define STT_METHOD_CHECK_APP_AGREED "stt_method_check_app_agreed"
#define STT_METHOD_SET_PRIVATE_DATA "stt_method_set_private_data"
#define STT_METHOD_GET_PRIVATE_DATA "stt_method_get_private_data"
#define STT_METHOD_START_FILE "stt_method_start_file"
#define STT_METHOD_CANCEL_FILE "stt_method_cancel_file"
+#define STT_METHOD_START_AUDIO_STREAMING "stt_method_start_audio_streaming"
+#define STT_METHOD_SEND_AUDIO_STREAMING "stt_method_send_audio_streaming"
+#define STT_METHOD_STOP_AUDIO_STREAMING "stt_method_stop_audio_streaming"
+
/******************************************************************************************
* Defines for configuration
else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_IS_TYPE_SUPPORTED))
sttd_dbus_server_is_recognition_type_supported(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_GET_AUDIO_FORMAT))
+ sttd_dbus_server_get_audio_format(g_conn_listener, msg);
+
else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_SET_START_SOUND))
sttd_dbus_server_set_start_sound(g_conn_listener, msg);
else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_STOP))
sttd_dbus_server_stop(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_START_AUDIO_STREAMING))
+ sttd_dbus_server_start_audio_streaming(g_conn_listener, msg);
+
+ else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_SEND_AUDIO_STREAMING))
+ sttd_dbus_server_send_audio_streaming(g_conn_listener, msg);
+
+ else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_STOP_AUDIO_STREAMING))
+ sttd_dbus_server_stop_audio_streaming(g_conn_listener, msg);
+
else if (dbus_message_is_method_call(msg, g_server_service_interface, STT_METHOD_CANCEL))
sttd_dbus_server_cancel(g_conn_listener, msg);
return 0;
}
+int sttd_dbus_server_get_audio_format(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ unsigned int uid = STT_INVALID_UID;
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT get audio format");
+
+ stte_audio_type_e type = STTE_AUDIO_TYPE_PCM_S16_LE;
+ int rate = -1;
+ int num_of_channels = -1;
+ int ret = STTD_ERROR_OPERATION_FAILED;
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get audio format : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ ret = STTD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get audio format : uid(%u)", uid);
+ ret = sttd_server_get_audio_format(uid, &type, &rate, &num_of_channels);
+ }
+
+ DBusMessage* reply = dbus_message_new_method_return(msg);
+ if (NULL != reply) {
+ /* Append result and language */
+ dbus_message_append_args(reply,
+ DBUS_TYPE_INT32, &ret,
+ DBUS_TYPE_INT32, &type,
+ DBUS_TYPE_INT32, &rate,
+ DBUS_TYPE_INT32, &num_of_channels,
+ DBUS_TYPE_INVALID);
+
+ if (0 == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), type(%d), rate(%d), number of channels(%d)",
+ ret, type, rate, num_of_channels);
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ }
+
+ __sttd_dbus_server_dbus_connection_send(conn, reply);
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+ return STTD_ERROR_NONE;
+}
+
+
int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
return 0;
}
+int sttd_dbus_server_start_audio_streaming(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ unsigned int uid = STT_INVALID_UID;
+ char* language = NULL;
+ char* type = NULL;
+ char* appid = NULL;
+ int silence = 0;
+ char* credential = NULL;
+ char* audio_id = NULL;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_STRING, &language,
+ DBUS_TYPE_STRING, &type,
+ DBUS_TYPE_INT32, &silence,
+ DBUS_TYPE_STRING, &appid,
+ DBUS_TYPE_STRING, &credential,
+ DBUS_TYPE_STRING, &audio_id,
+ DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start audio streaming. UID(%u)", uid);
+
+ int ret = STTD_ERROR_OPERATION_FAILED;
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start audio streaming : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ ret = STTD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTD,
+ "[IN] stt start audio streaming : uid(%u), lang(%s), type(%s), silence(%d) appid(%s) credential(%s) audio_id(%s)",
+ uid, language, type, silence, appid, credential, audio_id);
+ ret = sttd_server_start_audio_streaming(uid, language, type, silence, appid, credential, audio_id);
+ }
+
+ if (STTD_ERROR_NONE == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] stt start audio streaming");
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (STTD_ERROR_NONE != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+ return STTD_ERROR_NONE;
+}
+
+int sttd_dbus_server_send_audio_streaming(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ unsigned int uid = STT_INVALID_UID;
+ char* data = NULL;
+ size_t data_size = 0;
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_UINT32, &uid,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+ &data, &data_size,
+ DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Send audio streaming");
+
+ int ret = STTD_ERROR_OPERATION_FAILED;
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt send audio streaming : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ ret = STTD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt send audio streaming : uid(%u)", uid);
+ ret = sttd_server_send_audio_streaming(uid, data, data_size);
+ }
+
+ if (STTD_ERROR_NONE == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] stt send audio streaming");
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (STTD_ERROR_NONE != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to send audio streaming")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+ return STTD_ERROR_NONE;
+}
+
+int sttd_dbus_server_stop_audio_streaming(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ unsigned int uid = STT_INVALID_UID;
+
+ dbus_message_get_args(msg, &err, DBUS_TYPE_UINT32, &uid, DBUS_TYPE_INVALID);
+
+ SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop audio streaming");
+
+ int ret = STTD_ERROR_OPERATION_FAILED;
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop audio streaming : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ ret = STTD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop audio streaming: uid(%u)", uid);
+ ret = sttd_server_stop_audio_streaming(uid);
+ }
+
+ if (STTD_ERROR_NONE == ret) {
+ SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] stt stop audio streaming");
+ } else {
+ SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+ if (STTD_ERROR_NONE != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop audio streaming")) {
+ SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+ }
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+ return STTD_ERROR_NONE;
+}
+
int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg);
+int sttd_dbus_server_get_audio_format(DBusConnection* conn, DBusMessage* msg);
+
int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg);
int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg);
+int sttd_dbus_server_start_audio_streaming(DBusConnection* conn, DBusMessage* msg);
+
+int sttd_dbus_server_send_audio_streaming(DBusConnection* conn, DBusMessage* msg);
+
+int sttd_dbus_server_stop_audio_streaming(DBusConnection* conn, DBusMessage* msg);
+
int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg);
int sttd_dbus_server_start_file(DBusConnection* conn, DBusMessage* msg);
projects / platform / core / uifw / stt.git / commitdiff