scmirroring_state_cb state_cb;
}scmirroring_state_cb_s;
+typedef struct
+{
+ int error_code;
+ int sink_state;
+ void *user_data;
+ scmirroring_sink_state_cb state_cb;
+}scmirroring_sink_state_cb_s;
+
typedef struct
{
char *ip;
char *ip;
char *port;
bool use_hdcp;
- scmirroring_state_cb_s *scmirroring_state_cb;
+ scmirroring_sink_state_cb_s *scmirroring_sink_state_cb;
} scmirroring_sink_s;
#ifdef __cplusplus
/**
* @brief Creates a new screen mirroring sink handle
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
+ *
* @remarks You must release @a scmirroring_sink using scmirroring_sink_destroy().
*
* @param[out] scmirroring_sink A newly returned handle to the screen mirroring sink
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
+ *
+ * @post The screen mirroring state will be SCMIRRORING_STATE_NULL
*
* @see scmirroring_sink_destroy()
*/
* @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
*
* @see scmirroring_sink_create()
*/
-int scmirroring_sink_set_state_changed_cb(scmirroring_sink_h scmirroring_sink, scmirroring_state_cb callback, void *user_data);
+int scmirroring_sink_set_state_changed_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_state_cb callback, void *user_data);
/**
* @brief Sets server IP and port
* @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
*
* @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
*
* @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
*
/**
* @brief Prepares the screen mirroring sink handle and allocates specific resources.
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
- * @return 0 on success, otherwise a negative error value.
+ * @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
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre Register user callback by calling scmirroring_sink_set_state_changed_cb().
- * @post The screen mirroring state will be SCMIRRORING_STATE_READY
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_NULL
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_PREPARED
*
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
* @brief Creates connection and prepare for receiving data from SCMIRRORING source
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
* @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre Register user callback by calling scmirroring_sink_set_state_changed_cb().
* @pre Call scmirroring_sink_prepare()
- * @post The screen mirroring state will be SCMIRRORING_STATE_CONNECTED
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_PREPARED
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_CONNECTED
*
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
* @brief Start receiving data from the SCMIRRORING source and display it (mirror)
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
* @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre Register user callback by calling scmirroring_sink_set_state_changed_cb().
* @pre Call scmirroring_sink_prepare()
- * @post The screen mirroring state will be SCMIRRORING_STATE_PLAYING
+ * @pre Call scmirroring_sink_connect()
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_CONNECTED
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_PLAYING
*
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
/**
* @brief Pauses receiving data from the SCMIRRORING source
- * @details This function pauses receiving data from the SCMIRRORING source, which means it sends RTSP PAUSE message to source.
+ * @details This function pauses receiving data from the SCMIRRORING source,
+ * which means it sends RTSP PAUSE message to source.
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
- * @pre The screen mirroring state should be SCMIRRORING_STATE_PLAYING
- * @post The screen mirroring state will be SCMIRRORING_STATE_PAUSED
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_PLAYING
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_PAUSED
*
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
* @details This function pauses receiving data from the SCMIRRORING source, which means it sends RTSP PLAY message to source.
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
- * @pre The screen mirroring state should be SCMIRRORING_STATE_PAUSED
- * @post The screen mirroring state will be SCMIRRORING_STATE_PLAYING
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_PAUSED
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_PLAYING
*
* @see scmirroring_sink_pause()
*/
int scmirroring_sink_resume(scmirroring_sink_h scmirroring_sink);
/**
- * @brief Stops receiving data from the SCMIRRORING source
+ * @brief Disconnects and stops receiving data from the SCMIRRORING source
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
- * @pre The screen mirroring state should be SCMIRRORING_STATE_PAUSED or SCMIRRORING_STATE_PLAYING
- * @post The screen mirroring state will be SCMIRRORING_STATE_TEARDOWN
+ * @pre The screen mirroring state should be SCMIRRORING_SINK_STATE_CONNECTED
+ * or SCMIRRORING_SINK_STATE_PLAYING or SCMIRRORING_SINK_STATE_PAUSED
+ * @post The screen mirroring state will be SCMIRRORING_SINK_STATE_DISCONNECTED
*
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
* @see scmirroring_sink_connect()
* @see scmirroring_sink_start()
*/
-int scmirroring_sink_stop(scmirroring_sink_h scmirroring_sink);
+int scmirroring_sink_disconnect(scmirroring_sink_h scmirroring_sink);
/**
* @brief Unprepares screen mirroring
* @details This function unprepares screen mirroring, which closes specific resources.
*
* @since_tizen 2.4
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/internet
*
* @param[in] scmirroring_sink The handle to the screen mirroring sink
* @return @c 0 on success,
* @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
* @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre Register user callback by calling scmirroring_sink_set_state_changed_cb().
* 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
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre Register user callback by calling scmirroring_sink_set_state_changed_cb().
* @see scmirroring_sink_create()
* @see scmirroring_sink_set_state_changed_cb()
*/
-int scmirroring_sink_unset_state_cb(scmirroring_sink_h scmirroring_sink);
+int scmirroring_sink_unset_state_changed_cb(scmirroring_sink_h scmirroring_sink);
/**
* @brief Destroys screen mirroring sink handle.
* 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
* @retval #SCMIRRORING_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SCMIRRORING_ERROR_PERMISSION_DENIED Permission Denied
+ * @retval #SCMIRRORING_ERROR_NOT_SUPPORTED Not supported
+ * @retval #SCMIRRORING_ERROR_UNKNOWN Unknown Error
*
* @pre Create a screen mirroring sink handle by calling scmirroring_sink_create().
* @pre The screen mirroring state should be SCMIRRORING_STATE_NULL
SCMIRRORING_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
SCMIRRORING_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
SCMIRRORING_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
- SCMIRRORING_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid Operation */
+ SCMIRRORING_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid Operation */
SCMIRRORING_ERROR_CONNECTION_TIME_OUT = TIZEN_ERROR_CONNECTION_TIME_OUT, /**< Connection timeout */
- SCMIRRORING_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
- SCMIRRORING_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ SCMIRRORING_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
+ SCMIRRORING_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ SCMIRRORING_ERROR_UNKNOWN = TIZEN_ERROR_UNKNOWN, /**< Unknown error */
} scmirroring_error_e;
/**
- * @brief Enumeration for screen mirroring state.
+ * @brief Enumeration for screen mirroring source state.
* @since_tizen 2.4
*/
typedef enum
{
SCMIRRORING_STATE_NULL = 0, /**< Screen mirroring is created, but not realized yet */
- SCMIRRORING_STATE_READY, /**< Screen mirroring is ready to play media */
+ SCMIRRORING_STATE_READY, /**< Screen mirroring is ready to play media */
SCMIRRORING_STATE_CONNECTION_WAIT, /**< Screen mirroring is waiting for connection */
SCMIRRORING_STATE_CONNECTED, /**< Screen mirroring is connected */
SCMIRRORING_STATE_PLAYING, /**< Screen mirroring is now playing media */
- SCMIRRORING_STATE_PAUSED, /**< Screen mirroring is paused while playing media */
+ SCMIRRORING_STATE_PAUSED, /**< Screen mirroring is paused while playing media */
SCMIRRORING_STATE_TEARDOWN, /**< Teardown Screen mirroring */
SCMIRRORING_STATE_NONE, /**< Screen mirroring is not created yet */
SCMIRRORING_STATE_MAX /* Number of screen mirroring states */
} scmirroring_state_e;
+/**
+ * @brief Enumeration for screen mirroring sink state.
+ * @since_tizen 2.4
+ */
+typedef enum
+{
+ SCMIRRORING_SINK_STATE_NONE = 0, /**< Screen mirroring is not created yet */
+ SCMIRRORING_SINK_STATE_NULL, /**< Screen mirroring is created, but not prepared yet */
+ SCMIRRORING_SINK_STATE_PREPARED, /**< Screen mirroring is prepared to play media */
+ SCMIRRORING_SINK_STATE_CONNECTED, /**< Screen mirroring is connected */
+ SCMIRRORING_SINK_STATE_PLAYING, /**< Screen mirroring is now playing media */
+ SCMIRRORING_SINK_STATE_PAUSED, /**< Screen mirroring is paused while playing media */
+ SCMIRRORING_SINK_STATE_DISCONNECTED, /**< Screen mirroring is dieconnected */
+ SCMIRRORING_SINK_STATE_MAX /* Number of screen mirroring states */
+} scmirroring_sink_state_e;
+
/**
* @brief Enumeration for screen mirroring resolution.
* @since_tizen 2.4
*/
typedef void (*scmirroring_state_cb)(scmirroring_error_e error, scmirroring_state_e state, void *user_data);
+/**
+ * @brief Called when each status is changed
+ * @since_tizen 2.4
+ *
+ * @details This callback is called for state and error of screen mirroring sink
+ *
+ * @param[in] error The error code
+ * @param[in] state The screen mirroring sink state
+ * @param[in] user_data The user data passed from the scmirroring_sink_set_state_cb() function
+ *
+ * @pre scmirroring_sink_create()
+ *
+ * @see scmirroring_sink_create()
+ */
+typedef void (*scmirroring_sink_state_cb)(scmirroring_error_e error, scmirroring_sink_state_e state, void *user_data);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
Name: capi-media-screen-mirroring
Summary: A screen mirroring library in Tizen C API
-Version: 0.1.22
+Version: 0.1.23
Release: 0
Group: Multimedia/API
License: Apache License, Version 2.0
return ret;
}
-static scmirroring_state_e __scmirroring_sink_state_convert(MMWfdSinkStateType mm_state)
+static scmirroring_sink_state_e __scmirroring_sink_state_convert(MMWFDSinkStateType mm_state)
{
- scmirroring_state_e state = SCMIRRORING_STATE_NULL;
+ scmirroring_sink_state_e state = SCMIRRORING_SINK_STATE_NONE;
switch( mm_state )
{
+ case MM_WFD_SINK_STATE_NONE:
+ state = SCMIRRORING_SINK_STATE_NONE;
+ break;
case MM_WFD_SINK_STATE_NULL:
- state = SCMIRRORING_STATE_NULL;
+ state = SCMIRRORING_SINK_STATE_NULL;
+ break;
+ case MM_WFD_SINK_STATE_PREPARED:
+ state = SCMIRRORING_SINK_STATE_PREPARED;
break;
- case MM_WFD_SINK_STATE_READY:
- state = SCMIRRORING_STATE_READY;
+ case MM_WFD_SINK_STATE_CONNECTED:
+ state = SCMIRRORING_SINK_STATE_CONNECTED;
break;
case MM_WFD_SINK_STATE_PLAYING:
- state = SCMIRRORING_STATE_PLAYING;
+ state = SCMIRRORING_SINK_STATE_PLAYING;
break;
case MM_WFD_SINK_STATE_PAUSED:
- state = SCMIRRORING_STATE_PAUSED;
+ state = SCMIRRORING_SINK_STATE_PAUSED;
break;
- case MM_WFD_SINK_STATE_TEARDOWN:
- state = SCMIRRORING_STATE_TEARDOWN;
- break;
- case MM_WFD_SINK_STATE_NONE:
- state = SCMIRRORING_STATE_NULL;
+ case MM_WFD_SINK_STATE_DISCONNECTED:
+ state = SCMIRRORING_SINK_STATE_DISCONNECTED;
break;
default:
- state = SCMIRRORING_STATE_NULL;
+ state = SCMIRRORING_SINK_STATE_NONE;
break;
}
return state;
}
-void __mm_scmirroring_sink_set_message_cb(MMWfdSinkStateType type, void *uData)
+void __mm_scmirroring_sink_set_message_cb(int error_type, MMWFDSinkStateType state_type, void *uData)
{
- int error_value = SCMIRRORING_ERROR_NONE;
- scmirroring_state_e state = __scmirroring_sink_state_convert(type);
+ scmirroring_error_e error = __scmirroring_sink_error_convert(__func__, error_type);
+ scmirroring_sink_state_e state = __scmirroring_sink_state_convert(state_type);
scmirroring_sink_s *handle = (scmirroring_sink_s*)uData;
/* call application callback */
- if (handle->scmirroring_state_cb->state_cb)
- handle->scmirroring_state_cb->state_cb((scmirroring_error_e)error_value, state, handle->scmirroring_state_cb->user_data);
+ if (handle->scmirroring_sink_state_cb->state_cb)
+ handle->scmirroring_sink_state_cb->state_cb(error, state, handle->scmirroring_sink_state_cb->user_data);
return;
}
handle->ip= NULL;
handle->port = NULL;
handle->use_hdcp = TRUE;
+ handle->scmirroring_sink_state_cb = NULL;
ret = mm_wfd_sink_create(&handle->mm_handle);
if(ret != MM_ERROR_NONE)
scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
- ret = mm_wfd_sink_realize(handle->mm_handle);
+ ret = mm_wfd_sink_prepare(handle->mm_handle);
ret = __scmirroring_sink_error_convert(__func__, ret);
if(handle->ip == NULL)
{
- scmirroring_error("INVALID_IP (0x%08x)",SCMIRRORING_ERROR_INVALID_PARAMETER);
+ scmirroring_error("INVALID_IP(NULL) (0x%08x)",SCMIRRORING_ERROR_INVALID_PARAMETER);
return SCMIRRORING_ERROR_INVALID_PARAMETER;
}
if(handle->port == NULL)
{
- scmirroring_error("INVALID_PORT (0x%08x)",SCMIRRORING_ERROR_INVALID_PARAMETER);
+ scmirroring_error("INVALID_PORT(NULL) (0x%08x)",SCMIRRORING_ERROR_INVALID_PARAMETER);
return SCMIRRORING_ERROR_INVALID_PARAMETER;
}
scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
- ret = mm_wfd_sink_unrealize(handle->mm_handle);
+ ret = mm_wfd_sink_unprepare(handle->mm_handle);
ret = __scmirroring_sink_error_convert(__func__, ret);
ret = mm_wfd_sink_destroy(handle->mm_handle);
+ handle->mm_handle = 0;
SCMIRRORING_SAFE_FREE(handle->ip);
SCMIRRORING_SAFE_FREE(handle->port);
- SCMIRRORING_SAFE_FREE(handle->scmirroring_state_cb);
+ SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_state_cb);
SCMIRRORING_SAFE_FREE(handle);
ret = __scmirroring_sink_error_convert(__func__, ret);
return ret;
}
-int scmirroring_sink_stop(scmirroring_sink_h scmirroring_sink)
+int scmirroring_sink_disconnect(scmirroring_sink_h scmirroring_sink)
{
int ret = SCMIRRORING_ERROR_NONE;
scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
- ret = mm_wfd_sink_stop(handle->mm_handle);
+ ret = mm_wfd_sink_disconnect(handle->mm_handle);
ret = __scmirroring_sink_error_convert(__func__, ret);
return ret;
}
-int scmirroring_sink_set_state_changed_cb(scmirroring_sink_h scmirroring_sink, scmirroring_state_cb callback, void *user_data)
+int scmirroring_sink_set_state_changed_cb(scmirroring_sink_h scmirroring_sink, scmirroring_sink_state_cb callback, void *user_data)
{
int ret = SCMIRRORING_ERROR_NONE;
scmirroring_error_fenter();
scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ scmirroring_retvm_if(callback == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "callback is NULL");
- handle->scmirroring_state_cb = (scmirroring_state_cb_s*)calloc(1, sizeof(scmirroring_state_cb_s));
-
- if(handle->scmirroring_state_cb == NULL)
+ if(handle->scmirroring_sink_state_cb == NULL)
+ {
+ handle->scmirroring_sink_state_cb = (scmirroring_sink_state_cb_s*)calloc(1, sizeof(scmirroring_sink_state_cb_s));
+ if(handle->scmirroring_sink_state_cb == NULL)
+ {
+ scmirroring_error("Error Set CB");
+ return SCMIRRORING_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
{
- scmirroring_error("Error Set CB");
- return SCMIRRORING_ERROR_OUT_OF_MEMORY;
+ memset(handle->scmirroring_sink_state_cb, 0, sizeof(scmirroring_sink_state_cb_s));
}
- handle->scmirroring_state_cb->user_data = user_data;
- handle->scmirroring_state_cb->state_cb = callback;
+ handle->scmirroring_sink_state_cb->user_data = user_data;
+ handle->scmirroring_sink_state_cb->state_cb = callback;
ret = mm_wfd_sink_set_message_callback(handle->mm_handle, __mm_scmirroring_sink_set_message_cb, handle);
return ret;
}
+int scmirroring_sink_unset_state_changed_cb(scmirroring_sink_h scmirroring_sink)
+{
+ int ret = SCMIRRORING_ERROR_NONE;
+
+ scmirroring_sink_s *handle = (scmirroring_sink_s*)scmirroring_sink;
+
+ scmirroring_error_fenter();
+
+ scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ ret = mm_wfd_sink_set_message_callback(handle->mm_handle, NULL, NULL);
+
+ SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_state_cb);
+
+ ret = __scmirroring_sink_error_convert(__func__, ret);
+
+ scmirroring_error_fleave();
+
+ return ret;
+}
+
int scmirroring_sink_set_display(scmirroring_sink_h scmirroring_sink, scmirroring_display_type_e type, void * display_surface)
{
int ret = SCMIRRORING_ERROR_NONE;
return __scmirroring_sink_error_convert(__func__,ret);
}
- ret = mm_wfd_sink_set_attribute(handle->mm_handle, NULL, "display_overlay", display_surface, NULL);
+ ret = mm_wfd_sink_set_attribute(handle->mm_handle, NULL, "display_overlay", display_surface, sizeof(display_surface), NULL);
if(ret != MM_ERROR_NONE)
{
scmirroring_error("Fail to Set Display Overlay");
return ret;
}
+
+int scmirroring_sink_set_resolution(scmirroring_sink_h scmirroring_sink, scmirroring_resolution_e resolution)
+{
+ int ret = SCMIRRORING_ERROR_NONE;
+
+ scmirroring_sink_s *handle = (scmirroring_sink_s*)scmirroring_sink;
+
+ scmirroring_error_fenter();
+
+ scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ if((resolution < SCMIRRORING_RESOLUTION_1920x1080_P30) ||(resolution >= SCMIRRORING_RESOLUTION_MAX))
+ {
+ scmirroring_error("INVALID resolution : %d", resolution);
+ return SCMIRRORING_ERROR_INVALID_PARAMETER;
+ }
+
+ scmirroring_error_fleave();
+
+ return ret;
+}
+
+int scmirroring_sink_pause(scmirroring_sink_h scmirroring_sink)
+{
+ int ret = SCMIRRORING_ERROR_NONE;
+
+ scmirroring_sink_s *handle = (scmirroring_sink_s*)scmirroring_sink;
+
+ scmirroring_error_fenter();
+
+ scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ scmirroring_error_fleave();
+
+ return ret;
+}
+
+int scmirroring_sink_resume(scmirroring_sink_h scmirroring_sink)
+{
+ int ret = SCMIRRORING_ERROR_NONE;
+
+ scmirroring_sink_s *handle = (scmirroring_sink_s*)scmirroring_sink;
+
+ scmirroring_error_fenter();
+
+ scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ scmirroring_error_fleave();
+
+ return ret;
+}
static int g_peer_cnt = 0;
static char g_peer_ip[32];
static char g_peer_port[32];
+#define DEFAULT_SCREEN_MIRRORING_PORT 2022
#endif
gboolean __scmirroring_sink_start(gpointer data);
static gboolean __disconnect_p2p_connection(void);
#endif
-static void scmirroring_state_callback(scmirroring_error_e error_code, scmirroring_state_e state, void *user_data)
+static void scmirroring_sink_state_callback(scmirroring_error_e error_code, scmirroring_sink_state_e state, void *user_data)
{
g_print("Received Callback error code[%d]", error_code);
- if(state == SCMIRRORING_STATE_NULL)
- g_print(" st ate[%d] SCMIRRORING_STATE_NULL", state);
- else if(state ==SCMIRRORING_STATE_READY)
- g_print(" state[%d] SCMIRRORING_STATE_READY", state);
- else if(state == SCMIRRORING_STATE_CONNECTION_WAIT)
- g_print(" state[%d] SCMIRRORING_STATE_CONNECTION_WAIT", state);
- else if(state == SCMIRRORING_STATE_CONNECTED)
- g_print(" state[%d] SCMIRRORING_STATE_CONNECTED", state);
- else if(state == SCMIRRORING_STATE_PLAYING)
- g_print(" state[%d] SCMIRRORING_STATE_PLAYING", state);
- else if(state == SCMIRRORING_STATE_PAUSED)
- g_print(" state[%d] SCMIRRORING_STATE_PAUSED", state);
- else if(state == SCMIRRORING_STATE_TEARDOWN)
- g_print(" state[%d] SCMIRRORING_STATE_TEARDOWN", state);
- else if(state == SCMIRRORING_STATE_NONE)
- g_print(" state[%d] SCMIRRORING_STATE_NONE", state);
+ if(state == SCMIRRORING_SINK_STATE_NONE)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_NONE", state);
+ else if(state == SCMIRRORING_SINK_STATE_NULL)
+ g_print(" st ate[%d] (state == SCMIRRORING_SINK_STATE_NULL)", state);
+ else if(state ==SCMIRRORING_SINK_STATE_PREPARED)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_PREPARED", state);
+ else if(state == SCMIRRORING_SINK_STATE_CONNECTED)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_CONNECTED", state);
+ if(scmirroring_sink_start(g_scmirroring)!= SCMIRRORING_ERROR_NONE)
+ g_print("scmirroring_sink_start fail");
+ else if(state == SCMIRRORING_SINK_STATE_PLAYING)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_PLAYING", state);
+ else if(state == SCMIRRORING_SINK_STATE_PAUSED)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_PAUSED", state);
+ else if(state == SCMIRRORING_SINK_STATE_DISCONNECTED)
+ g_print(" state[%d] SCMIRRORING_SINK_STATE_DISCONNECTED", state);
else
g_print(" state[%d] Invalid State", state);
g_print("a : a ip port (ex. a 192.168.49.1 2022)\n");
g_print("s : start \n");
#endif
- g_print("T : sTop\n");
- g_print("D : Destroy\n");
+ g_print("D : Disconnect\n");
+ g_print("T : desTroy\n");
g_print("q : quit\n");
g_print("-----------------------------------------------------------------------------------------\n");
}
#ifdef TEST_WITH_WIFI_DIRECT
bool _connected_peer_cb(wifi_direct_connected_peer_info_s *peer, void *user_data)
{
+ int peer_port = 0;
+ if (wifi_direct_get_peer_display_port(peer->mac_address, &peer_port) != WIFI_DIRECT_ERROR_NONE)
+ {
+ g_print ("Can not get port info\n Use default (2022)\n");
+ peer_port = DEFAULT_SCREEN_MIRRORING_PORT;
+ }
+ if (peer_port == 0)
+ {
+ g_print ("Can not get port info\n Use default (2022)\n");
+ peer_port = DEFAULT_SCREEN_MIRRORING_PORT;
+ }
+
g_print("[_connected_peer_cb] Connected to IP [%s]\n", peer->ip_address);
- g_print("[_connected_peer_cb] Connected to Port [%d]\n", peer->scmirroring_ctrl_port);
+ g_print("[_connected_peer_cb] Connected to Port [%d]\n", peer_port);
g_print("[_connected_peer_cb] Connected device_name [%s]\n", peer->device_name);
g_print("[_connected_peer_cb] Connected to mac_address [%s]\n", peer->mac_address);
g_print("[_connected_peer_cb] Connected to interface_address [%s]\n", peer->interface_address);
memset(g_peer_port, 0x00, sizeof(g_peer_port));
snprintf(g_peer_ip, sizeof(g_peer_port), "%s", peer->ip_address);
- snprintf(g_peer_port, sizeof(g_peer_port), "%d", peer->scmirroring_ctrl_port);
+ snprintf(g_peer_port, sizeof(g_peer_port), "%d", peer_port);
g_timeout_add(SINKTEST_EXECUTE_DELAY, __scmirroring_sink_start, NULL);
int ret = SCMIRRORING_ERROR_NONE;
gchar **value;
value = g_strsplit(cmd," ",0);
-#if 0
- gchar **value;
- value = g_strsplit(cmd," ",0);
-#endif
- if(strncmp(cmd, "T", 1) == 0)
+ if(strncmp(cmd, "D", 1) == 0)
{
- g_print ("Stop\n");
- ret = scmirroring_sink_stop(g_scmirroring);
+ g_print ("Disconnect\n");
+ ret = scmirroring_sink_disconnect(g_scmirroring);
}
- else if(strncmp(cmd, "D", 1) == 0)
+ else if(strncmp(cmd, "T", 1) == 0)
{
g_print ("Destroy\n");
ret = scmirroring_sink_unprepare(g_scmirroring);
}
/*Enable Screen Mirroring*/
- ret = wifi_direct_display_init();
+ ret = wifi_direct_init_display();
if(ret != WIFI_DIRECT_ERROR_NONE)
{
g_print("Error : wifi_direct_display_init failed : %d\n", ret);
}
/*Enable Wifi Direct - You can set this as true if you want to see it from wifi-direct list*/
- ret = wifi_direct_display_set_wifi_direct(false);
+ ret = wifi_direct_set_display_availability(TRUE);
if(ret != WIFI_DIRECT_ERROR_NONE)
{
g_print("Error : wifi_direct_display_init failed : %d\n", ret);
goto error;
}
- ret = wifi_direct_display_set_device(WIFI_DISPLAY_TYPE_PRIMARY_SINK, 77, 0);
+ ret = wifi_direct_set_display(WIFI_DISPLAY_TYPE_SINK, 2022, 0);
if(ret != WIFI_DIRECT_ERROR_NONE)
{
g_print("Error : wifi_direct_display_set_device failed : %d\n", ret);
}
#endif
- ret = scmirroring_sink_set_state_changed_cb(g_scmirroring, scmirroring_state_callback, NULL);
+ ret = scmirroring_sink_set_state_changed_cb(g_scmirroring, scmirroring_sink_state_callback, NULL);
if(ret != SCMIRRORING_ERROR_NONE)
{
g_print("scmirroring_sink_set_state_changed_cb fail [%d]", ret);
return FALSE;
}
#endif
-
- ret = scmirroring_sink_start(g_scmirroring);
- if(ret != SCMIRRORING_ERROR_NONE)
- {
- g_print("scmirroring_sink_start fail [%d]", ret);
- return FALSE;
- }
-
return FALSE;
}
projects / platform / core / api / screen-mirroring.git / commitdiff