*/
/**
- * @brief Called when updating status of the media controller server.
+ * @brief Called when the status of the media controller server is updated.
* @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_server_state_updated_cb)(const char *server_name, mc_server_state_e state, void *user_data);
/**
- * @brief Called when updating the playback information of the media controller server.
+ * @brief Called when the playback information of the media controller server is updated.
* @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_playback_updated_cb)(const char *server_name, mc_playback_h playback, void *user_data);
/**
- * @brief Called when updating the metadata of the media controller server.
+ * @brief Called when the metadata of the media controller server is updated.
* @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_metadata_updated_cb)(const char *server_name, mc_metadata_h metadata, void *user_data);
/**
- * @brief Called when updating the shuffle mode of the media controller server.
+ * @brief Called when the shuffle mode of the media controller server is updated.
* @since_tizen @if MOBILE 4.0 @elseif WEARABLE 5.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_shuffle_mode_updated_cb)(const char *server_name, mc_shuffle_mode_e mode, void *user_data);
/**
- * @brief Called when updating the repeat mode of the media controller server.
+ * @brief Called when the repeat mode of the media controller server is updated.
* @since_tizen @if MOBILE 4.0 @elseif WEARABLE 5.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_repeat_mode_updated_cb)(const char *server_name, mc_repeat_mode_e mode, void *user_data);
/**
- * @brief Called when updating the playback ability of the media controller server.
+ * @brief Called when the playback ability support of the media controller server is updated.
* @since_tizen 5.0
*
* @remarks The callback is called in the dbus event loop.\n
typedef void (*mc_playback_ability_updated_cb)(const char *server_name, mc_playback_ability_h ability, void *user_data);
/**
- * @brief Called when updating the shuffle ability of the media controller server.
+ * @deprecated Deprecated since 5.5. Use mc_ability_support_updated_cb() instead.
+ * @brief Called when the shuffle ability support of the media controller server is updated.
* @since_tizen 5.0
*
* @remarks The callback is called in the dbus event loop.\n
*
* @see mc_client_set_shuffle_ability_updated_cb()
*/
-typedef void (*mc_shuffle_ability_updated_cb)(const char *server_name, mc_ability_support_e support, void *user_data);
+typedef void (*mc_shuffle_ability_updated_cb)(const char *server_name, mc_ability_support_e support, void *user_data) TIZEN_DEPRECATED_API;
/**
- * @brief Called when updating the repeat ability of the media controller server.
+ * @deprecated Deprecated since 5.5. Use mc_ability_support_updated_cb() instead.
+ * @brief Called when the repeat ability of the media controller server is updated.
* @since_tizen 5.0
*
* @remarks The callback is called in the dbus event loop.\n
*
* @see mc_client_set_repeat_ability_updated_cb()
*/
+typedef void (*mc_repeat_ability_updated_cb)(const char *server_name, mc_ability_support_e support, void *user_data) TIZEN_DEPRECATED_API;
-typedef void (*mc_repeat_ability_updated_cb)(const char *server_name, mc_ability_support_e support, void *user_data);
-
+/**
+ * @brief Called when a media controller server's support for an ability is updated.
+ * @since_tizen 5.5
+ *
+ * @remarks The callback is called in the dbus event loop.\n
+ * The @a server_name should not be released by the application. \n
+ * The @a server_name can be used only in the callback. To use outside, make a copy.
+ *
+ * @param[in] server_name The app_id of the media controller server which sent the notification
+ * @param[in] ability The ability
+ * @param[in] support The support value of the ability of the updated media controller server
+ * @param[in] user_data The user data passed from the callback function
+ *
+ * @see mc_client_set_ability_support_updated_cb()
+ */
+typedef void (*mc_ability_support_updated_cb)(const char *server_name, mc_ability_e ability, mc_ability_support_e support, void *user_data);
/**
* @brief Called when requesting the list of created servers.
typedef bool (*mc_subscribed_server_cb)(const char *server_name, void *user_data);
/**
- * @brief Called when updating the playlist of the media controller server.
+ * @brief Called when the playlist of the media controller server is updated.
* @since_tizen @if MOBILE 4.0 @elseif WEARABLE 5.0 @endif
*
* @remarks The callback is called in the dbus event loop.\n
int mc_client_unset_playback_ability_updated_cb(mc_client_h client);
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_set_ability_support_updated_cb() instead.
* @brief Sets the callback for monitoring the shuffle ability of the media controller server.
* @details The media controller client which calls this function will receive notifications from all media controller servers.
* @since_tizen 5.0
* @see mc_client_create()
* @see mc_client_destroy()
*/
-int mc_client_set_shuffle_ability_updated_cb(mc_client_h client, mc_shuffle_ability_updated_cb callback, void *user_data);
+int mc_client_set_shuffle_ability_updated_cb(mc_client_h client, mc_shuffle_ability_updated_cb callback, void *user_data) TIZEN_DEPRECATED_API;
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_unset_ability_support_updated_cb() instead.
* @brief Unsets the callback for monitoring the shuffle ability of the media controller server.
* @since_tizen 5.0
*
* @see mc_client_create()
* @see mc_client_destroy()
*/
-int mc_client_unset_shuffle_ability_updated_cb(mc_client_h client);
+int mc_client_unset_shuffle_ability_updated_cb(mc_client_h client) TIZEN_DEPRECATED_API;
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_set_ability_support_updated_cb() instead.
* @brief Sets the callback for monitoring the repeat ability of the media controller server.
* @details The media controller client which calls this function will receive notifications from all media controller servers.
* @since_tizen 5.0
* @see mc_client_create()
* @see mc_client_destroy()
*/
-int mc_client_set_repeat_ability_updated_cb(mc_client_h client, mc_repeat_ability_updated_cb callback, void *user_data);
+int mc_client_set_repeat_ability_updated_cb(mc_client_h client, mc_repeat_ability_updated_cb callback, void *user_data) TIZEN_DEPRECATED_API;
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_unset_ability_support_updated_cb() instead.
* @brief Unsets the callback for monitoring the repeat ability of the media controller server.
* @since_tizen 5.0
*
* @see mc_client_create()
* @see mc_client_destroy()
*/
-int mc_client_unset_repeat_ability_updated_cb(mc_client_h client);
+int mc_client_unset_repeat_ability_updated_cb(mc_client_h client) TIZEN_DEPRECATED_API;
+
+/**
+ * @brief Sets the callback for monitoring the media controller server's support for an ability.
+ * @details The media controller client which calls this function will receive notifications from all media controller servers.
+ * This function can be used to monitor the following abilities:\n
+ * #MC_ABILITY_SHUFFLE, \n
+ * #MC_ABILITY_REPEAT, \n
+ * #MC_ABILITY_PLAYBACK_POSITION, \n
+ * #MC_ABILITY_PLAYLIST, \n
+ * #MC_ABILITY_CLIENT_CUSTOM, \n
+ * #MC_ABILITY_SEARCH, \n
+ * To monitor the media controller server's support for a playback ability, use mc_client_set_playback_ability_updated_cb().
+ * @since_tizen 5.5
+ *
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/mediacontroller.client
+ *
+ * @param[in] client The handle of the media controller client
+ * @param[in] callback The callback to be invoked when the ability is changed
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #MEDIA_CONTROLLER_ERROR_NONE Successful
+ * @retval #MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY Out of memory
+ *
+ * @pre Create a media controller client handle by calling mc_client_create().
+ * @see mc_client_create()
+ * @see mc_client_destroy()
+ * @see mc_client_set_playback_ability_updated_cb()
+ */
+int mc_client_set_ability_support_updated_cb(mc_client_h client, mc_ability_support_updated_cb callback, void *user_data);
+
+/**
+ * @brief Unsets the callback for monitoring the media controller server's support for an ability.
+ * @details The media controller client which calls this function will not receive notifications from all media controller servers.
+ * This function can be used for the following abilities:\n
+ * #MC_ABILITY_SHUFFLE, \n
+ * #MC_ABILITY_REPEAT, \n
+ * #MC_ABILITY_PLAYBACK_POSITION, \n
+ * #MC_ABILITY_PLAYLIST, \n
+ * #MC_ABILITY_CLIENT_CUSTOM, \n
+ * #MC_ABILITY_SEARCH, \n
+ * To stop monitoring the media controller server's support for a playback ability, use mc_client_unset_playback_ability_updated_cb().
+ * @since_tizen 5.5
+ *
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/mediacontroller.client
+ *
+ * @param[in] client The handle of the media controller client
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #MEDIA_CONTROLLER_ERROR_NONE Successful
+ * @retval #MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @pre Create a media controller client handle by calling mc_client_create().
+ * @see mc_client_create()
+ * @see mc_client_destroy()
+ * @see mc_client_unset_playback_ability_updated_cb()
+ * @see mc_ability_support_updated_cb()
+ */
+int mc_client_unset_ability_support_updated_cb(mc_client_h client);
/**
* @brief Sets the callback for receiving the result of the command from the media controller server.
int mc_client_get_server_playback_ability(mc_client_h client, const char *server_name, mc_playback_ability_h *ability);
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_get_ability_support() instead.
* @brief Gets the support value of the shuffle ability of the updated media controller server.
* @since_tizen 5.0
*
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.client
*
- * @remarks If the ability's support is not set, the result value is #MC_ABILITY_SUPPORTED_UNDECIDED.
+ * @remarks If the server's ability support is not set, the result value is #MC_ABILITY_SUPPORTED_UNDECIDED. \n
+ * It means you can send the corresponding command to the server, but it's not guaranteed that the server can handle it.
*
* @param[in] client The handle of the media controller client
* @param[in] server_name The app_id of the media controller server
* @see mc_client_get_latest_server_info()
* @see mc_client_foreach_server()
*/
-int mc_client_get_server_shuffle_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support);
+int mc_client_get_server_shuffle_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support) TIZEN_DEPRECATED_API;
/**
+ * @deprecated Deprecated since 5.5. Use mc_client_get_ability_support() instead.
* @brief Gets the support value of the repeat ability of the updated media controller server.
* @since_tizen 5.0
*
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.client
*
- * @remarks If the ability's support is not set, the result value is #MC_ABILITY_SUPPORTED_UNDECIDED.
+ * @remarks If the server's ability support is not set, the result value is #MC_ABILITY_SUPPORTED_UNDECIDED. \n
+ * It means you can send the corresponding command to the server, but it's not guaranteed that the server can handle it.
*
* @param[in] client The handle of the media controller client
* @param[in] server_name The app_id of the media controller server
* @see mc_client_destroy()
* @see mc_client_get_latest_server_info()
* @see mc_client_foreach_server()
+ * @see mc_client_get_server_playback_ability()
+ */
+int mc_client_get_server_repeat_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support) TIZEN_DEPRECATED_API;
+
+/**
+ * @brief Gets the ability support of the media controller server.
+ * @since_tizen 5.5
+ *
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/mediacontroller.client
+ *
+ * @remarks If the server's ability support is not set, the result value is #MC_ABILITY_SUPPORTED_UNDECIDED. \n
+ * It means you can send the corresponding command to the server, but it's not guaranteed that the server can handle it.
+ *
+ * @param[in] client The handle of the media controller client
+ * @param[in] server_name The app_id of the media controller server
+ * @param[in] ability The ability
+ * @param[out] support The support value of the ability
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #MEDIA_CONTROLLER_ERROR_NONE Successful
+ * @retval #MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY Out of memory
+ *
+ * @pre Create a media controller client handle by calling mc_client_create().
+ * @pre Get a server name handle by calling mc_client_create().
+ * @see mc_client_create()
+ * @see mc_client_destroy()
+ * @see mc_client_get_latest_server_info()
+ * @see mc_client_foreach_server()
*/
-int mc_client_get_server_repeat_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support);
+int mc_client_get_ability_support(mc_client_h client, const char *server_name, mc_ability_e ability, mc_ability_support_e *support);
/**
* @brief Retrieves all created servers.
int mc_db_get_shuffle_mode(sqlite3 *handle, const char *server_name, mc_shuffle_mode_e *mode);
int mc_db_get_repeat_mode(sqlite3 *handle, const char *server_name, mc_repeat_mode_e *mode);
int mc_db_get_icon_uri(sqlite3 *handle, const char *server_name, char **uri);
-int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported);
+int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, int ability, mc_ability_support_e *supported);
int mc_db_get_pb_action_ability(sqlite3 *handle, const char *server_name, mc_playback_ability_h *ability);
int _mc_db_get_playlist_count(sqlite3 *handle, const char *server_name);
int mc_db_get_foreach_playlist(sqlite3 *handle, const char *server_name, mc_playlist_cb callback, void *user_data);
#define MC_DBUS_SIGNAL_NAME_PLAYBACK_ABILITY "playback_ability"
#define MC_DBUS_SIGNAL_NAME_SHUFFLE_ABILITY "shuffle_ability"
#define MC_DBUS_SIGNAL_NAME_REPEAT_ABILITY "repeat_ability"
+#define MC_DBUS_SIGNAL_NAME_ABILITY_SUPPORT "ability_support"
+
+
#define MC_DBUS_SIGNAL_NAME_SEARCH_CMD "search_cmd"
#ifdef TIZEN_FEATURE_COMPATIBILITY
#define MC_DBUS_SIGNAL_NAME_PLAYBACK_STATE_CMD "pb_state_cmd"
MC_CLIENT_EVENT_PLAYBACK_ABILITY = MC_SUBSCRIPTION_TYPE_PLAYBACK_ABILITY,
MC_CLIENT_EVENT_SHUFFLE_ABILITY = MC_SUBSCRIPTION_TYPE_SHUFFLE_ABILITY,
MC_CLIENT_EVENT_REPEAT_ABILITY = MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY,
+ MC_CLIENT_EVENT_ABILITY_SUPPORT = MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT,
MC_CLIENT_EVENT_CMD_REPLY,
MC_CLIENT_EVENT_SERVER_CUSTOM, //receive event from server to client
#ifdef TIZEN_FEATURE_COMPATIBILITY
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_playback_ability(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives playback action from client.
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_playback_action_cmd_received_cb()
+ * @see mc_server_set_playback_ability()
*/
int mc_server_set_playback_action_cmd_received_cb(mc_server_h server, mc_server_playback_action_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_playback_ability(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_playback_action_cmd_received_cb()
+ * @see mc_server_set_playback_ability()
*/
int mc_server_unset_playback_action_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives position command from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_playback_position_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_playback_position_cmd_received_cb(mc_server_h server, mc_server_playback_position_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_playback_position_cmd_received_cb()
+ * @see mc_server_set_playback_ability()
*/
int mc_server_unset_playback_position_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives shuffle mode from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_shuffle_mode_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_shuffle_mode_cmd_received_cb(mc_server_h server, mc_server_shuffle_mode_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_shuffle_mode_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_unset_shuffle_mode_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives repeat mode from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_repeat_mode_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_repeat_mode_cmd_received_cb(mc_server_h server, mc_server_repeat_mode_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_repeat_mode_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_unset_repeat_mode_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives playlist command from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_playlist_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_playlist_cmd_received_cb(mc_server_h server, mc_server_playlist_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_playlist_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_unset_playlist_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives custom command from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_custom_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_custom_cmd_received_cb(mc_server_h server, mc_server_custom_cmd_received_cb callback, void *user_data);
* @brief Unsets the callback for receiving custom command from client.
* @since_tizen @if MOBILE 4.0 @elseif WEARABLE 5.0 @endif
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_custom_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_unset_custom_cmd_received_cb(mc_server_h server);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @param[in] callback The callback to be invoked when media controller server receives search command from client
* @param[in] user_data The user data to be passed to the callback function
* @pre Create a media controller server handle by calling mc_server_create().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_unset_search_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_set_search_cmd_received_cb(mc_server_h server, mc_server_search_cmd_received_cb callback, void *user_data);
* @privlevel public
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
+ * @remarks It is recommended to set the corresponding ability's support using mc_server_set_ability_support(). It will let the client know about the server's abilities and what commands the client can send.
+ *
* @param[in] server The handle to media controller server
* @return @c 0 on success,
* otherwise a negative error value
* @see mc_server_create()
* @see mc_server_destroy()
* @see mc_server_set_search_cmd_received_cb()
+ * @see mc_server_set_ability_support()
*/
int mc_server_unset_search_cmd_received_cb(mc_server_h server);
* @privilege %http://tizen.org/privilege/mediacontroller.server
*
* @remarks If @a support is #MC_ABILITY_SUPPORTED_UNDECIDED, this function will return #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER.
+ * To notify all clients about the changes of the playback's ability support, use mc_server_update_playback_ability().
*
* @param[in] server The handle to media controller server
* @param[in] action The playback action
* @post Update abilities of a media controller server by calling mc_server_update_playback_ability().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_update_playback_ability()
*/
int mc_server_set_playback_ability(mc_server_h server, mc_playback_action_e action, mc_ability_support_e support);
* @pre Set abilities of a media controller server by calling mc_server_set_playback_ability().
* @see mc_server_create()
* @see mc_server_destroy()
+ * @see mc_server_set_playback_ability()
*/
int mc_server_update_playback_ability(mc_server_h server);
/**
+ * @deprecated Deprecated since 5.5. Use mc_server_set_ability_support() instead.
* @brief Sets the shuffle ability's support of the media controller.
* @since_tizen 5.0
*
* @see mc_server_create()
* @see mc_server_destroy()
*/
-int mc_server_set_shuffle_ability(mc_server_h server, mc_ability_support_e support);
+int mc_server_set_shuffle_ability(mc_server_h server, mc_ability_support_e support) TIZEN_DEPRECATED_API;
/**
+ * @deprecated Deprecated since 5.5. Use mc_server_set_ability_support() instead.
* @brief Sets the repeat ability's support of the media controller.
* @since_tizen 5.0
*
* @see mc_server_create()
* @see mc_server_destroy()
*/
-int mc_server_set_repeat_ability(mc_server_h server, mc_ability_support_e support);
+int mc_server_set_repeat_ability(mc_server_h server, mc_ability_support_e support) TIZEN_DEPRECATED_API;
+
+/**
+ * @brief Sets the ability's support of the media controller.
+ * @details This function allows setting the support for the following abilities:
+ * MC_ABILITY_SHUFFLE, \n
+ * MC_ABILITY_REPEAT, \n
+ * MC_ABILITY_PLAYBACK_POSITION, \n
+ * MC_ABILITY_PLAYLIST, \n
+ * MC_ABILITY_CLIENT_CUSTOM, \n
+ * MC_ABILITY_SEARCH, \n
+ * To set the support for a playback ability, use mc_server_set_playback_ability() and mc_server_update_playback_ability().
+ * @since_tizen 5.5
+ *
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/mediacontroller.server
+ *
+ * @remarks If @a support is #MC_ABILITY_SUPPORTED_UNDECIDED, this function will return #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER.
+ *
+ * @param[in] server The handle to media controller server
+ * @param[in] ability The ability to set support
+ * @param[in] support The support value of the ability
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #MEDIA_CONTROLLER_ERROR_NONE Successful
+ * @retval #MEDIA_CONTROLLER_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_CONTROLLER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #MEDIA_CONTROLLER_ERROR_OUT_OF_MEMORY Out of memory
+ *
+ * @pre Create a media controller server handle by calling mc_server_create().
+ * @see mc_server_create()
+ * @see mc_server_destroy()
+ * @see mc_server_set_playback_ability()
+ * @see mc_server_update_playback_ability()
+ */
+int mc_server_set_ability_support(mc_server_h server, mc_ability_e ability, mc_ability_support_e support);
/**
* @brief Sets the icon URI of media controller server.
MC_SUBSCRIPTION_TYPE_REPEAT_MODE, /**< Repeat mode */
MC_SUBSCRIPTION_TYPE_PLAYLIST, /**< Playlist (Since @if MOBILE 4.0 @elseif WEARABLE 5.0 @endif) */
MC_SUBSCRIPTION_TYPE_PLAYBACK_ABILITY, /**< Playback ability (Since 5.0) */
- MC_SUBSCRIPTION_TYPE_SHUFFLE_ABILITY, /**< Shuffle ability (Since 5.0) */
- MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY, /**< Repeat ability (Since 5.0) */
+ MC_SUBSCRIPTION_TYPE_SHUFFLE_ABILITY, /**< Shuffle ability (Since 5.0) (Deprecated since 5.5. Use #MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT instead)*/
+ MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY, /**< Repeat ability (Since 5.0) (Deprecated since 5.5. Use #MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT instead)*/
+ MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT = 9, /**< Ability support (Since 5.5) */
} mc_subscription_type_e;
/**
} mc_ability_support_e;
/**
+ * @brief Enumeration for the ability.
+ * @since_tizen 5.5
+ */
+typedef enum {
+ MC_ABILITY_SHUFFLE, /**< Shuffle */
+ MC_ABILITY_REPEAT, /**< Repeat */
+ MC_ABILITY_PLAYBACK_POSITION, /**< Playback Position */
+ MC_ABILITY_PLAYLIST, /**< Playlist */
+ MC_ABILITY_CLIENT_CUSTOM, /**< Custom command from a client */
+ MC_ABILITY_SEARCH, /**< Search */
+} mc_ability_e;
+
+/**
* @brief Enumeration for the search category.
* @since_tizen 5.0
*/
Name: capi-media-controller
Summary: A media controller library in Tizen Native API
-Version: 0.2.1
+Version: 0.2.3
Release: 1
Group: Multimedia/API
License: Apache-2.0
static void __client_cmd_reply_received_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
static void __client_custom_event_received_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
static void __client_playback_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
-static void __client_repeat_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
-static void __client_shuffle_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
+static void __client_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
+static void __client_ability_support_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
+
#ifdef TIZEN_FEATURE_COMPATIBILITY
static void __client_reply_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data);
{MC_DBUS_SIGNAL_NAME_PLAYBACK_REPEAT, __client_repeat_cb},
{MC_DBUS_SIGNAL_NAME_PLAYLIST, __client_playlist_cb},
{MC_DBUS_SIGNAL_NAME_PLAYBACK_ABILITY, __client_playback_ability_cb},
- {MC_DBUS_SIGNAL_NAME_SHUFFLE_ABILITY, __client_shuffle_ability_cb},
- {MC_DBUS_SIGNAL_NAME_REPEAT_ABILITY, __client_repeat_ability_cb},
+ {MC_DBUS_SIGNAL_NAME_SHUFFLE_ABILITY, __client_ability_cb},
+ {MC_DBUS_SIGNAL_NAME_REPEAT_ABILITY, __client_ability_cb},
+ {MC_DBUS_SIGNAL_NAME_ABILITY_SUPPORT, __client_ability_support_cb},
{MC_DBUS_SIGNAL_NAME_CMD_REPLY, __client_cmd_reply_received_cb},
{MC_DBUS_SIGNAL_NAME_CUSTOM_EVENT, __client_custom_event_received_cb},
#ifdef TIZEN_FEATURE_COMPATIBILITY
mc_playback_ability_destroy(ability);
}
-static void __client_shuffle_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+static void __client_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
{
gchar **params = NULL;
media_controller_receiver_s *reciever = (media_controller_receiver_s *)user_data;
mc_retm_if(reciever == NULL, "reciever is NULL");
mc_shuffle_ability_updated_cb callback = (mc_shuffle_ability_updated_cb)reciever->callback;
- mc_retm_if(callback == NULL, "shuffle_ability_cb is NULL");
+ mc_retm_if(callback == NULL, "callback is NULL");
mc_retm_if(message == NULL, "message is NULL");
- mc_secure_debug("__client_shuffle_ability_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+ mc_secure_debug("__client_ability_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
- mc_retm_if(params == NULL, "invalid shuffle ability data");
+ mc_retm_if(params == NULL, "invalid ability data");
callback(params[0], (mc_ability_support_e)atoi(params[1]), reciever->user_data);
g_strfreev(params);
}
-static void __client_repeat_ability_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
+static void __client_ability_support_cb(const char *interface_name, const char *signal_name, const char *message, const char *request_id, void *user_data)
{
gchar **params = NULL;
media_controller_receiver_s *reciever = (media_controller_receiver_s *)user_data;
mc_retm_if(reciever == NULL, "reciever is NULL");
- mc_repeat_ability_updated_cb callback = (mc_repeat_ability_updated_cb)reciever->callback;
- mc_retm_if(callback == NULL, "repeat_ability_cb is NULL");
+ mc_ability_support_updated_cb callback = (mc_ability_support_updated_cb)reciever->callback;
+ mc_retm_if(callback == NULL, "callback is NULL");
mc_retm_if(message == NULL, "message is NULL");
- mc_secure_debug("__client_repeat_ability_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
+ mc_secure_debug("__client_ability_cb(%s, %s, %s, %s, %p)", interface_name, signal_name, message, request_id, user_data);
params = g_strsplit(message, MC_STRING_DELIMITER, 0);
- mc_retm_if(params == NULL, "invalid repeat ability data");
+ mc_retm_if(params == NULL, "invalid ability data");
- callback(params[0], (mc_ability_support_e)atoi(params[1]), reciever->user_data);
+ callback(params[0], (mc_ability_e)atoi(params[1]), (mc_ability_support_e)atoi(params[2]), reciever->user_data);
g_strfreev(params);
}
int mc_client_set_shuffle_ability_updated_cb(mc_client_h client, mc_shuffle_ability_updated_cb callback, void *user_data)
{
+ mc_warning("DEPRECATION WARNING: mc_client_set_shuffle_ability_updated_cb() is deprecated and will be removed from next release. Use mc_client_set_ability_support_updated_cb() instead.");
+
return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE_ABILITY, callback, user_data);
}
int mc_client_unset_shuffle_ability_updated_cb(mc_client_h client)
{
+ mc_warning("DEPRECATION WARNING: mc_client_unset_shuffle_ability_updated_cb() is deprecated and will be removed from next release. Use mc_client_unset_ability_support_updated_cb() instead.");
+
return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_SHUFFLE_ABILITY);
}
int mc_client_set_repeat_ability_updated_cb(mc_client_h client, mc_repeat_ability_updated_cb callback, void *user_data)
{
+ mc_warning("DEPRECATION WARNING: mc_client_set_repeat_ability_updated_cb() is deprecated and will be removed from next release. Use mc_client_set_ability_support_updated_cb() instead.");
+
return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_REPEAT_ABILITY, callback, user_data);
}
int mc_client_unset_repeat_ability_updated_cb(mc_client_h client)
{
+ mc_warning("DEPRECATION WARNING: mc_client_unset_repeat_ability_updated_cb() is deprecated and will be removed from next release. Use mc_client_unset_ability_support_updated_cb() instead.");
+
return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_REPEAT_ABILITY);
}
+int mc_client_set_ability_support_updated_cb(mc_client_h client, mc_ability_support_updated_cb callback, void *user_data)
+{
+ return __mc_client_set_updated_cb(client, MC_CLIENT_EVENT_ABILITY_SUPPORT, callback, user_data);
+}
+
+int mc_client_unset_ability_support_updated_cb(mc_client_h client)
+{
+ return __mc_client_unset_updated_cb(client, MC_CLIENT_EVENT_ABILITY_SUPPORT);
+}
+
int mc_client_subscribe(mc_client_h client, const mc_subscription_type_e subscription_type, const char *server_name)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
ret = mc_db_get_ability_supported(mc_client->db_handle, server_name, ability, &supported);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to get ability");
- mc_retvm_if(supported == MC_ABILITY_SUPPORTED_NO, MEDIA_CONTROLLER_ERROR_ABILITY_LIMITED_BY_SERVER_APP, "Not Supported ability");
+ mc_retvm_if(supported == MC_ABILITY_SUPPORTED_NO, MEDIA_CONTROLLER_ERROR_ABILITY_LIMITED_BY_SERVER_APP, "Not Supported ability [%d]", ability);
return MEDIA_CONTROLLER_ERROR_NONE;
}
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_PLAYBACK_POSITION);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
+
message = g_strdup_printf("%s%s%llu", mc_client->client_name, MC_STRING_DELIMITER, position);
mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
mc_retvm_if(!mc_client, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid handle");
mc_retvm_if(((shuffle_mode < MC_SHUFFLE_MODE_ON) || (shuffle_mode > MC_SHUFFLE_MODE_OFF)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid shuffle mode [%d]", shuffle_mode);
- ret = __mc_client_verify_ability(client, server_name, MC_SERVER_EVENT_SHUFFLE);
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SHUFFLE);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
message = g_strdup_printf("%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, shuffle_mode);
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(((repeat_mode < MC_REPEAT_MODE_ON) || (repeat_mode > MC_REPEAT_MODE_ONE_MEDIA)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid repeat mode [%d]", repeat_mode);
- ret = __mc_client_verify_ability(client, server_name, MC_SERVER_EVENT_REPEAT);
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_REPEAT);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
message = g_strdup_printf("%s%s%d", mc_client->client_name, MC_STRING_DELIMITER, repeat_mode);
mc_retvm_if(!MC_STRING_VALID(index), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid index");
mc_retvm_if(!_mc_util_is_valid_playback_action(action), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid action");
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_PLAYLIST);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
+
message = g_strdup_printf("%s%s%s%s%s%s%d%s%llu", mc_client->client_name, MC_STRING_DELIMITER, playlist_name, MC_STRING_DELIMITER, index, MC_STRING_DELIMITER, action, MC_STRING_DELIMITER, position);
mc_retvm_if(message == NULL, MEDIA_CONTROLLER_ERROR_INVALID_OPERATION, "fail making message [%d]", ret);
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_CLIENT_CUSTOM);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
+
ret = mc_util_bundle_to_string(data, &bundle_str);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error when make string from bundle");
mc_retvm_if(!MC_STRING_VALID(server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
mc_retvm_if(!_mc_db_is_activated_server(mc_client->db_handle, server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ ret = __mc_client_verify_ability(client, server_name, MC_ABILITY_SEARCH);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to verify ability");
+
ret = __mc_client_get_bundle_from_search(search, &bundle_data);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error __mc_client_get_bundle_from_search [%d]", ret);
return ret;
}
-int mc_client_get_server_shuffle_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support)
+static int __mc_client_get_server_ability(mc_client_h client, const char *server_name, mc_ability_e ability, mc_ability_support_e *support)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_client_s *mc_client = (media_controller_client_s *)client;
- mc_retvm_if(client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "client is NULL");
- mc_retvm_if(support == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "supported is NULL");
+ mc_retvm_if(!client, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid client");
mc_retvm_if(!mc_db_is_exist_server(mc_client->db_handle, server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ mc_retvm_if(((ability < MC_ABILITY_SHUFFLE) || (ability > MC_ABILITY_SEARCH)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid ability [%d]", ability);
- ret = mc_db_get_ability_supported(mc_client->db_handle, server_name, MC_SERVER_EVENT_SHUFFLE, support);
+ ret = mc_db_get_ability_supported(mc_client->db_handle, server_name, ability, support);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_db_get_ability_supported [%d]", ret);
return ret;
}
-int mc_client_get_server_repeat_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support)
+int mc_client_get_server_shuffle_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support)
{
- int ret = MEDIA_CONTROLLER_ERROR_NONE;
- media_controller_client_s *mc_client = (media_controller_client_s *)client;
+ mc_warning("DEPRECATION WARNING: mc_client_get_server_shuffle_ability_support() is removed from 5.5. Use mc_client_get_ability_support() instead.");
- mc_retvm_if(client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "client is NULL");
- mc_retvm_if(support == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "supported is NULL");
- mc_retvm_if(!mc_db_is_exist_server(mc_client->db_handle, server_name), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server_name");
+ return __mc_client_get_server_ability(client, server_name, MC_ABILITY_SHUFFLE, support);
+}
- ret = mc_db_get_ability_supported(mc_client->db_handle, server_name, MC_SERVER_EVENT_REPEAT, support);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "Error mc_db_get_ability_supported [%d]", ret);
+int mc_client_get_server_repeat_ability_support(mc_client_h client, const char *server_name, mc_ability_support_e *support)
+{
+ mc_warning("DEPRECATION WARNING: mc_client_get_server_repeat_ability_support() is removed from 5.5. Use mc_client_get_ability_support() instead.");
- return ret;
+ return __mc_client_get_server_ability(client, server_name, MC_ABILITY_REPEAT, support);
+}
+
+int mc_client_get_ability_support(mc_client_h client, const char *server_name, mc_ability_e ability, mc_ability_support_e *support)
+{
+ return __mc_client_get_server_ability(client, server_name, ability, support);
}
int mc_client_destroy(mc_client_h client)
mc_retvm_if(mc_client == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
/*Unregister all filter listener*/
- for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY; idx++) {
+ for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT; idx++) {
ret = __mc_client_unregister_filter_listener(mc_client, &mc_client->updated_cb[idx].filter_list, NULL, cb_event[idx].signal_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
mc_error("Error __mc_client_unregister_filter_listener [%d]", ret);
}
-int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, mc_server_receive_event_e ability, mc_ability_support_e *supported)
+int mc_db_get_ability_supported(sqlite3 *handle, const char *server_name, int ability, mc_ability_support_e *supported)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
unsigned long long _decided = 0;
unsigned long long _supported = 0;
+ mc_retvm_if(!supported, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid supported");
+
ret = __mc_db_get_ability(handle, server_name, &_decided, &_supported);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "__mc_db_get_ability failed");
mc_search_destroy((mc_search_h)mc_search);
}
-static int __mc_server_send_message(media_controller_server_s *mc_server, const char *interface_name, const char *signal_name, const int param1, const unsigned long long param2, const char* param3)
+static int __mc_server_send_message(media_controller_server_s *mc_server, const char *interface_name, const char *signal_name, const int param1, const int param2, const char* param3)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
char *message = NULL;
message = g_strdup_printf("%s", mc_server->server_name);
else if (!g_strcmp0(MC_DBUS_SIGNAL_NAME_PLAYLIST, signal_name))
message = g_strdup_printf("%s%s%d%s%s", mc_server->server_name, MC_STRING_DELIMITER, param1, MC_STRING_DELIMITER, param3);
+ else if (!g_strcmp0(MC_DBUS_SIGNAL_NAME_ABILITY_SUPPORT, signal_name))
+ message = g_strdup_printf("%s%s%d%s%d", mc_server->server_name, MC_STRING_DELIMITER, param1, MC_STRING_DELIMITER, param2);
else
message = g_strdup_printf("%s%s%d", mc_server->server_name, MC_STRING_DELIMITER, param1);
return ret;
}
-static int __mc_server_set_ability(mc_server_h server, mc_server_receive_event_e event, mc_ability_support_e support)
+static int __mc_server_set_ability(mc_server_h server, mc_ability_e ability, mc_ability_support_e support)
{
int ret = MEDIA_CONTROLLER_ERROR_NONE;
media_controller_server_s *mc_server = (media_controller_server_s *)server;
- char *ability_signal = NULL;
- switch (event) {
- case MC_SERVER_EVENT_SHUFFLE:
- ability_signal = (char *)MC_DBUS_SIGNAL_NAME_SHUFFLE_ABILITY;
- break;
+ mc_retvm_if(((ability < MC_ABILITY_SHUFFLE) || (ability > MC_ABILITY_SEARCH)) , MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid ability [%d]", ability);
- case MC_SERVER_EVENT_REPEAT:
- ability_signal = (char *)MC_DBUS_SIGNAL_NAME_REPEAT_ABILITY;
- break;
-
- default:
- mc_error("Not supported event [%d]", event);
- return MEDIA_CONTROLLER_ERROR_INVALID_OPERATION;
- }
-
- ret = __mc_server_update_ability(server, event, support, TRUE);
+ ret = __mc_server_update_ability(server, ability, support, TRUE);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to __mc_server_update_ability");
- ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, ability_signal, support, 0, NULL);
+ ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_ABILITY_SUPPORT, ability, support, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to __mc_server_send_message");
+ /*To Support Deprecated ability for shuffle and repeat*/
+ if (ability == MC_ABILITY_SHUFFLE) {
+ ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_SHUFFLE_ABILITY, support, 0, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to __mc_server_send_message");
+ } else if (ability == MC_ABILITY_REPEAT) {
+ ret = __mc_server_send_message(mc_server, MC_DBUS_UPDATE_INTERFACE, MC_DBUS_SIGNAL_NAME_REPEAT_ABILITY, support, 0, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, ret, "fail to __mc_server_send_message");
+ }
+
return ret;
}
{
media_controller_server_s *mc_server = (media_controller_server_s *)server;
- mc_retvm_if(mc_server == NULL, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- mc_retvm_if(((support != MC_ABILITY_SUPPORTED_YES) && (support != MC_ABILITY_SUPPORTED_NO)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "support is invalid [%d]", support);
+ mc_retvm_if(!mc_server, MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid server");
+ mc_retvm_if(((support != MC_ABILITY_SUPPORTED_YES) && (support != MC_ABILITY_SUPPORTED_NO)), MEDIA_CONTROLLER_ERROR_INVALID_PARAMETER, "Invalid suupport [%d]", support);
/* Change decided bit to 1(set) */
_mc_util_set_bit(support_item, TRUE, &mc_server->basic_ability.decided);
int mc_server_set_shuffle_ability(mc_server_h server, mc_ability_support_e support)
{
- return __mc_server_set_ability(server, MC_SERVER_EVENT_SHUFFLE, support);
+ mc_warning("DEPRECATION WARNING: mc_server_set_shuffle_ability() is removed from 5.5. Use mc_server_set_ability_support() instead.");
+ return __mc_server_set_ability(server, MC_ABILITY_SHUFFLE, support);
}
int mc_server_set_repeat_ability(mc_server_h server, mc_ability_support_e support)
{
- return __mc_server_set_ability(server, MC_SERVER_EVENT_REPEAT, support);
+ mc_warning("DEPRECATION WARNING: mc_server_set_repeat_ability() is removed from 5.5. Use mc_server_set_ability_support() instead.");
+ return __mc_server_set_ability(server, MC_ABILITY_REPEAT, support);
+}
+
+int mc_server_set_ability_support(mc_server_h server, mc_ability_e ability, mc_ability_support_e support)
+{
+ return __mc_server_set_ability(server, ability, support);
}
int mc_server_create(mc_server_h *server)
gboolean _mc_util_is_valid_subscription_type(const mc_subscription_type_e subscription_type)
{
- if ((subscription_type < MC_SUBSCRIPTION_TYPE_SERVER_STATE) || (subscription_type > MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY)) {
+ if ((subscription_type < MC_SUBSCRIPTION_TYPE_SERVER_STATE) || (subscription_type > MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT)) {
mc_error("Invalid subscription_type [%d]", subscription_type);
return FALSE;
}
}
}
-bool _mc_activated_server_cb(const char *server_name, void *user_data)
+static bool __mc_activated_server_cb(const char *server_name, void *user_data)
{
media_controller_client_s *_client = (media_controller_client_s *)g_mc_client;
mc_debug("[Client:%s] Activated server_name: %s", _client->client_name, server_name);
- mc_ability_support_e supported = MC_ABILITY_SUPPORTED_UNDECIDED;
-
- mc_client_get_server_shuffle_ability_support(g_mc_client, server_name, &supported);
- g_print("== shuffle ability %d \n", supported);
-
- mc_client_get_server_repeat_ability_support(g_mc_client, server_name, &supported);
- g_print("== repeat ability %d \n", supported);
-
return TRUE;
}
}
}
-void _mc_shuffle_ability_updated_cb(const char *server_name, mc_ability_support_e support, void *user_data)
+static void __mc_shuffle_ability_updated_cb(const char *server_name, mc_ability_support_e support, void *user_data)
{
media_controller_client_s *_client = (media_controller_client_s *)g_mc_client;
mc_debug("[Client:%s] shuffle_ability(%d) updated from server[%s]", _client->client_name, support, server_name);
}
-void _mc_repeat_ability_updated_cb(const char *server_name, mc_ability_support_e support, void *user_data)
+static void __mc_repeat_ability_updated_cb(const char *server_name, mc_ability_support_e support, void *user_data)
{
media_controller_client_s *_client = (media_controller_client_s *)g_mc_client;
mc_debug("[Client:%s] repeat_ability(%d) updated from server[%s]", _client->client_name, support, server_name);
}
+static void __mc_ability_updated_cb(const char *server_name, mc_ability_e ability, mc_ability_support_e support, void *user_data)
+{
+ media_controller_client_s *_client = (media_controller_client_s *)g_mc_client;
+
+ mc_debug("[Client:%s] ability[%d][%d] updated from server[%s]", _client->client_name, ability, support, server_name);
+}
+
static gboolean _create()
{
g_print("== create \n");
g_print("== create \n");
int ret = MEDIA_CONTROLLER_ERROR_NONE;
- ret = mc_client_foreach_server(g_mc_client, _mc_activated_server_cb, NULL);
+ ret = mc_client_foreach_server(g_mc_client, __mc_activated_server_cb, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
g_print("Fail to foreach media contoller client");
return FALSE;
ret = mc_client_set_playback_ability_updated_cb(g_mc_client, _mc_playback_ability_updated_cb, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_playback_ability_updated_cb [%d]", ret);
- ret = mc_client_set_shuffle_ability_updated_cb(g_mc_client, _mc_shuffle_ability_updated_cb, NULL);
+ ret = mc_client_set_shuffle_ability_updated_cb(g_mc_client, __mc_shuffle_ability_updated_cb, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_shuffle_ability_updated_cb [%d]", ret);
- ret = mc_client_set_repeat_ability_updated_cb(g_mc_client, _mc_repeat_ability_updated_cb, NULL);
+ ret = mc_client_set_repeat_ability_updated_cb(g_mc_client, __mc_repeat_ability_updated_cb, NULL);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_repeat_ability_updated_cb [%d]", ret);
+ ret = mc_client_set_ability_support_updated_cb(g_mc_client, __mc_ability_updated_cb, NULL);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_set_ability_support_updated_cb [%d]", ret);
+
mc_debug_fleave();
return ret;
ret = mc_client_unset_playback_ability_updated_cb(g_mc_client);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_playback_ability_updated_cb [%d]", ret);
- ret = mc_client_unset_shuffle_ability_updated_cb(g_mc_client);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_shuffle_ability_updated_cb [%d]", ret);
-
- ret = mc_client_unset_repeat_ability_updated_cb(g_mc_client);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_unset_repeat_ability_updated_cb [%d]", ret);
+ ret = mc_client_unset_ability_support_updated_cb(g_mc_client);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to unset position ability updated cb [%d]", ret);
mc_debug_fleave();
ret = mc_playback_ability_destroy(ability);
mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_playback_ability_destroy [%d]", ret);
- ret = mc_client_get_server_shuffle_ability_support(g_mc_client, g_server_name, &support);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_shuffle_ability_support [%d]", ret);
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_SHUFFLE, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get shuffle ability [%d]", ret);
g_print("shuffle_ability: %d \n", support);
- ret = mc_client_get_server_repeat_ability_support(g_mc_client, g_server_name, &support);
- mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to mc_client_get_server_repeat_ability_support [%d]", ret);
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_REPEAT, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get repeat ability [%d]", ret);
g_print("repeat_ability: %d \n", support);
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_PLAYBACK_POSITION, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get playback position ability [%d]", ret);
+
+ g_print("position_ability: %d \n", support);
+
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_PLAYLIST, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get playlist ability [%d]", ret);
+
+ g_print("playlist_ability: %d \n", support);
+
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_CLIENT_CUSTOM, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get client custom ability [%d]", ret);
+
+ g_print("custom_ability: %d \n", support);
+
+ ret = mc_client_get_ability_support(g_mc_client, g_server_name, MC_ABILITY_SEARCH, &support);
+ mc_retvm_if(ret != MEDIA_CONTROLLER_ERROR_NONE, FALSE, "Fail to get search ability [%d]", ret);
+
+ g_print("search_ability: %d \n", support);
+
break;
default:
g_print("== unknown type!\n");
g_print("== send command to latest server \n");
int ret = MEDIA_CONTROLLER_ERROR_NONE;
bundle *bundle_data = NULL;
+ unsigned int i = 0;
if (g_playback_action == MC_PLAYBACK_ACTION_PLAY)
- g_playback_action = MC_PLAYBACK_ACTION_STOP;
+ g_playback_action = MC_PLAYBACK_ACTION_PAUSE;
else
g_playback_action = MC_PLAYBACK_ACTION_PLAY;
ret = mc_client_send_playback_action_cmd(g_mc_client, g_server_name, g_playback_action, &g_request_id[TEST_REQ_PB_ACT_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send playback action command [%d]", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send playback action command [%d]\n", ret);
+ else
+ g_print("Success in sending playback action command [%d]\n", ret);
g_playback_position += 1000;
ret = mc_client_send_playback_position_cmd(g_mc_client, g_server_name, g_playback_position, &g_request_id[TEST_REQ_PB_POS_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send playback position command [%d]", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send playback position command [%d]\n", ret);
+ else
+ g_print("Success in sending playback position command [%d]\n", ret);
+
if (g_shuffle_mode == MC_SHUFFLE_MODE_OFF)
g_shuffle_mode = MC_SHUFFLE_MODE_ON;
else
g_shuffle_mode = MC_SHUFFLE_MODE_OFF;
ret = mc_client_send_shuffle_mode_cmd(g_mc_client, g_server_name, g_shuffle_mode, &g_request_id[TEST_REQ_SHUFFLE_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send shuffle mode command [%d]", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send shuffle mode command [%d]\n", ret);
+ else
+ g_print("Success in sending shuffle mode command [%d]\n", ret);
if (g_repeat_mode == MC_REPEAT_MODE_OFF)
g_repeat_mode = MC_REPEAT_MODE_ON;
g_repeat_mode = MC_REPEAT_MODE_OFF;
ret = mc_client_send_repeat_mode_cmd(g_mc_client, g_server_name, g_repeat_mode, &g_request_id[TEST_REQ_REPEAT_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send shuffle mode command [%d]", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send repeat mode command [%d]\n", ret);
+ else
+ g_print("Success in sending repeat mode command [%d]\n", ret);
if (g_playlist_name != NULL) {
ret = mc_client_send_playlist_cmd(g_mc_client, g_server_name, g_playlist_name, "1", MC_PLAYBACK_ACTION_PLAY, 300, &g_request_id[TEST_REQ_PLAYLIST_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to send play playlist item [%d]", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send playlist command [%d]\n", ret);
+ else
+ g_print("Success in sending playlist command [%d]\n", ret);
}
struct timespec reqtime;
bundle_add_str(bundle_data, "key4", "val4_2");
ret = mc_client_send_custom_cmd(g_mc_client, g_server_name, "Custom Command2", bundle_data, &g_request_id[TEST_REQ_CUSTOM_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- bundle_free(bundle_data);
- mc_error("Fail to send custom command %d", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send custom command [%d]\n", ret);
+ else
+ g_print("Success in sending custom command [%d]\n", ret);
+
bundle_free(bundle_data);
/*Send Search Command*/
ret = mc_search_create(&mc_search);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Fail mc_search_create [%d]", ret);
+ mc_error("Fail mc_search_create [%d]\n", ret);
bundle_free(bundle_data);
return FALSE;
}
ret = mc_search_set_condition(mc_search, MC_CONTENT_TYPE_VIDEO, MC_SEARCH_GENRE, "search genre 4", bundle_data);
ret = mc_client_send_search_cmd(g_mc_client, g_server_name, mc_search, &g_request_id[TEST_REQ_SEARCH_CMD]);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- bundle_free(bundle_data);
- mc_search_destroy(mc_search);
- mc_error("Fail to send search command %d", ret);
- return FALSE;
- }
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE)
+ g_print("Fail to send search command [%d]\n", ret);
+ else
+ g_print("Success in sending search command [%d]\n", ret);
bundle_free(bundle_data);
ret = mc_search_destroy(mc_search);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- mc_error("Fail to mc_search_destroy [%d]", ret);
+ mc_error("Fail to mc_search_destroy [%d]\n", ret);
return FALSE;
}
- unsigned int i = 0;
for (i = 0; i < TEST_REQ_MAX; i++)
mc_error("[No-Errror][%02u][Id:%s]", i, g_request_id[i]);
mc_debug_fenter();
- for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY; idx++) {
+ for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT; idx++) {
ret = mc_client_subscribe(g_mc_client, idx, g_server_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
g_print("Fail to mc_client_subscribe");
mc_debug_fenter();
- for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_REPEAT_ABILITY; idx++) {
+ for (idx = 0; idx <= MC_SUBSCRIPTION_TYPE_ABILITY_SUPPORT; idx++) {
ret = mc_client_unsubscribe(g_mc_client, idx, g_server_name);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
g_print("Fail to mc_client_unsubscribe");
return MEDIA_CONTROLLER_ERROR_NONE;
/*Get Foreach server*/
- ret = mc_client_foreach_server(g_mc_client, _mc_activated_server_cb, NULL);
+ ret = mc_client_foreach_server(g_mc_client, __mc_activated_server_cb, NULL);
if (ret != MEDIA_CONTROLLER_ERROR_NONE)
g_print("Fail to mc_client_foreach_server\n");
CURRENT_STATE_MAIN_MENU,
CURRENT_STATE_INFORMATION_SET_MENU,
CURRENT_STATE_INFORMATION_UPDATE_MENU,
+ CURRENT_STATE_ABILITY_UPDATE_MENU,
CURRENT_STATE_SEND_EVENT_MENU,
};
return FALSE;
}
break;
- case 7:
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PLAY, MC_ABILITY_SUPPORTED_YES);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PAUSE, MC_ABILITY_SUPPORTED_NO);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_STOP, MC_ABILITY_SUPPORTED_YES);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_NEXT, MC_ABILITY_SUPPORTED_NO);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PREV, MC_ABILITY_SUPPORTED_YES);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_FAST_FORWARD, MC_ABILITY_SUPPORTED_NO);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_REWIND, MC_ABILITY_SUPPORTED_YES);
- ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_TOGGLE_PLAY_PAUSE, MC_ABILITY_SUPPORTED_NO);
- ret = mc_server_update_playback_ability(g_mc_server);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to mc_server_update_playback_ability. err=%d", ret);
- return FALSE;
- }
- break;
- case 8:
- if (g_ability_support != MC_ABILITY_SUPPORTED_YES)
- g_ability_support = MC_ABILITY_SUPPORTED_YES;
- else
- g_ability_support = MC_ABILITY_SUPPORTED_NO;
-
- ret = mc_server_set_shuffle_ability(g_mc_server, g_ability_support);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to mc_server_set_shuffle_ability. err=%d", ret);
- return FALSE;
- }
- break;
- case 9:
- if (g_ability_support != MC_ABILITY_SUPPORTED_YES)
- g_ability_support = MC_ABILITY_SUPPORTED_YES;
- else
- g_ability_support = MC_ABILITY_SUPPORTED_NO;
-
- ret = mc_server_set_repeat_ability(g_mc_server, g_ability_support);
- if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
- g_print("Fail to mc_server_set_repeat_ability. err=%d", ret);
- return FALSE;
- }
- break;
default:
g_print(" == unknown type!\n");
return TRUE;
g_print("4. update server repeate mode \n");
g_print("5. update playlist \n");
g_print("6. update icon uri \n");
- g_print("7. update playback ability \n");
- g_print("8. update shuffle ability \n");
- g_print("9. update repeat ability \n");
g_print("0. back \n");
g_print("----------------------------------------------------\n");
g_print("====================================================\n");
}
+static void __display_ability_menu(void)
+{
+ g_print("\n");
+ g_print("====================================================\n");
+ g_print(" media controller test(server): Update ability menu\n");
+ g_print("----------------------------------------------------\n");
+ g_print("1. update playback ability \n");
+ g_print("2. update shuffle ability \n");
+ g_print("3. update repeat ability \n");
+ g_print("4. update position support\n");
+ g_print("5. update playlist ability \n");
+ g_print("6. update custom ability \n");
+ g_print("7. update search ability \n");
+ g_print("0. back \n");
+ g_print("----------------------------------------------------\n");
+ g_print("====================================================\n");
+
+}
+
static void __display_main_menu(void)
{
g_print("\n");
g_print("2. set default command callback \n");
g_print("3. set information to client \n");
g_print("4. update information to client \n");
+ g_print("5. update ability to client \n");
g_print("6. send event to client \n");
g_print("9. destroy media controller server \n");
g_print("0. quit \n");
__display_set_info_menu();
else if (g_menu_state == CURRENT_STATE_INFORMATION_UPDATE_MENU)
__display_update_info_menu();
+ else if (g_menu_state == CURRENT_STATE_ABILITY_UPDATE_MENU)
+ __display_ability_menu();
else if (g_menu_state == CURRENT_STATE_SEND_EVENT_MENU)
__display_send_menu();
else
__update_info(5);
else if (!strncmp(cmd, "6", len))
__update_info(6);
+ else if (!strncmp(cmd, "0", len))
+ __reset_current_menu_state();
+ else
+ g_print("wrong command\n");
+ } else {
+ g_print("wrong command\n");
+ }
+}
+
+static gboolean __update_ability(int type)
+{
+ g_print(" == update ability \n");
+ int ret = MEDIA_CONTROLLER_ERROR_NONE;
+
+ if (g_ability_support != MC_ABILITY_SUPPORTED_YES)
+ g_ability_support = MC_ABILITY_SUPPORTED_YES;
+ else
+ g_ability_support = MC_ABILITY_SUPPORTED_NO;
+
+ switch (type) {
+ case 1:
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PLAY, MC_ABILITY_SUPPORTED_YES);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PAUSE, MC_ABILITY_SUPPORTED_NO);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_STOP, MC_ABILITY_SUPPORTED_YES);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_NEXT, MC_ABILITY_SUPPORTED_NO);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_PREV, MC_ABILITY_SUPPORTED_YES);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_FAST_FORWARD, MC_ABILITY_SUPPORTED_NO);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_REWIND, MC_ABILITY_SUPPORTED_YES);
+ ret = mc_server_set_playback_ability(g_mc_server, MC_PLAYBACK_ACTION_TOGGLE_PLAY_PAUSE, MC_ABILITY_SUPPORTED_NO);
+ ret = mc_server_update_playback_ability(g_mc_server);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to mc_server_update_playback_ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+ case 2:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_SHUFFLE, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set shuffle ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+
+ case 3:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_REPEAT, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set repeat ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+
+ case 4:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_PLAYBACK_POSITION, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set position ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+
+ case 5:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_PLAYLIST, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set playlist ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+
+ case 6:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_CLIENT_CUSTOM, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set custom ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+
+ case 7:
+ ret = mc_server_set_ability_support(g_mc_server, MC_ABILITY_SEARCH, g_ability_support);
+ if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+ g_print("Fail to set search ability. err=%d", ret);
+ return FALSE;
+ }
+ break;
+ default:
+ g_print(" == unknown type!\n");
+ return TRUE;
+ }
+
+ g_print(" == success update ability \n");
+
+ return TRUE;
+}
+
+static void __interpret_update_ability_menu(char *cmd)
+{
+ int len = strlen(cmd);
+
+ if (len == 1) {
+ if (!strncmp(cmd, "1", len))
+ __update_ability(1);
+ else if (!strncmp(cmd, "2", len))
+ __update_ability(2);
+ else if (!strncmp(cmd, "3", len))
+ __update_ability(3);
+ else if (!strncmp(cmd, "4", len))
+ __update_ability(4);
+ else if (!strncmp(cmd, "5", len))
+ __update_ability(5);
+ else if (!strncmp(cmd, "6", len))
+ __update_ability(6);
else if (!strncmp(cmd, "7", len))
- __update_info(7);
- else if (!strncmp(cmd, "8", len))
- __update_info(8);
- else if (!strncmp(cmd, "9", len))
- __update_info(9);
+ __update_ability(7);
else if (!strncmp(cmd, "0", len))
__reset_current_menu_state();
+ else
+ g_print("wrong command\n");
} else {
g_print("wrong command\n");
}
else if (!strncmp(cmd, "0", len)) {
__reset_current_menu_state();
__display_menu();
+ } else {
+ g_print("wrong command\n");
+ __display_menu();
}
} else {
g_print("wrong command\n");
+ __display_menu();
}
}
-static void __interpret_send_menu(char *cmd)
+static void __interpret_send_event_menu(char *cmd)
{
int len = strlen(cmd);
} else if (!strncmp(cmd, "0", len)) {
__reset_current_menu_state();
__display_menu();
+ } else {
+ g_print("wrong command\n");
+ __display_menu();
}
} else {
g_print("wrong command\n");
+ __display_menu();
}
}
g_menu_state = CURRENT_STATE_INFORMATION_SET_MENU;
else if (!strncmp(cmd, "4", len))
g_menu_state = CURRENT_STATE_INFORMATION_UPDATE_MENU;
+ else if (!strncmp(cmd, "5", len))
+ g_menu_state = CURRENT_STATE_ABILITY_UPDATE_MENU;
else if (!strncmp(cmd, "6", len))
g_menu_state = CURRENT_STATE_SEND_EVENT_MENU;
else if (!strncmp(cmd, "9", len))
__set_info(g_menu_set_state, cmd);
__reset_current_set_menu_state();
__display_menu();
+ break;
default:
+ __display_menu();
break;
}
break;
__interpret_update_info_menu(cmd);
__display_menu();
break;
+ case CURRENT_STATE_ABILITY_UPDATE_MENU:
+ __interpret_update_ability_menu(cmd);
+ __display_menu();
+ break;
case CURRENT_STATE_SEND_EVENT_MENU:
switch (g_menu_send_event) {
case 0:
- __interpret_send_menu(cmd);
+ __interpret_send_event_menu(cmd);
break;
case 2:
__send_event(g_menu_send_event, cmd);
projects / platform / core / api / media-controller.git / commitdiff