From: Youngwoo Cho Date: Fri, 18 Apr 2025 06:00:29 +0000 (+0900) Subject: Add inernal APIs related to UIBC X-Git-Tag: accepted/tizen/unified/20250516.055919^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fheads%2Ftizen;p=platform%2Fcore%2Fapi%2Fscreen-mirroring.git Add inernal APIs related to UIBC - both callbacks are related to UIBC - scmirroring_sink_set_src_display_orientation_notify_cb() - scmirroring_sink_set_uibc_info_received_cb() [Version] 0.3.5 Change-Id: Ie54aa1c2c62fe54bc66740607979c817f887b3f8 Signed-off-by: Youngwoo Cho --- diff --git a/include/scmirroring_internal.h b/include/scmirroring_internal.h index 75c4bb2..a6bb44f 100644 --- a/include/scmirroring_internal.h +++ b/include/scmirroring_internal.h @@ -204,6 +204,51 @@ int scmirroring_sink_send_generic_mouse_event(scmirroring_sink_h scmirroring_sin */ int scmirroring_sink_send_generic_key_event(scmirroring_sink_h scmirroring_sink, scmirroring_key_event_type_e event_type, unsigned short key_code_1, unsigned short key_code_2); + +/** + * @internal + * @brief Registers a callback function to be called when display orientation of screen mirroring source device is received. + * + * @since_tizen 10.0 + * + * @param[in] scmirroring_sink The handle to the screen mirroring sink + * @param[in] callback The callback function to invoke + * @param[in] user_data The user data passed to the callback registration function + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #SCMIRRORING_ERROR_NONE Successful + * @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory + * + * @pre Create a screen mirroring sink handle by calling scmirroring_sink_create(). + * + * @see scmirroring_sink_create() + */ +int scmirroring_sink_set_src_display_orientation_notify_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_src_display_orientation_notify_cb callback, void *user_data); + +/** + * @internal + * @brief Registers a callback function to be called when UIBC information is received. + * + * @since_tizen 10.0 + * + * @param[in] scmirroring_sink The handle to the screen mirroring sink + * @param[in] callback The callback function to invoke + * @param[in] user_data The user data passed to the callback registration function + * @return @c 0 on success, + * otherwise a negative error value + * + * @retval #SCMIRRORING_ERROR_NONE Successful + * @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory + * + * @pre Create a screen mirroring sink handle by calling scmirroring_sink_create(). + * + * @see scmirroring_sink_create() + */ +int scmirroring_sink_set_uibc_info_received_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_uibc_info_received_cb callback, void *user_data); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/include/scmirroring_private.h b/include/scmirroring_private.h index c0ddd0e..214984a 100644 --- a/include/scmirroring_private.h +++ b/include/scmirroring_private.h @@ -200,6 +200,16 @@ typedef struct { scmirroring_sink_state_cb state_cb; } scmirroring_sink_state_cb_s; +typedef struct { + void *user_data; + scmirroring_sink_src_display_orientation_notify_cb src_display_orientation_notify_cb; +} scmirroring_sink_src_display_orientation_notify_cb_s; + +typedef struct { + void *user_data; + scmirroring_sink_uibc_info_received_cb uibc_info_received_cb; +} scmirroring_sink_uibc_info_received_cb_s; + typedef struct { unsigned int magic_num; char *ip; @@ -229,6 +239,8 @@ typedef struct { char *port; bool use_hdcp; scmirroring_sink_state_cb_s *scmirroring_sink_state_cb; + scmirroring_sink_src_display_orientation_notify_cb_s *scmirroring_sink_src_display_orientation_notify_cb; + scmirroring_sink_uibc_info_received_cb_s *scmirroring_sink_uibc_info_received_cb; unsigned int magic_num; } scmirroring_sink_s; @@ -272,6 +284,7 @@ typedef struct { scmirroring_error_e _scmirroring_error_convert(const char *func, int error); scmirroring_sink_state_e _scmirroring_sink_state_convert(MMWFDSinkStateType mm_state); +scmirroring_display_orientation_e _scmirroring_sink_display_orientation_convert(MMWFDDisplayOrientation mm_orientation); scmirroring_state_e _scmirroring_src_state_convert(gchar *str); int _scmirroring_sink_prepare(MMHandleType handle); int _scmirroring_sink_connect(MMHandleType handle, const char *ip, const char *port); diff --git a/include/scmirroring_type_internal.h b/include/scmirroring_type_internal.h index 8173b59..cdfea75 100644 --- a/include/scmirroring_type_internal.h +++ b/include/scmirroring_type_internal.h @@ -17,6 +17,7 @@ #ifndef __TIZEN_MEDIA_SCMIRRORING_TYPE_INTERNAL_H__ #define __TIZEN_MEDIA_SCMIRRORING_TYPE_INTERNAL_H__ +#include #include #include @@ -124,6 +125,104 @@ typedef struct { scmirroring_uibc_mouse_s *uibc_object; /**< UIBC mouse */ } scmirroring_uibc_mouse_event_s; +/** + * @internal + * @brief Enumeration for screen mirroring display orientation. + * @since_tizen 10.0 + */ +typedef enum { + SCMIRRORING_DISPLAY_ORIENTATION_NONE = 0, + SCMIRRORING_DISPLAY_ORIENTATION_PORTRAIT_DISPLAY, + SCMIRRORING_DISPLAY_ORIENTATION_PORTRAIT, + SCMIRRORING_DISPLAY_ORIENTATION_LANDSCAPE +} scmirroring_display_orientation_e; + +/** + * @internal + * @brief Enumeration for screen mirroring UIBC input type. + * @since_tizen 10.0 + */ +typedef enum { + SCMIRRORING_UIBC_INPUT_TYPE_UNKNOWN = 0, + SCMIRRORING_UIBC_INPUT_TYPE_KEYBOARD = (1 << 0), + SCMIRRORING_UIBC_INPUT_TYPE_MOUSE = (1 << 1), + SCMIRRORING_UIBC_INPUT_TYPE_SINGLETOUCH = (1 << 2), + SCMIRRORING_UIBC_INPUT_TYPE_MULTITOUCH = (1 << 3), + SCMIRRORING_UIBC_INPUT_TYPE_JOYSTICK = (1 << 4), + SCMIRRORING_UIBC_INPUT_TYPE_CAMERA = (1 << 5), + SCMIRRORING_UIBC_INPUT_TYPE_GESTURE = (1 << 6), + SCMIRRORING_UIBC_INPUT_TYPE_REMOTECONTROL = (1 << 7) +} scmirroring_uibc_input_type_e; + +/** + * @internal + * @brief Enumeration for screen mirroring UIBC input path. + * @since_tizen 10.0 + */ +typedef enum { + SCMIRRORING_UIBC_INPUT_PATH_UNKNOWN = 0, + SCMIRRORING_UIBC_INPUT_PATH_INFRARED = (1 << 0), + SCMIRRORING_UIBC_INPUT_PATH_USB = (1 << 1), + SCMIRRORING_UIBC_INPUT_PATH_BT = (1 << 2), + SCMIRRORING_UIBC_INPUT_PATH_ZIGBEE = (1 << 3), + SCMIRRORING_UIBC_INPUT_PATH_WIFI = (1 << 4), + SCMIRRORING_UIBC_INPUT_PATH_NOSP = (1 << 5) +} scmirroring_uibc_input_path_e; + +/** + * @internal + * @brief Screen mirroring UIBC input. + * @since_tizen 10.0 + */ +typedef struct { + scmirroring_uibc_input_type_e type; + scmirroring_uibc_input_path_e path; +} scmirroring_uibc_input_s; + +/** + * @internal + * @brief Screen mirroring UIBC information. + * @since_tizen 10.0 + */ +typedef struct { + char *ip; + uint32_t port; + uint32_t gen_capability; + int32_t width; + int32_t height; + scmirroring_uibc_input_s *hidc_caps_list; + uint32_t hidc_caps_count; +} scmirroring_uibc_info_s; + +/** + * @internal + * @brief Called when display orientation of screen mirroring source is received. + * @since_tizen 10.0 + * + * @details This callback is called for display orientation of screen mirroring source will be received. + * + * @param[in] orientation The display orientation of screen mirroring source device + * @param[in] user_data The user data passed from the scmirroring_sink_set_src_display_orientation_notify_cb() function + * + * @see scmirroring_sink_set_src_display_orientation_notify_cb() + */ +typedef void(*scmirroring_sink_src_display_orientation_notify_cb)(scmirroring_display_orientation_e orientation, void *user_data); + +/** + * @internal + * @brief Called when UIBC information is received. + * @since_tizen 10.0 + * + * @details This callback is called for UIBC information will be received. + * + * @param[in] error The error code + * @param[in] uibc_info The UIBC information + * @param[in] user_data The user data passed from the scmirroring_sink_set_uibc_info_received_cb() function + * + * @see scmirroring_sink_set_uibc_info_received_cb() + */ +typedef void(*scmirroring_sink_uibc_info_received_cb)(scmirroring_error_e error, scmirroring_uibc_info_s *uibc_info, void *user_data); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/packaging/capi-media-screen-mirroring.spec b/packaging/capi-media-screen-mirroring.spec index e84109f..5fb4759 100644 --- a/packaging/capi-media-screen-mirroring.spec +++ b/packaging/capi-media-screen-mirroring.spec @@ -1,6 +1,6 @@ Name: capi-media-screen-mirroring Summary: A screen mirroring library in Tizen C API -Version: 0.3.4 +Version: 0.3.5 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/scmirroring_sink.c b/src/scmirroring_sink.c index 2bd5a4f..5345b55 100644 --- a/src/scmirroring_sink.c +++ b/src/scmirroring_sink.c @@ -57,6 +57,8 @@ int scmirroring_sink_create(scmirroring_sink_h *scmirroring_sink) handle->port = NULL; handle->use_hdcp = TRUE; handle->scmirroring_sink_state_cb = NULL; + handle->scmirroring_sink_src_display_orientation_notify_cb = NULL; + handle->scmirroring_sink_uibc_info_received_cb = NULL; handle->magic_num = SCMIRRORING_MAGIC_NUMBER; ret = mm_wfd_sink_create(&handle->mm_handle); @@ -144,6 +146,8 @@ int scmirroring_sink_destroy(scmirroring_sink_h scmirroring_sink) SCMIRRORING_SAFE_FREE(handle->ip); SCMIRRORING_SAFE_FREE(handle->port); SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_state_cb); + SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_src_display_orientation_notify_cb); + SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_uibc_info_received_cb); SCMIRRORING_SAFE_FREE(handle); ret = _scmirroring_error_convert(__func__, ret); diff --git a/src/scmirroring_sink_internal.c b/src/scmirroring_sink_internal.c index fa1c5d2..b0003e8 100644 --- a/src/scmirroring_sink_internal.c +++ b/src/scmirroring_sink_internal.c @@ -21,6 +21,26 @@ #include #include +static void __mm_scmirroring_sink_src_display_orientation_notify_cb(MMWFDDisplayOrientation mm_orientation, void *user_data) +{ + scmirroring_display_orientation_e orientation = _scmirroring_sink_display_orientation_convert(mm_orientation); + scmirroring_sink_s *handle = (scmirroring_sink_s *)user_data; + + /* call application callback */ + if (handle && handle->scmirroring_sink_src_display_orientation_notify_cb && handle->scmirroring_sink_src_display_orientation_notify_cb->src_display_orientation_notify_cb) + handle->scmirroring_sink_src_display_orientation_notify_cb->src_display_orientation_notify_cb(orientation, handle->scmirroring_sink_src_display_orientation_notify_cb->user_data); +} + +static void __mm_scmirroring_sink_uibc_info_received_cb(int error_type, MMWFDUibcInfo *mm_uibc_info, void *user_data) +{ + scmirroring_error_e error = _scmirroring_error_convert(__func__, error_type); + scmirroring_sink_s *handle = (scmirroring_sink_s *)user_data; + + /* call application callback */ + if (handle && handle->scmirroring_sink_uibc_info_received_cb && handle->scmirroring_sink_uibc_info_received_cb->uibc_info_received_cb) + handle->scmirroring_sink_uibc_info_received_cb->uibc_info_received_cb(error, (scmirroring_uibc_info_s *)mm_uibc_info, handle->scmirroring_sink_uibc_info_received_cb->user_data); +} + static gboolean __is_valid_handle(scmirroring_sink_s *handle) { scmirroring_retvm_if(!handle, FALSE, "scmirroring_sink_s is NULL"); @@ -87,3 +107,53 @@ int scmirroring_sink_send_generic_key_event(scmirroring_sink_h scmirroring_sink, return _scmirroring_sink_send_generic_key_event(handle->mm_handle, event_type, key_code_1, key_code_2); } + +int scmirroring_sink_set_src_display_orientation_notify_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_src_display_orientation_notify_cb callback, void *user_data) +{ + scmirroring_sink_s *handle = (scmirroring_sink_s *)scmirroring_sink; + + scmirroring_debug_fenter(); + + scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid"); + scmirroring_retvm_if(callback == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "callback is NULL"); + + if (handle->scmirroring_sink_src_display_orientation_notify_cb == NULL) { + handle->scmirroring_sink_src_display_orientation_notify_cb = (scmirroring_sink_src_display_orientation_notify_cb_s *)calloc(1, sizeof(scmirroring_sink_src_display_orientation_notify_cb_s)); + if (handle->scmirroring_sink_src_display_orientation_notify_cb == NULL) { + scmirroring_error("Error Set CB"); + return SCMIRRORING_ERROR_OUT_OF_MEMORY; + } + } else { + memset(handle->scmirroring_sink_src_display_orientation_notify_cb, 0, sizeof(scmirroring_sink_src_display_orientation_notify_cb_s)); + } + + handle->scmirroring_sink_src_display_orientation_notify_cb->user_data = user_data; + handle->scmirroring_sink_src_display_orientation_notify_cb->src_display_orientation_notify_cb = callback; + + return _scmirroring_error_convert(__func__, mm_wfd_sink_set_src_display_orientation_notify_callback(handle->mm_handle, __mm_scmirroring_sink_src_display_orientation_notify_cb, handle)); +} + +int scmirroring_sink_set_uibc_info_received_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_uibc_info_received_cb callback, void *user_data) +{ + scmirroring_sink_s *handle = (scmirroring_sink_s *)scmirroring_sink; + + scmirroring_debug_fenter(); + + scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_sink is invalid"); + scmirroring_retvm_if(callback == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "callback is NULL"); + + if (handle->scmirroring_sink_uibc_info_received_cb == NULL) { + handle->scmirroring_sink_uibc_info_received_cb = (scmirroring_sink_uibc_info_received_cb_s *)calloc(1, sizeof(scmirroring_sink_uibc_info_received_cb_s)); + if (handle->scmirroring_sink_uibc_info_received_cb == NULL) { + scmirroring_error("Error Set CB"); + return SCMIRRORING_ERROR_OUT_OF_MEMORY; + } + } else { + memset(handle->scmirroring_sink_uibc_info_received_cb, 0, sizeof(scmirroring_sink_uibc_info_received_cb_s)); + } + + handle->scmirroring_sink_uibc_info_received_cb->user_data = user_data; + handle->scmirroring_sink_uibc_info_received_cb->uibc_info_received_cb = callback; + + return _scmirroring_error_convert(__func__, mm_wfd_sink_set_uibc_info_received_callback(handle->mm_handle, __mm_scmirroring_sink_uibc_info_received_cb, handle)); +} diff --git a/src/scmirroring_util.c b/src/scmirroring_util.c index 694dc95..fbaecf2 100644 --- a/src/scmirroring_util.c +++ b/src/scmirroring_util.c @@ -92,6 +92,22 @@ scmirroring_sink_state_e _scmirroring_sink_state_convert(MMWFDSinkStateType mm_s return state; } +scmirroring_display_orientation_e _scmirroring_sink_display_orientation_convert(MMWFDDisplayOrientation mm_orientation) +{ + switch (mm_orientation) { + case MM_WFD_DISPLAY_ORIENTATION_NONE: + return SCMIRRORING_DISPLAY_ORIENTATION_NONE; + case MM_WFD_DISPLAY_ORIENTATION_PORTRAIT_DISPLAY: + return SCMIRRORING_DISPLAY_ORIENTATION_PORTRAIT_DISPLAY; + case MM_WFD_DISPLAY_ORIENTATION_PORTRAIT: + return SCMIRRORING_DISPLAY_ORIENTATION_PORTRAIT; + case MM_WFD_DISPLAY_ORIENTATION_LANDSCAPE: + return SCMIRRORING_DISPLAY_ORIENTATION_LANDSCAPE; + default: + return SCMIRRORING_DISPLAY_ORIENTATION_NONE; + } +} + scmirroring_state_e _scmirroring_src_state_convert(gchar *str) { if (g_strrstr(str, "LISTENING"))