From bd842f927bdb06a494a5dceb8dae2e4b01416793 Mon Sep 17 00:00:00 2001 From: Suyeon Hwang Date: Fri, 26 May 2023 20:45:26 +0900 Subject: [PATCH] Add dbus interface for audio streaming - Requirements: The client and server library must be able to exchange the requests for audio streaming. - Contents: To handle requests for audio streaming, this patch adds new dbus interface. With this patch, the client and server library can exchange the requests for audio streaming. Change-Id: I559f8f7693e87539549b81c5b90cda78feca7270 Signed-off-by: Suyeon Hwang --- client/stt_dbus.c | 162 +++++++++++++++++++++++++++++++++++++++++- client/stt_dbus.h | 8 +++ common/stt_defs.h | 5 ++ server/sttd_dbus.c | 12 ++++ server/sttd_dbus_server.c | 174 ++++++++++++++++++++++++++++++++++++++++++++++ server/sttd_dbus_server.h | 8 +++ 6 files changed, 367 insertions(+), 2 deletions(-) diff --git a/client/stt_dbus.c b/client/stt_dbus.c index 4bc695f..a01bb4c 100644 --- a/client/stt_dbus.c +++ b/client/stt_dbus.c @@ -1391,8 +1391,6 @@ int stt_dbus_request_get_private_data(unsigned int uid, const char* key, char** return result; } - - int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* type, bool* support) { if (NULL == support || NULL == type) { @@ -1458,6 +1456,75 @@ int stt_dbus_request_is_recognition_type_supported(unsigned int uid, const char* 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; @@ -1634,6 +1701,97 @@ int stt_dbus_request_stop(unsigned int uid) 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; diff --git a/client/stt_dbus.h b/client/stt_dbus.h index 24a41ef..71e07a9 100644 --- a/client/stt_dbus.h +++ b/client/stt_dbus.h @@ -48,6 +48,8 @@ int stt_dbus_request_get_private_data(unsigned int uid, const char* key, char** 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); @@ -61,6 +63,12 @@ int stt_dbus_request_start(unsigned int uid, const char* lang, const char* type, 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); diff --git a/common/stt_defs.h b/common/stt_defs.h index fc6a502..02b3bc7 100644 --- a/common/stt_defs.h +++ b/common/stt_defs.h @@ -55,6 +55,7 @@ extern "C" { #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" @@ -79,6 +80,10 @@ extern "C" { #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 diff --git a/server/sttd_dbus.c b/server/sttd_dbus.c index ec69ac2..8adfea7 100644 --- a/server/sttd_dbus.c +++ b/server/sttd_dbus.c @@ -447,6 +447,9 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle 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); @@ -467,6 +470,15 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle 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); diff --git a/server/sttd_dbus_server.c b/server/sttd_dbus_server.c index 5ce8a9a..9dc9c9e 100644 --- a/server/sttd_dbus_server.c +++ b/server/sttd_dbus_server.c @@ -662,6 +662,56 @@ int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMes 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; @@ -854,6 +904,130 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg) 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; diff --git a/server/sttd_dbus_server.h b/server/sttd_dbus_server.h index da21771..3b0f3a7 100644 --- a/server/sttd_dbus_server.h +++ b/server/sttd_dbus_server.h @@ -52,6 +52,8 @@ int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg); 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); @@ -66,6 +68,12 @@ int sttd_dbus_server_start(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); -- 2.7.4