*
*/
-
#ifndef _OAL_AVRCP_CT_H_
#define _OAL_AVRCP_CT_H_
-
#include <glib.h>
#include <sys/types.h>
#include <oal-manager.h>
OAL_PLAY_POSITION,
} avrcp_ct_player_property_type_t;
-typedef enum {
- OAL_PLAYSTATE_STOPPED = 0x00, /* Stopped */
- OAL_PLAYSTATE_PLAYING = 0x01, /* Playing */
- OAL_PLAYSTATE_PAUSED = 0x02, /* Paused */
- OAL_PLAYSTATE_FWD_SEEK = 0x03, /* Fwd Seek*/
- OAL_PLAYSTATE_REV_SEEK = 0x04, /* Rev Seek*/
- OAL_PLAYSTATE_ERROR = 0xFF, /* Error */
-} avrcp_ct_play_status_t;
-
-typedef struct {
- const char *title;
- const char *artist;
- const char *album;
- const char *genre;
- unsigned int total_tracks;
- unsigned int number;
- unsigned int duration;
-} avrcp_ct_media_metadata_attr_t;
-
typedef struct {
+ avrcp_ct_player_property_type_t type;
unsigned int value;
} avrcp_ct_property_value_t;
uint32_t song_pos;
} avrcp_ct_play_position_t;
-typedef struct {
- avrcp_ct_play_status_t play_status;
-} avrcp_ct_play_status_val_t;
-
/**
- * @brief Enable AVRCP Ctroller Feature
+ * @brief Enable AVRCP Controller Feature
*
- * @remarks BT Profile AVRCP Controller will be able to connect.
+ * @remarks Devices supporting AVRCP Target will be able to connect.
+ * @remarks Used in conjunction with a2dp_sink_enable.
*
- * @return OAL_STATUS_SUCCESS on success, otherwise non-zero error value.
+ * @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
* @retval #OAL_STATUS_SUCCESS Successful
*
* @pre OAL API must be initialized with oal_bt_init().
*
- * @see avrcp_ct_disable()
+ * @see avrcp_ct_disable
+ * @see a2dp_sink_enable
*/
oal_status_t avrcp_ct_enable(void);
/**
* @brief Disable AVRCP Controller Feature
*
- * @remarks BT Profile AVRCP Controller will be able to connect.
+ * @remarks Devices supporting AVRCP Target will not be able to connect.
+ * @remarks Used in conjunction with a2dp_sink_disable.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
* @retval #OAL_STATUS_SUCCESS Successful
*
- * @pre Audio host should be enabled with avrcp_ct_enable().
+ * @pre AVRCP Controller should be enabled with avrcp_ct_enable().
*
- * @see avrcp_ct_enable()
+ * @see avrcp_ct_enable
+ * @see a2dp_sink_disable
*/
oal_status_t avrcp_ct_disable(void);
-
/**
* @brief Initiate a connection with a BT Sound device
*
* @brief Play audio on the connected remote device.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_play(bt_address_t *device_address);
/**
* @brief Stop audio on the connected remote device.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_stop(bt_address_t *device_address);
/**
* @brief Pause audio on the connected remote device.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_pause(bt_address_t *device_address);
/**
* RELEASE_STATE - Stop Fast Forward
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_fforward(bt_address_t *device_address, avrcp_ct_pass_state_t press_state);
/**
* RELEASE_STATE - Stop Rewind
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_rewind(bt_address_t *device_address, avrcp_ct_pass_state_t press_state);
/**
* @brief Play next track on the connected remote device.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_next_track(bt_address_t *device_address);
* @brief Play prev track on the connected remote device.
*
* @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
- * @retval #OAL_STATUS_SUCCESS Successful
+ * @retval #OAL_STATUS_SUCCESS Successful
*
* @pre A2DP Sink should be connected with a device.
* @pre AVRCP connection should exist with the device.
- **/
+ */
oal_status_t avrcp_ct_prev_track(bt_address_t *device_address);
/**
* @pre OAL API must be initialize with avrcp_ct_enable().
*
*/
-oal_status_t avrcp_ct_get_property(bt_address_t *device_address, avrcp_ct_player_property_type_t type, uint32_t *value);
+oal_status_t avrcp_ct_get_property(bt_address_t *device_address, avrcp_ct_player_property_type_t type);
/**
* @brief Set media player properties to target device
*/
oal_status_t avrcp_ct_get_media_attribute(bt_address_t *device_address);
+/**
+ * @brief Request current status of the media playing on connected Audio source.
+ *
+ * @details Result containing - Song Length, Song Position and current status(Stopped/Playing/Paused) will be notified through an OAL event
+ *
+ * @return OAL_STATUS_SUCCESS on success, otherwise a non-zero error value.
+ * @retval #OAL_STATUS_SUCCESS Successful
+ *
+ * @pre A2DP Sink should be connected with a device.
+ * @pre AVRCP connection should exist with the device.
+ *
+ * @see OAL_EVENT_AVRCP_CT_PLAY_STATUS
+ * @see event_avrcp_ct_play_status_t
+ */
+oal_status_t avrcp_ct_get_play_status(bt_address_t *device_address);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
EVENT(OAL_EVENT_AVRCP_SETTING_SHUFFLE_STATUS) /* bt_address_t*/ \
EVENT(OAL_EVENT_AVRCP_SETTING_SCAN_STATUS) /* bt_address_t*/ \
EVENT(OAL_EVENT_AVRCP_VOLUME_MUTE_CHANGED)\
- EVENT(OAL_EVENT_AVRCP_CTRL_CONNECTING) /* bt_address_t*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_CONNECTED) /* bt_address_t*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_DISCONNECTING) /* bt_address_t*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_DISCONNECTED) /* bt_address_t*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_EQUALIZER_STATUS) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_REPEAT_STATUS) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_SHUFFLE_STATUS) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_SCAN_STATUS) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_PLAY_POSITION_STATUS) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_PLAY_STATUS_CHANGED) /* property_value*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_TRACK_INFO_CHANGED) /* trak_info*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_TRACK_INFO) /* trak_info response*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_PASS_CMD_RES) /* pass through command response*/ \
- EVENT(OAL_EVENT_AVRCP_CTRL_PLAYER_SETTING_RES) /* palyer setting response*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_CONNECTED) /* bt_address_t*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_DISCONNECTED) /* bt_address_t*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_EQUALIZER_STATUS) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_REPEAT_STATUS) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_SHUFFLE_STATUS) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_SCAN_STATUS) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_NOTIF_PLAY_STATUS_CHANGED) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_NOTIF_PLAY_POS_CHANGED) /* property_value*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_NOTIF_TRACK_CHANGE) /* trak_info*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_MEDIA_INFO) /* trak_info response*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_PLAY_STATUS) \
+ EVENT(OAL_EVENT_AVRCP_CT_PASS_CMD_RES) /* pass through command response*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_PLAYER_SETTING_RES) /* palyer setting response*/ \
+ EVENT(OAL_EVENT_AVRCP_CT_GET_PROPERTY_RES) /* get propery response*/ \
EVENT(OAL_EVENT_HDP_APP_REGISTERED) /* HDP APP registered */ \
EVENT(OAL_EVENT_HDP_APP_UNREGISTERED) /* HDP APP un-registered */ \
EVENT(OAL_EVENT_HDP_CHANNEL_CONNECTED) /* HDP channel connected */ \
oal_uuid_t client_uuid;
} event_gattc_register_t;
+/********* AVRCP CT role callback data structures ******************/
+#define MEDIA_ATTIRBUTE_STRING_LENGTH 100
+typedef struct {
+ uint8_t title_info[MEDIA_ATTIRBUTE_STRING_LENGTH];
+ uint8_t artist_info[MEDIA_ATTIRBUTE_STRING_LENGTH];
+ uint8_t album_info[MEDIA_ATTIRBUTE_STRING_LENGTH];
+ uint64_t playing_time;
+ uint8_t genre_info[MEDIA_ATTIRBUTE_STRING_LENGTH];
+ uint64_t total_track;
+ uint64_t track_number;
+} event_avrcp_ct_media_info_t;
+
+typedef enum {
+ OAL_PLAY_STATUS_STOPPED = 0x00,
+ OAL_PLAY_STATUS_PLAYING = 0x01,
+ OAL_PLAY_STATUS_PAUSED = 0x02,
+ OAL_PLAY_STATUS_FWD_SEEK = 0x03,
+ OAL_PLAY_STATUS_REV_SEEK = 0x04,
+ OAL_PLAY_STATUS_ERROR = 0xFF,
+} notif_event_avrcp_ct_play_status_t;
+
+#define BTRCC_UID_SIZE 8
+typedef uint8_t notif_event_avrcp_ct_track_id[BTRCC_UID_SIZE];
+
+typedef uint32_t notif_event_avrcp_ct_song_pos;
+
+typedef union {
+ notif_event_avrcp_ct_play_status_t play_status;
+ notif_event_avrcp_ct_track_id track_id;
+ notif_event_avrcp_ct_song_pos song_pos;
+} event_notif_avrcp_ct_notif_info_t;
+
+typedef struct {
+ uint8_t song_len;
+ uint8_t song_pos;
+ notif_event_avrcp_ct_play_status_t play_status;
+} event_avrcp_ct_play_status_t;
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
typedef struct {
long int song_pos;
long int playing_time;
- uint8_t title[BTRC_MAX_ATTR_STR_LEN];
- uint8_t artist[BTRC_MAX_ATTR_STR_LEN];
- uint8_t album[BTRC_MAX_ATTR_STR_LEN];
- uint8_t genre[BTRC_MAX_ATTR_STR_LEN];
- long int num_tracks;
- uint32_t cur_track;
+ uint8_t title_info[BTRC_MAX_ATTR_STR_LEN];
+ uint8_t artist_info[BTRC_MAX_ATTR_STR_LEN];
+ uint8_t album_info[BTRC_MAX_ATTR_STR_LEN];
+ uint8_t genre_info[BTRC_MAX_ATTR_STR_LEN];
+ long int total_track;
+ uint32_t track_number;
} avrcp_ct_track_info_t;
typedef struct {
+ bdstr_t bdstr;
int equalizer;
btrc_player_repeat_val_t repeat;
btrc_player_shuffle_val_t shuffle;
unsigned int volume;
} avrcp_ct_player_settings_t;
+typedef struct {
+ char address[BT_ADDRESS_STR_LEN];
+ avrcp_ct_player_settings_t player_setting;
+ avrcp_ct_track_info_t track_info;
+} avrcp_ct_player_info_t;
+
+static GSList *player_list = NULL;
+
const btrc_ctrl_interface_t * _bt_get_stack_interface(void);
static const btrc_ctrl_interface_t *avrcp_ct_interface = NULL;
static void cb_avrcp_ct_connection_state(bool rc_connect, bool bt_connect, bt_bdaddr_t* bd_addr);
-static void cb_avrcp_ct_btrc_playerapplicationsetting_changed (bt_bdaddr_t *bd_addr, btrc_player_settings_t *p_vals);
-static void cb_avrcp_ct_btrc_play_position_changed (bt_bdaddr_t *bd_addr, uint32_t song_len, uint32_t song_pos);
-static void cb_avrcp_ct_btrc_play_status_changed (bt_bdaddr_t *bd_addr, btrc_play_status_t play_status);
-static void cb_avrcp_ct_trak_info_chnaged (bt_bdaddr_t *bd_address, uint8_t num_attr, btrc_element_attr_val_t *p_attrs);
-static void cb_avrcp_ct_btrc_passthrough_rsp (bt_bdaddr_t *bd_addr, int id, int key_state);
-static void cb_avrcp_ct_btrc_setplayerapplicationsetting_rsp (bt_bdaddr_t *bd_addr, uint8_t accepted);
-
-static avrcp_ct_track_info_t track_info;
-static avrcp_ct_player_settings_t player_setting;
+static void cb_avrcp_ct_btrc_playerapplicationsetting_changed(bt_bdaddr_t *bd_addr, btrc_player_settings_t *p_vals);
+static void cb_avrcp_ct_btrc_play_position_changed(bt_bdaddr_t *bd_addr, uint32_t song_len, uint32_t song_pos);
+static void cb_avrcp_ct_btrc_play_status_changed(bt_bdaddr_t *bd_addr, btrc_play_status_t play_status);
+static void cb_avrcp_ct_trak_info_chnaged(bt_bdaddr_t *bd_address, uint8_t num_attr, btrc_element_attr_val_t *p_attrs);
+static void cb_avrcp_ct_btrc_passthrough_rsp(bt_bdaddr_t *bd_addr, int id, int key_state);
+static void cb_avrcp_ct_btrc_setplayerapplicationsetting_rsp(bt_bdaddr_t *bd_addr, uint8_t accepted);
/** AVRCP Controller callback structure. */
static btrc_ctrl_callbacks_t avrcp_ct_cb = {
NULL /*btrc_ct_set_addressed_player_callback*/
};
+static void __add_device_to_avrcp_list(bt_address_t *address)
+{
+ avrcp_ct_player_info_t *player_info;
+ avrcp_ct_player_settings_t *player_setting;
+ bdstr_t bdstr;
+ GSList *l;
+
+ bdt_bd2str(address, &bdstr);
+ BT_INFO("Address: %s", bdstr);
+ for (l = player_list; NULL != l; l = g_slist_next(l)) {
+ player_info = (avrcp_ct_player_info_t *)l->data;
+
+ if (!player_info)
+ continue;
+
+ if (!strncmp(bdstr, player_info->address, BT_ADDRESS_STR_LEN)) {
+ BT_INFO("Already added");
+ return;
+ }
+ }
+
+ player_info = g_new0(avrcp_ct_player_info_t, 1);
+
+ /* Copy address to player_info->address */
+ g_strlcpy(player_info->address, bdstr, BT_ADDRESS_STR_LEN);
+
+ /* Init player settings with default values */
+ player_setting = &player_info->player_setting;
+ player_setting->equalizer = 0;
+ player_setting->repeat = BTRC_PLAYER_VAL_OFF_REPEAT;
+ player_setting->shuffle = BTRC_PLAYER_VAL_OFF_SHUFFLE;
+ player_setting->scan = 0;
+ player_setting->status = BTRC_PLAYSTATE_STOPPED;
+ player_setting->volume = 0;
+
+ /* Nothing to do for track_info as values are already initialized to 0 */
+
+ /* Add player_info to player_list */
+ player_list = g_slist_append(player_list, player_info);
+}
+
+static void __remove_device_from_avrcp_list(bt_address_t *address)
+{
+ avrcp_ct_player_info_t *player_info = NULL;
+ bdstr_t bdstr;
+ GSList *l;
+
+ bdt_bd2str(address, &bdstr);
+ BT_INFO("Address: %s", bdstr);
+ for (l = player_list; NULL != l; l = g_slist_next(l)) {
+ player_info = (avrcp_ct_player_info_t *)l->data;
+
+ if (!player_info)
+ continue;
+
+ if (!strncmp(bdstr, player_info->address, BT_ADDRESS_STR_LEN)) {
+ BT_INFO("Found");
+ break;
+ }
+
+ player_info = NULL;
+ }
+
+ if (!player_info)
+ return;
+
+ player_list = g_slist_remove(player_list, player_info);
+ g_free(player_info);
+}
+
+static avrcp_ct_player_info_t *__get_player_info_from_list(bt_address_t *address)
+{
+ avrcp_ct_player_info_t *player_info;
+ bdstr_t bdstr;
+ GSList *l;
+
+ bdt_bd2str(address, &bdstr);
+ BT_INFO("Address: %s", bdstr);
+ for (l = player_list; NULL != l; l = g_slist_next(l)) {
+ player_info = (avrcp_ct_player_info_t *)l->data;
+
+ if (!player_info)
+ continue;
+
+ if (!strncmp(bdstr, player_info->address, BT_ADDRESS_STR_LEN)) {
+ BT_INFO("Found");
+ return player_info;
+ }
+ }
+
+ return NULL;
+}
oal_status_t avrcp_ct_enable(void)
{
static void cb_avrcp_ct_connection_state(bool rc_connect, bool bt_connect, bt_bdaddr_t* bd_addr)
{
- bt_address_t * event_data = NULL;
+ bt_address_t *event_data = NULL;
bdstr_t bdstr;
oal_event_t event;
event_data = g_new0(bt_address_t, 1);
memcpy(event_data->addr, bd_addr->address, BT_ADDRESS_BYTES_NUM);
- if (rc_connect)
- event = OAL_EVENT_AVRCP_CTRL_CONNECTED;
- else
- event = OAL_EVENT_AVRCP_CTRL_DISCONNECTED;
+ if (rc_connect) {
+ event = OAL_EVENT_AVRCP_CT_CONNECTED;
+ __add_device_to_avrcp_list(event_data);
+ } else {
+ event = OAL_EVENT_AVRCP_CT_DISCONNECTED;
+ __remove_device_from_avrcp_list(event_data);
+ }
send_event_bda_trace(event, event_data, sizeof(bt_address_t), (bt_address_t*)bd_addr);
}
-avrcp_ct_play_status_t __hal_to_oal_play_status(btrc_play_status_t play_status)
+notif_event_avrcp_ct_play_status_t __hal_to_oal_play_status(btrc_play_status_t play_status)
{
- avrcp_ct_play_status_t status = OAL_PLAYSTATE_ERROR;
+ notif_event_avrcp_ct_play_status_t status = OAL_PLAY_STATUS_ERROR;
+
switch(play_status) {
case BTRC_PLAYSTATE_STOPPED:
- status = OAL_PLAYSTATE_STOPPED;
+ status = OAL_PLAY_STATUS_STOPPED;
break;
case BTRC_PLAYSTATE_PLAYING:
- status = OAL_PLAYSTATE_PLAYING;
+ status = OAL_PLAY_STATUS_PLAYING;
break;
case BTRC_PLAYSTATE_PAUSED:
- status = OAL_PLAYSTATE_PAUSED;
+ status = OAL_PLAY_STATUS_PAUSED;
break;
case BTRC_PLAYSTATE_FWD_SEEK:
- status = OAL_PLAYSTATE_FWD_SEEK;
+ status = OAL_PLAY_STATUS_FWD_SEEK;
break;
case BTRC_PLAYSTATE_REV_SEEK:
- status = OAL_PLAYSTATE_REV_SEEK;
+ status = OAL_PLAY_STATUS_REV_SEEK;
break;
default :
BT_INFO("Incorrect Play status");
break;
}
+
return status;
}
+static avrcp_ct_player_settings_t *__get_player_setting(bt_address_t *address)
+{
+ avrcp_ct_player_info_t *player_info;
+
+ BT_INFO("");
+ player_info = __get_player_info_from_list(address);
+ if (!player_info)
+ return NULL;
+
+ return &player_info->player_setting;
+}
+
static void cb_avrcp_ct_btrc_playerapplicationsetting_changed(
bt_bdaddr_t *bd_addr, btrc_player_settings_t *p_vals)
{
avrcp_ct_property_value_t *event_data = NULL;
oal_event_t event;
int i;
+ bdstr_t bdstr;
+ avrcp_ct_player_settings_t *player_setting;
+
+ bdt_bd2str((bt_address_t *)bd_addr, &bdstr);
+ player_setting = __get_player_setting((bt_address_t *)bd_addr);
+ if (!player_setting) {
+ BT_INFO("player_setting is NULL");
+ /* Player info not yet added to player_list, first add it to list */
+ __add_device_to_avrcp_list((bt_address_t *)bd_addr);
+ player_setting = __get_player_setting((bt_address_t *)bd_addr);
+ }
for (i = 0; i < p_vals->num_attr; i++) {
event_data = g_new0(avrcp_ct_property_value_t, 1);
switch(p_vals->attr_ids[i]) {
case BTRC_PLAYER_ATTR_EQUALIZER:
- event = OAL_EVENT_AVRCP_CTRL_EQUALIZER_STATUS;
+ event = OAL_EVENT_AVRCP_CT_EQUALIZER_STATUS;
+ event_data->type = OAL_EQUALIZER;
event_data->value = p_vals->attr_values[i];
- player_setting.equalizer = p_vals->attr_values[i];
+ player_setting->equalizer = p_vals->attr_values[i];
break;
case BTRC_PLAYER_ATTR_REPEAT:
- event = OAL_EVENT_AVRCP_CTRL_REPEAT_STATUS;
+ event = OAL_EVENT_AVRCP_CT_REPEAT_STATUS;
+ event_data->type = OAL_REPEAT;
event_data->value = p_vals->attr_values[i];
- player_setting.repeat = p_vals->attr_values[i];
+ player_setting->repeat = p_vals->attr_values[i];
break;
case BTRC_PLAYER_ATTR_SHUFFLE:
- event = OAL_EVENT_AVRCP_CTRL_SHUFFLE_STATUS;
+ event = OAL_EVENT_AVRCP_CT_SHUFFLE_STATUS;
+ event_data->type = OAL_SHUFFLE;
event_data->value = p_vals->attr_values[i];
- player_setting.shuffle = p_vals->attr_values[i];
+ player_setting->shuffle = p_vals->attr_values[i];
break;
case BTRC_PLAYER_ATTR_SCAN:
- event = OAL_EVENT_AVRCP_CTRL_SCAN_STATUS;
+ event = OAL_EVENT_AVRCP_CT_SCAN_STATUS;
+ event_data->type = OAL_SCAN;
event_data->value = p_vals->attr_values[i];
- player_setting.scan = p_vals->attr_values[i];
+ player_setting->scan = p_vals->attr_values[i];
break;
default :
event = OAL_EVENT_END;
}
if (OAL_EVENT_END != event)
- send_event(event, event_data, sizeof(avrcp_ct_property_value_t *));
+ send_event(event, event_data, sizeof(avrcp_ct_property_value_t));
}
}
-static void cb_avrcp_ct_btrc_play_position_changed (bt_bdaddr_t *bd_addr, uint32_t song_len, uint32_t song_pos)
+static avrcp_ct_track_info_t *__get_track_info(bt_address_t *address)
+{
+ avrcp_ct_player_info_t *player_info;
+
+ BT_INFO("");
+ player_info = __get_player_info_from_list(address);
+ if (!player_info)
+ return NULL;
+
+ return &player_info->track_info;
+}
+
+static void cb_avrcp_ct_btrc_play_position_changed(
+ bt_bdaddr_t *bd_addr, uint32_t song_len, uint32_t song_pos)
{
- avrcp_ct_play_position_t *event_data = NULL;
+ event_notif_avrcp_ct_notif_info_t *event_data = NULL;
+ avrcp_ct_track_info_t *track_info;
+
+ track_info = __get_track_info((bt_address_t *)bd_addr);
+ if (!track_info) {
+ BT_INFO("track_info is NULL");
+ /* Player info not yet added to player_list, first add it to list */
+ __add_device_to_avrcp_list((bt_address_t *)bd_addr);
+ track_info = __get_track_info((bt_address_t *)bd_addr);
+ }
+ track_info->song_pos = song_pos;
- event_data = g_new0(avrcp_ct_play_position_t, 1);
- event_data->song_len = track_info.playing_time;
+ event_data = g_new0(event_notif_avrcp_ct_notif_info_t, 1);
event_data->song_pos = song_pos;
- track_info.song_pos = song_pos;
- send_event(OAL_EVENT_AVRCP_CTRL_PLAY_POSITION_STATUS, event_data, sizeof(avrcp_ct_play_position_t *));
+ send_event(OAL_EVENT_AVRCP_CT_NOTIF_PLAY_POS_CHANGED,
+ event_data, sizeof(event_notif_avrcp_ct_notif_info_t));
}
-static void cb_avrcp_ct_btrc_play_status_changed (bt_bdaddr_t *bd_addr, btrc_play_status_t play_status)
+static void cb_avrcp_ct_btrc_play_status_changed(
+ bt_bdaddr_t *bd_addr, btrc_play_status_t play_status)
{
- avrcp_ct_play_status_val_t *event_data = NULL;
+ event_notif_avrcp_ct_notif_info_t *event_data = NULL;
+ avrcp_ct_player_settings_t *player_setting;
+
+ player_setting = __get_player_setting((bt_address_t *)bd_addr);
+ if (!player_setting) {
+ BT_INFO("player_setting is NULL");
+ /* Player info not yet added to player_list, first add it to list */
+ __add_device_to_avrcp_list((bt_address_t *)bd_addr);
+ player_setting = __get_player_setting((bt_address_t *)bd_addr);
+ }
+
+ player_setting->status = play_status;
- event_data = g_new0(avrcp_ct_play_status_val_t, 1);
+ event_data = g_new0(event_notif_avrcp_ct_notif_info_t, 1);
event_data->play_status = __hal_to_oal_play_status(play_status);
- player_setting.status = play_status;
- send_event(OAL_EVENT_AVRCP_CTRL_PLAY_STATUS_CHANGED, event_data, sizeof(avrcp_ct_play_status_val_t *));
+ send_event(OAL_EVENT_AVRCP_CT_NOTIF_PLAY_STATUS_CHANGED,
+ event_data, sizeof(event_notif_avrcp_ct_notif_info_t));
}
-static void cb_avrcp_ct_btrc_passthrough_rsp (bt_bdaddr_t *bd_addr, int id, int state)
+static void cb_avrcp_ct_btrc_passthrough_rsp(bt_bdaddr_t *bd_addr, int id, int state)
{
avrcp_ct_pass_cmd_key_code_t key_code;
avrcp_ct_pass_state_t key_state;
key_code = id;
key_state = state;
- if(key_code) {
+ if (key_code) {
event_data->key_code = key_code;
event_data->key_state = key_state;
- send_event(OAL_EVENT_AVRCP_CTRL_PASS_CMD_RES, event_data, sizeof(avrcp_ct_pass_cmd_t *));
+ send_event(OAL_EVENT_AVRCP_CT_PASS_CMD_RES,
+ event_data, sizeof(avrcp_ct_pass_cmd_t));
} else {
BT_ERR("Invalid pass through command key code");
}
}
-static void cb_avrcp_ct_btrc_setplayerapplicationsetting_rsp (bt_bdaddr_t *bd_addr, uint8_t accepted)
+static void cb_avrcp_ct_btrc_setplayerapplicationsetting_rsp(
+ bt_bdaddr_t *bd_addr, uint8_t accepted)
{
avrcp_ct_playersetting_t *event_data;
event_data = g_new0(avrcp_ct_playersetting_t, 1);
event_data->accepted = accepted;
- send_event(OAL_EVENT_AVRCP_CTRL_PLAYER_SETTING_RES, event_data, sizeof(avrcp_ct_playersetting_t *));
+ send_event(OAL_EVENT_AVRCP_CT_PLAYER_SETTING_RES,
+ event_data, sizeof(avrcp_ct_playersetting_t));
}
-static void cb_avrcp_ct_trak_info_chnaged(bt_bdaddr_t *device_address, uint8_t num_attr, btrc_element_attr_val_t *p_attrs)
+static void cb_avrcp_ct_trak_info_chnaged(bt_bdaddr_t *device_address,
+ uint8_t num_attr, btrc_element_attr_val_t *p_attrs)
{
int idx =0;
- avrcp_ct_media_metadata_attr_t *event_data = NULL;
- event_data = g_new0(avrcp_ct_media_metadata_attr_t, 1);
+ avrcp_ct_track_info_t *track_info;
+ event_avrcp_ct_media_info_t *event_data = NULL;
+
+ track_info = __get_track_info((bt_address_t *)device_address);
+ if (!track_info) {
+ BT_INFO("track_info is NULL");
+ /* Player info not yet added to player_list, first add it to list */
+ __add_device_to_avrcp_list((bt_address_t *)device_address);
+ track_info = __get_track_info((bt_address_t *)device_address);
+ }
+ event_data = g_new0(event_avrcp_ct_media_info_t, 1);
for(idx=0; idx < num_attr; idx++) {
BT_INFO("idx [%d]", p_attrs[idx].attr_id);
switch(p_attrs[idx].attr_id) {
case BTRC_MEDIA_ATTR_ID_TITLE:
- event_data->title = g_strdup((const char*)&p_attrs[idx].text);
- g_strlcpy((gchar *)track_info.title, event_data->title, BTRC_MAX_ATTR_STR_LEN);
+ g_strlcpy((char *)track_info->title_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->title_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
break;
case BTRC_MEDIA_ATTR_ID_ARTIST:
- event_data->artist = g_strdup((const char*)&p_attrs[idx].text);
- g_strlcpy((gchar *)track_info.artist, event_data->artist, BTRC_MAX_ATTR_STR_LEN);
+ g_strlcpy((char *)track_info->artist_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->artist_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
break;
case BTRC_MEDIA_ATTR_ID_ALBUM:
- event_data->album = g_strdup((const char*)&p_attrs[idx].text);
- g_strlcpy((gchar *)track_info.album, event_data->album, BTRC_MAX_ATTR_STR_LEN);
+ g_strlcpy((char *)track_info->album_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->album_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
break;
case BTRC_MEDIA_ATTR_ID_GENRE:
- event_data->genre = g_strdup((const char*)&p_attrs[idx].text);
- g_strlcpy((gchar *)track_info.genre, event_data->genre, BTRC_MAX_ATTR_STR_LEN);
+ g_strlcpy((char *)track_info->genre_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->genre_info, (const char *)&p_attrs[idx].text,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
break;
case BTRC_MEDIA_ATTR_ID_NUM_TRACKS:
if(p_attrs[idx].text != NULL) {
- event_data->total_tracks = g_ascii_strtoll((const gchar *)p_attrs[idx].text, NULL, 10);
- track_info.num_tracks = event_data->total_tracks;
+ track_info->total_track = g_ascii_strtoll(
+ (const gchar *)p_attrs[idx].text, NULL, 10);
+ event_data->total_track = track_info->total_track;
} else {
BT_WARN("string is null!!!!!!!");
}
break;
case BTRC_MEDIA_ATTR_ID_TRACK_NUM:
if(p_attrs[idx].text != NULL) {
- event_data->number = g_ascii_strtoll((const gchar *)p_attrs[idx].text, NULL, 10);
- track_info.cur_track = event_data->number;
+ track_info->track_number = g_ascii_strtoll(
+ (const gchar *)p_attrs[idx].text, NULL, 10);
+ event_data->track_number = track_info->track_number;
} else {
BT_WARN("string is null!!!!!!!");
}
break;
case BTRC_MEDIA_ATTR_ID_PLAYING_TIME:
if(p_attrs[idx].text != NULL) {
- event_data->duration = g_ascii_strtoll((const gchar *)p_attrs[idx].text, NULL, 10);
- track_info.playing_time = event_data->duration;
+ track_info->playing_time = g_ascii_strtoll(
+ (const gchar *)p_attrs[idx].text, NULL, 10);
+ event_data->playing_time = track_info->playing_time;
} else {
BT_WARN("string is null!!!!!!!");
}
}
}
- send_event(OAL_EVENT_AVRCP_CTRL_TRACK_INFO_CHANGED, event_data, sizeof(avrcp_ct_media_metadata_attr_t *));
+ send_event(OAL_EVENT_AVRCP_CT_NOTIF_TRACK_CHANGE,
+ event_data, sizeof(event_avrcp_ct_media_info_t));
return;
}
return result;
}
-oal_status_t avrcp_ct_get_property( bt_address_t *device_address, avrcp_ct_player_property_type_t type, uint32_t *value)
+static gboolean __send_avrcp_property_event(gpointer data)
{
- int result = OAL_STATUS_SUCCESS;
+ avrcp_ct_property_value_t *event_data = (avrcp_ct_property_value_t *)data;
+
+ send_event(OAL_EVENT_AVRCP_CT_GET_PROPERTY_RES,
+ event_data, sizeof(avrcp_ct_property_value_t));
+ return FALSE;
+}
+
+oal_status_t avrcp_ct_get_property(bt_address_t *device_address, avrcp_ct_player_property_type_t type)
+{
+ avrcp_ct_player_info_t *player_info;
+ avrcp_ct_player_settings_t *player_setting;
+ avrcp_ct_track_info_t *track_info;
+ avrcp_ct_property_value_t *event_data;
API_TRACE();
CHECK_OAL_AVRCP_CTRL_ENABLED();
+ player_info = __get_player_info_from_list(device_address);
+ if (!player_info) {
+ BT_ERR("Player info not found");
+ return OAL_STATUS_INVALID_PARAM;
+ }
+
+ player_setting = &player_info->player_setting;
+ track_info = &player_info->track_info;
+
+ event_data = g_new0(avrcp_ct_property_value_t, 1);
+ event_data->type = type;
+
switch (type) {
case OAL_EQUALIZER:
- *value = player_setting.equalizer;
+ event_data->value = player_setting->equalizer;
break;
case OAL_REPEAT:
- *value = player_setting.repeat;
+ event_data->value = player_setting->repeat;
break;
case OAL_SHUFFLE:
- *value = player_setting.shuffle;
+ event_data->value = player_setting->shuffle;
break;
case OAL_SCAN:
- *value = player_setting.scan;
- break;
- case OAL_PLAY_STATUS:
- *value = player_setting.status;
+ event_data->value = player_setting->scan;
break;
case OAL_PLAY_POSITION:
- *value = track_info.song_pos;
+ event_data->value = track_info->song_pos;
break;
default:
BT_ERR("Invalid Type [%d]", type);
- result = OAL_STATUS_INVALID_PARAM;
+ return OAL_STATUS_INVALID_PARAM;
}
- return result;
+ g_idle_add(__send_avrcp_property_event, (gpointer)event_data);
+ return OAL_STATUS_SUCCESS;
+}
+
+static gboolean __send_avrcp_play_status_event(gpointer data)
+{
+ event_avrcp_ct_play_status_t *event_data = (event_avrcp_ct_play_status_t *)data;
+
+ send_event(OAL_EVENT_AVRCP_CT_PLAY_STATUS,
+ event_data, sizeof(event_avrcp_ct_play_status_t));
+
+ return FALSE;
}
-gboolean __send_media_attribute_event()
+oal_status_t avrcp_ct_get_play_status(bt_address_t *device_address)
{
- avrcp_ct_media_metadata_attr_t *event_data = NULL;
+ avrcp_ct_player_info_t *player_info;
+ avrcp_ct_player_settings_t *player_setting;
+ avrcp_ct_track_info_t *track_info;
+ event_avrcp_ct_play_status_t *event_data = NULL;
+
+ API_TRACE();
+ CHECK_OAL_AVRCP_CTRL_ENABLED();
- event_data = g_new0(avrcp_ct_media_metadata_attr_t, 1);
+ player_info = __get_player_info_from_list(device_address);
+ if (!player_info) {
+ BT_ERR("Player info not found");
+ return OAL_STATUS_INVALID_PARAM;
+ }
+
+ player_setting = &player_info->player_setting;
+ track_info = &player_info->track_info;
+
+ event_data = g_new0(event_avrcp_ct_play_status_t, 1);
+ event_data->song_len = track_info->playing_time;
+ event_data->song_pos = track_info->song_pos;
+
+ switch (player_setting->status) {
+ case BTRC_PLAYSTATE_STOPPED:
+ event_data->play_status = OAL_PLAY_STATUS_STOPPED;
+ break;
+ case BTRC_PLAYSTATE_PLAYING:
+ event_data->play_status = OAL_PLAY_STATUS_PLAYING;
+ break;
+ case BTRC_PLAYSTATE_PAUSED:
+ event_data->play_status = OAL_PLAY_STATUS_PAUSED;
+ break;
+ case BTRC_PLAYSTATE_FWD_SEEK:
+ event_data->play_status = OAL_PLAY_STATUS_FWD_SEEK;
+ break;
+ case BTRC_PLAYSTATE_REV_SEEK:
+ event_data->play_status = OAL_PLAY_STATUS_REV_SEEK;
+ break;
+ default:
+ event_data->play_status = OAL_PLAY_STATUS_ERROR;
+ break;
+ }
- event_data->title = g_strdup((gchar *)track_info.title);
- event_data->artist = g_strdup((gchar *)track_info.artist);
- event_data->album = g_strdup((gchar *)track_info.album);
- event_data->genre = g_strdup((gchar *)track_info.genre);
- event_data->total_tracks = track_info.num_tracks;
- event_data->number = track_info.cur_track;
- event_data->duration = track_info.playing_time;
+ g_idle_add(__send_avrcp_play_status_event, (gpointer)event_data);
+ return OAL_STATUS_SUCCESS;
+}
+
+static gboolean __send_media_attribute_event(gpointer data)
+{
+ event_avrcp_ct_media_info_t *event_data = (event_avrcp_ct_media_info_t *)data;
- send_event(OAL_EVENT_AVRCP_CTRL_TRACK_INFO, event_data, sizeof(avrcp_ct_media_metadata_attr_t *));
+ send_event(OAL_EVENT_AVRCP_CT_MEDIA_INFO,
+ event_data, sizeof(event_avrcp_ct_media_info_t));
return FALSE;
}
oal_status_t avrcp_ct_get_media_attribute(bt_address_t *device_address)
{
- int result = OAL_STATUS_SUCCESS;
+ avrcp_ct_track_info_t *track_info;
+ event_avrcp_ct_media_info_t *event_data;
API_TRACE();
OAL_CHECK_PARAMETER(device_address, return);
- g_idle_add(__send_media_attribute_event,NULL);
- return result;
-}
+ track_info = __get_track_info(device_address);
+ if (!track_info) {
+ BT_ERR("Player info not found");
+ return OAL_STATUS_INVALID_PARAM;
+ }
+
+ event_data = g_new0(event_avrcp_ct_media_info_t, 1);
+ g_strlcpy((char *)event_data->title_info, (const char *)track_info->title_info,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->album_info, (const char *)track_info->album_info,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->genre_info, (const char *)track_info->genre_info,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ g_strlcpy((char *)event_data->artist_info, (const char *)track_info->artist_info,
+ MEDIA_ATTIRBUTE_STRING_LENGTH);
+ event_data->playing_time = track_info->playing_time;
+ event_data->total_track = track_info->total_track;
+ event_data->track_number = track_info->track_number;
+
+ g_idle_add(__send_media_attribute_event, (gpointer)event_data);
+
+ return OAL_STATUS_SUCCESS;
+}
\ No newline at end of file
BT_DBG("");
for (i = 0; i < p_vals->num_attr; i++) {
- value = g_new0(uint8_t, 1);
event = 0xffff;
switch (p_vals->attr_ids[i]) {
break;
default:
BT_ERR("Inavlid attr id= %d", p_vals->attr_ids[i]);
- g_free(value);
}
if (event != 0xffff) {
+ value = g_new0(uint8_t, 1);
*value = p_vals->attr_values[i];
send_event(event, value, sizeof(*value));
}
LIST(APPEND SRCS ./services/obex/bt-service-map-client.c)
LIST(APPEND SRCS ./services/obex/bt-service-opp-client.c)
LIST(APPEND SRCS ./services/obex/bt-service-pbap.c)
-LIST(APPEND SRCS ./services/obex/bt-service-avrcp.c)
LIST(APPEND SRCS ./services/obex/bt-service-obex-event-receiver.c)
LIST(APPEND SRCS ./services/obex/bt-service-oob.c)
ENDIF()
#include <bluetooth-media-control.h>
#include <bt-service-event.h>
+static int __media_prop_to_oal_type(int type)
+{
+ int oal_type;
+
+ switch (type) {
+ case EQUALIZER:
+ oal_type = OAL_EQUALIZER;
+ break;
+ case SHUFFLE:
+ oal_type = OAL_SHUFFLE;
+ break;
+ case REPEAT:
+ oal_type = OAL_REPEAT;
+ break;
+ case SCAN:
+ oal_type = OAL_SCAN;
+ break;
+ case POSITION:
+ oal_type = OAL_PLAY_POSITION;
+ break;
+ case STATUS:
+ oal_type = OAL_PLAY_STATUS;
+ break;
+ default:
+ BT_ERR("Unknown type: %d", type);
+ oal_type = -1;
+ }
+
+ return oal_type;
+}
+
+static int __oal_type_to_media_prop(int oal_type)
+{
+ int type;
+
+ switch (oal_type) {
+ case OAL_EQUALIZER:
+ type = EQUALIZER;
+ break;
+ case OAL_SHUFFLE:
+ type = SHUFFLE;
+ break;
+ case OAL_REPEAT:
+ type = REPEAT;
+ break;
+ case OAL_SCAN:
+ type = SCAN;
+ break;
+ case OAL_PLAY_POSITION:
+ type = POSITION;
+ break;
+ case OAL_PLAY_STATUS:
+ type = STATUS;
+ break;
+ default:
+ BT_ERR("Unknown type: %d", oal_type);
+ type = -1;
+ }
+
+ return type;
+}
+
int _bt_avrcp_connect_remote_target(bluetooth_device_address_t *device_address)
{
oal_status_t status = OAL_STATUS_SUCCESS;
connected = _bt_is_headset_type_connected(BT_AVRCP, connected_address);
if (connected) {
+ int oal_type;
+
+ oal_type = __media_prop_to_oal_type(type);
+ retv_if(0 > oal_type, BLUETOOTH_ERROR_INVALID_PARAM);
+
_bt_convert_addr_string_to_type(device_address.addr,
connected_address);
status = avrcp_ct_set_property((bt_address_t*)&device_address,
- type, value);
+ oal_type, value);
if (status != OAL_STATUS_SUCCESS) {
BT_ERR("Set peoperty err: [%d]", status);
result = BLUETOOTH_ERROR_INTERNAL;
return result;
}
-int _bt_avrcp_control_get_property(int type, unsigned int *value)
+int _bt_avrcp_control_get_property(int type)
{
char connected_address[BT_ADDRESS_STRING_SIZE + 1];
gboolean connected;
- bluetooth_device_address_t device_address;
+ bt_address_t device_address;
oal_status_t status = OAL_STATUS_SUCCESS;
int result = BLUETOOTH_ERROR_NONE;
BT_INFO("+");
_bt_convert_addr_string_to_type(
device_address.addr,
connected_address);
-
- switch (type) {
- case EQUALIZER:
- oal_type = OAL_EQUALIZER;
- break;
- case SHUFFLE:
- oal_type = OAL_SHUFFLE;
- break;
- case REPEAT:
- oal_type = OAL_REPEAT;
- break;
- case SCAN:
- oal_type = OAL_SCAN;
- break;
- case POSITION:
- oal_type = OAL_PLAY_POSITION;
- break;
- case STATUS:
- oal_type = OAL_PLAY_STATUS;
- break;
- default:
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- status = avrcp_ct_get_property((bt_address_t*)&device_address,
- oal_type, value);
- if (status != OAL_STATUS_SUCCESS) {
- BT_ERR("Get peoperty err: [%d]", status);
- result = BLUETOOTH_ERROR_INTERNAL;
+ if (type == STATUS) {
+ status = avrcp_ct_get_play_status(&device_address);
+ if (status != OAL_STATUS_SUCCESS) {
+ BT_ERR("Get play status err: [%d]", status);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ } else {
+ oal_type = __media_prop_to_oal_type(type);
+ retv_if (0 > oal_type, BLUETOOTH_ERROR_INVALID_PARAM);
+
+ status = avrcp_ct_get_property(&device_address, oal_type);
+ if (status != OAL_STATUS_SUCCESS) {
+ BT_ERR("Get peoperty err: [%d]", status);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
}
} else {
BT_ERR("Device is not connected:");
_bt_free_info_from_invocation_list(req_info);
}
+static void __bt_avrcp_ct_reply_pending_requests(void)
+{
+ BT_INFO("+");
+ int result = BLUETOOTH_ERROR_INTERNAL;
+ GArray *out_param;
+ invocation_info_t *req_info;
+ GSList *l;
+
+ for (l = _bt_get_invocation_list(); l != NULL;) {
+ req_info = l->data;
+ l = g_slist_next(l);
+
+ if (req_info == NULL)
+ continue;
+
+ /* Create out param */
+ out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
+
+ BT_INFO("service_function: [0x%X]", req_info->service_function);
+ switch(req_info->service_function) {
+ case BT_AVRCP_GET_TRACK_INFO:
+ case BT_AVRCP_CONTROL_GET_PROPERTY: {
+ _bt_service_method_return(req_info->context, out_param, result);
+ break;
+ }
+ default:
+ break;
+ }
+ _bt_free_info_from_invocation_list(req_info);
+ g_array_free(out_param, TRUE);
+ }
+ BT_INFO("-");
+}
+
static void __bt_handle_avrcp_target_disconnected_state(bluetooth_device_address_t *address)
{
char addr[BT_ADDRESS_STRING_SIZE] = { 0 };
/* Remove data from the connected list */
_bt_remove_headset_from_list(BT_AVRCP, addr);
- /* Replay to avrcp cotroller connect */
+ /* Reply to avrcp cotroller connect */
__bt_reply_avrcp_ct_disconnection_pending_request(address);
+ /* Reply AVRCP CT pending requests */
+ __bt_avrcp_ct_reply_pending_requests();
+
/* Send AVRCP(TARGET Role) disconnected event to Application */
param = g_variant_new("(is)", result, addr);
_bt_send_event(BT_AVRCP_CONTROL_EVENT, BLUETOOTH_EVENT_AVRCP_DISCONNECTED, param);
int ret =0;
switch(oal_event) {
- case OAL_EVENT_AVRCP_CTRL_EQUALIZER_STATUS:
- ret = BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS;
- break;
- case OAL_EVENT_AVRCP_CTRL_REPEAT_STATUS:
- ret = BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS;
- break;
- case OAL_EVENT_AVRCP_CTRL_SHUFFLE_STATUS:
- ret = BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS;
- break;
- case OAL_EVENT_AVRCP_CTRL_SCAN_STATUS:
- ret = BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS;
- break;
- case OAL_EVENT_AVRCP_CTRL_PLAY_POSITION_STATUS:
- ret = BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS;
- break;
- case OAL_EVENT_AVRCP_CTRL_PLAY_STATUS_CHANGED:
- ret = BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED;
- break;
- case OAL_EVENT_AVRCP_CTRL_TRACK_INFO_CHANGED:
- ret = BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED;
- break;
- default:
- break;
+ case OAL_EVENT_AVRCP_CT_EQUALIZER_STATUS:
+ ret = BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS;
+ break;
+ case OAL_EVENT_AVRCP_CT_REPEAT_STATUS:
+ ret = BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS;
+ break;
+ case OAL_EVENT_AVRCP_CT_SHUFFLE_STATUS:
+ ret = BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS;
+ break;
+ case OAL_EVENT_AVRCP_CT_SCAN_STATUS:
+ ret = BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS;
+ break;
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_POS_CHANGED:
+ ret = BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS;
+ break;
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_STATUS_CHANGED:
+ ret = BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED;
+ break;
+ default:
+ break;
}
return ret;
}
__bt_oal_to_bt_event(oal_event), param);
}
-static void __bt_handle_avrcp_track_info_changed(avrcp_ct_media_metadata_attr_t* metadata)
+static void __bt_handle_avrcp_track_info_changed(event_avrcp_ct_media_info_t* metadata)
{
GVariant *param;
+ unsigned int total_track = 0;
+ unsigned int track_number = 0;
+ unsigned int playing_time = 0;
BT_INFO("+");
+
+ total_track = (unsigned int)(metadata->total_track);
+ track_number = (unsigned int)(metadata->track_number);
+ playing_time = (unsigned int)(metadata->playing_time);
/* Send AVRCP Target player track info changed event to application*/
param = g_variant_new("(ssssuuu)",
- metadata->title,
- metadata->artist,
- metadata->album,
- metadata->genre,
- metadata->total_tracks,
- metadata->number,
- metadata->duration);
+ metadata->title_info,
+ metadata->artist_info,
+ metadata->album_info,
+ metadata->genre_info,
+ total_track,
+ track_number,
+ playing_time);
+
+ BT_INFO("Total_track: %u, track_number: %u, playing_time: %u",
+ total_track, track_number, playing_time);
_bt_send_event(BT_AVRCP_CONTROL_EVENT,
BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED, param);
}
return NULL;
}
-static void __bt_handle_avrcp_track_info(avrcp_ct_media_metadata_attr_t* metadata)
+static void __bt_handle_avrcp_track_info(event_avrcp_ct_media_info_t* metadata)
{
media_metadata_t meta_data;
invocation_info_t *req_info = NULL;
GArray *out_param = NULL;
int result = BLUETOOTH_ERROR_NONE;
+ req_info = __bt_get_request_info(BT_AVRCP_GET_TRACK_INFO);
+ ret_if(NULL == req_info);
+
memset(&meta_data, 0x00, sizeof(media_metadata_t));
- if (_bt_copy_utf8_string(meta_data.title, metadata->title,
- BT_META_DATA_MAX_LEN))
- BT_ERR("Error in copying Title\n");
- if (_bt_copy_utf8_string(meta_data.artist, metadata->artist,
- BT_META_DATA_MAX_LEN))
- BT_ERR("Error in copying Artist\n");
- if (_bt_copy_utf8_string(meta_data.album, metadata->album,
- BT_META_DATA_MAX_LEN))
- BT_ERR("Error in copying Album\n");
- if (_bt_copy_utf8_string(meta_data.genre, metadata->genre,
- BT_META_DATA_MAX_LEN))
- BT_ERR("Error in copying Genre\n");
-
- if (_bt_utf8_validate(meta_data.title) == FALSE)
- meta_data.title[0] = '\0';
-
- if (_bt_utf8_validate(meta_data.artist) == FALSE)
- meta_data.artist[0] = '\0';
-
- if (_bt_utf8_validate(meta_data.album) == FALSE)
- meta_data.album[0] = '\0';
-
- if (_bt_utf8_validate(meta_data.genre) == FALSE)
- meta_data.genre[0] = '\0';
- meta_data.total_tracks = metadata->total_tracks;
- meta_data.number = metadata->number;
- meta_data.duration = metadata->duration;
-
- g_free((gpointer)metadata->title);
- g_free((gpointer)metadata->artist);
- g_free((gpointer)metadata->album);
- g_free((gpointer)metadata->genre);
+ memcpy(&meta_data.title, &metadata->title_info,
+ strlen((char *)metadata->title_info));
+ meta_data.title[strlen((char *)metadata->title_info)] = '\0';
- req_info = __bt_get_request_info(BT_AVRCP_GET_TRACK_INFO);
+ memcpy(&meta_data.artist, &metadata->artist_info,
+ strlen((char *)metadata->artist_info));
+ meta_data.artist[strlen((char *)metadata->artist_info)] = '\0';
+
+ memcpy(&meta_data.album, &metadata->album_info,
+ strlen((char *)metadata->album_info));
+ meta_data.album[strlen((char *)metadata->album_info)] = '\0';
+
+ memcpy(&meta_data.genre, &metadata->genre_info,
+ strlen((char *)metadata->genre_info));
+ meta_data.genre[strlen((char *)metadata->genre_info)] = '\0';
+
+ meta_data.total_tracks = metadata->total_track;
+ meta_data.number = metadata->track_number;
+ meta_data.duration = metadata->playing_time;
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
- g_array_append_vals(out_param, &meta_data,
- sizeof(media_metadata_t));
+ g_array_append_vals(out_param, &meta_data, sizeof(media_metadata_t));
_bt_service_method_return(req_info->context, out_param, result);
g_array_free(out_param, TRUE);
BT_INFO("Set Property Response [%d]", player_setting_res->accepted);
}
+static void __bt_handle_avrcp_get_property_res_event(avrcp_ct_player_property_type_t oal_type, int value)
+{
+ invocation_info_t *req_info = NULL;
+ GArray *out_param = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+ int prop_type;
+ int type;
+ GSList *l;
+
+ BT_DBG("+");
+
+ prop_type = __oal_type_to_media_prop(oal_type);
+ ret_if(0 > prop_type);
+
+ out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
+ g_array_append_vals(out_param, &value, sizeof(value));
+
+ /* Find and reply to all get requests for prop_type */
+ for (l = _bt_get_invocation_list(); l != NULL;) {
+ req_info = l->data;
+ l = g_slist_next(l);
+
+ if (req_info == NULL)
+ continue;
+
+ type = *((int *)req_info->user_data);
+ if(req_info->service_function != BT_AVRCP_CONTROL_GET_PROPERTY
+ || type != prop_type)
+ continue;
+
+ BT_INFO("Request found");
+ _bt_service_method_return(req_info->context, out_param, result);
+ g_free(req_info->user_data);
+ _bt_free_info_from_invocation_list(req_info);
+ }
+
+ g_array_free(out_param, TRUE);
+ BT_DBG("-");
+}
+
void _bt_avrcp_ctrl_event_handler(int oal_event, gpointer event_data)
{
BT_INFO("+");
bluetooth_device_address_t* bd_addr;
switch(oal_event) {
- case OAL_EVENT_AVRCP_CTRL_CONNECTING:
- case OAL_EVENT_AVRCP_CTRL_CONNECTED: {
+ case OAL_EVENT_AVRCP_CT_CONNECTED: {
BT_INFO("AVRCP Controller Profile connected..");
bd_addr= (bluetooth_device_address_t*)event_data;
__bt_handle_avrcp_target_connected_state(bd_addr);
break;
}
- case OAL_EVENT_AVRCP_CTRL_DISCONNECTING:
- case OAL_EVENT_AVRCP_CTRL_DISCONNECTED: {
+ case OAL_EVENT_AVRCP_CT_DISCONNECTED: {
BT_INFO("AVRCP Controller Profile dissconnected..");
bd_addr= (bluetooth_device_address_t*)event_data;
__bt_handle_avrcp_target_disconnected_state(bd_addr);
break;
}
- case OAL_EVENT_AVRCP_CTRL_EQUALIZER_STATUS:
- case OAL_EVENT_AVRCP_CTRL_REPEAT_STATUS:
- case OAL_EVENT_AVRCP_CTRL_SHUFFLE_STATUS:
- case OAL_EVENT_AVRCP_CTRL_SCAN_STATUS:
- case OAL_EVENT_AVRCP_CTRL_PLAY_STATUS_CHANGED: {
+ case OAL_EVENT_AVRCP_CT_EQUALIZER_STATUS:
+ case OAL_EVENT_AVRCP_CT_REPEAT_STATUS:
+ case OAL_EVENT_AVRCP_CT_SHUFFLE_STATUS:
+ case OAL_EVENT_AVRCP_CT_SCAN_STATUS: {
avrcp_ct_property_value_t* property_val;
property_val = (avrcp_ct_property_value_t*)event_data;
__bt_handle_avrcp_target_player_property(property_val->value, oal_event);
break;
}
- case OAL_EVENT_AVRCP_CTRL_PLAY_POSITION_STATUS: {
- avrcp_ct_play_position_t* play_position;
- play_position = (avrcp_ct_play_position_t*)event_data;
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_STATUS_CHANGED:{
+ event_notif_avrcp_ct_notif_info_t* play_status_val;
+ play_status_val = (event_notif_avrcp_ct_notif_info_t*)event_data;
+ __bt_handle_avrcp_target_player_property(play_status_val->play_status, oal_event);
+ break;
+ }
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_POS_CHANGED: {
+ event_notif_avrcp_ct_notif_info_t* play_position;
+ play_position = (event_notif_avrcp_ct_notif_info_t*)event_data;
__bt_handle_avrcp_target_player_property(play_position->song_pos, oal_event);
break;
}
- case OAL_EVENT_AVRCP_CTRL_TRACK_INFO_CHANGED: {
- BT_INFO("AVRCP Controller Track Info Changed event..");
- avrcp_ct_media_metadata_attr_t* metadata;
+ case OAL_EVENT_AVRCP_CT_NOTIF_TRACK_CHANGE: {
+ BT_INFO("AVRCP Controller Track Changed event..");
+ event_avrcp_ct_media_info_t* metadata = event_data;
- metadata = (avrcp_ct_media_metadata_attr_t* )event_data;
__bt_handle_avrcp_track_info_changed(metadata);
break;
}
- case OAL_EVENT_AVRCP_CTRL_TRACK_INFO: {
+ case OAL_EVENT_AVRCP_CT_MEDIA_INFO: {
BT_INFO("AVRCP Controller Track Info event..");
- avrcp_ct_media_metadata_attr_t* metadata;
+ event_avrcp_ct_media_info_t* metadata;
- metadata = (avrcp_ct_media_metadata_attr_t* )event_data;
+ metadata = (event_avrcp_ct_media_info_t* )event_data;
__bt_handle_avrcp_track_info(metadata);
break;
}
- case OAL_EVENT_AVRCP_CTRL_PASS_CMD_RES: {
+ case OAL_EVENT_AVRCP_CT_GET_PROPERTY_RES: {
+ BT_INFO("AVRCP Controller Get Property response event..");
+ avrcp_ct_property_value_t *property = (avrcp_ct_property_value_t *)event_data;
+ __bt_handle_avrcp_get_property_res_event(property->type, property->value);
+ break;
+ }
+ case OAL_EVENT_AVRCP_CT_PLAY_STATUS: {
+ BT_INFO("AVRCP Controller Get Play status response event..");
+ event_avrcp_ct_play_status_t *play_status_info = (event_avrcp_ct_play_status_t *)event_data;
+ __bt_handle_avrcp_get_property_res_event(OAL_PLAY_STATUS, play_status_info->play_status);
+ break;
+ }
+ case OAL_EVENT_AVRCP_CT_PASS_CMD_RES: {
BT_INFO("AVRCP Controller Pass Command Res");
avrcp_ct_pass_cmd_t *pass_cmd;
__bt_handle_avrcp_pass_cmd_res(pass_cmd);
break;
}
- case OAL_EVENT_AVRCP_CTRL_PLAYER_SETTING_RES: {
+ case OAL_EVENT_AVRCP_CT_PLAYER_SETTING_RES: {
BT_INFO("AVRCP Player setting response");
avrcp_ct_playersetting_t *player_setting_res;
|| service_function == BT_HDP_DESTROY_APPLICATION
|| service_function == BT_HDP_GET_FD
|| service_function == BT_AVRCP_GET_TRACK_INFO
+ || service_function == BT_AVRCP_CONTROL_GET_PROPERTY
|| service_function == BT_SET_ADVERTISING_DATA
|| service_function == BT_SET_SCAN_RESPONSE_DATA
|| service_function == BT_SET_ADVERTISING
}
case BT_AVRCP_CONTROL_GET_PROPERTY: {
int type;
- unsigned int value;
__bt_service_get_parameters(in_param1, &type, sizeof(int));
- result = _bt_avrcp_control_get_property(type, &value);
- g_array_append_vals(*out_param1, &value, sizeof(int));
-
+ result = _bt_avrcp_control_get_property(type);
+ /* Save invocation */
+ if (result == BLUETOOTH_ERROR_NONE) {
+ sender = (char*)g_dbus_method_invocation_get_sender(context);
+ _bt_save_invocation_context(context, result, sender,
+ function_name, g_memdup(&type, sizeof(int)));
+ }
break;
}
case BT_AVRCP_GET_TRACK_INFO: {
if (avrcp_cb)
avrcp_cb(event_type, event_data);
break;
- case OAL_EVENT_AVRCP_CTRL_CONNECTING:
- case OAL_EVENT_AVRCP_CTRL_CONNECTED:
- case OAL_EVENT_AVRCP_CTRL_DISCONNECTING:
- case OAL_EVENT_AVRCP_CTRL_DISCONNECTED:
- case OAL_EVENT_AVRCP_CTRL_EQUALIZER_STATUS:
- case OAL_EVENT_AVRCP_CTRL_REPEAT_STATUS:
- case OAL_EVENT_AVRCP_CTRL_SHUFFLE_STATUS:
- case OAL_EVENT_AVRCP_CTRL_SCAN_STATUS:
- case OAL_EVENT_AVRCP_CTRL_PLAY_POSITION_STATUS:
- case OAL_EVENT_AVRCP_CTRL_PLAY_STATUS_CHANGED:
- case OAL_EVENT_AVRCP_CTRL_TRACK_INFO_CHANGED:
- case OAL_EVENT_AVRCP_CTRL_TRACK_INFO:
- case OAL_EVENT_AVRCP_CTRL_PASS_CMD_RES:
- case OAL_EVENT_AVRCP_CTRL_PLAYER_SETTING_RES:
+ case OAL_EVENT_AVRCP_CT_CONNECTED:
+ case OAL_EVENT_AVRCP_CT_DISCONNECTED:
+ case OAL_EVENT_AVRCP_CT_EQUALIZER_STATUS:
+ case OAL_EVENT_AVRCP_CT_REPEAT_STATUS:
+ case OAL_EVENT_AVRCP_CT_SHUFFLE_STATUS:
+ case OAL_EVENT_AVRCP_CT_SCAN_STATUS:
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_STATUS_CHANGED:
+ case OAL_EVENT_AVRCP_CT_NOTIF_PLAY_POS_CHANGED:
+ case OAL_EVENT_AVRCP_CT_NOTIF_TRACK_CHANGE:
+ case OAL_EVENT_AVRCP_CT_MEDIA_INFO:
+ case OAL_EVENT_AVRCP_CT_PLAY_STATUS:
+ case OAL_EVENT_AVRCP_CT_PASS_CMD_RES:
+ case OAL_EVENT_AVRCP_CT_PLAYER_SETTING_RES:
+ case OAL_EVENT_AVRCP_CT_GET_PROPERTY_RES:
if(avrcp_ctrl_cb)
avrcp_ctrl_cb(event_type, event_data);
break;
g_main_loop_run(main_loop);
BT_DBG("g_main_loop_quit called!");
-
bluetooth_plugin_deinit();
if (main_loop != NULL) {
int _bt_avrcp_control_set_property(int type, unsigned int value);
-int _bt_avrcp_control_get_property(int type, unsigned int *value);
+int _bt_avrcp_control_get_property(int type);
int _bt_avrcp_control_get_track_info(void);
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <gio/gio.h>
-#include <glib.h>
-#include <dlog.h>
-#include <string.h>
-
-#include "bluetooth-api.h"
-#include "bt-internal-types.h"
-#include "bt-service-common.h"
-#include "bt-service-avrcp.h"
-#include "bt-service-event.h"
-#include "bt-service-util.h"
-#include "bt-service-audio.h"
-
-static bt_player_settinngs_t loopstatus_settings[] = {
- { REPEAT_INVALID, "" },
- { REPEAT_MODE_OFF, "None" },
- { REPEAT_SINGLE_TRACK, "Track" },
- { REPEAT_ALL_TRACK, "Playlist" },
- { REPEAT_INVALID, "" }
-};
-
-static bt_player_settinngs_t shuffle_settings[] = {
- { SHUFFLE_INVALID, "" },
- { SHUFFLE_MODE_OFF, "off" },
- { SHUFFLE_ALL_TRACK, "alltracks" },
- { SHUFFLE_GROUP, "group" },
- { SHUFFLE_INVALID, "" }
-};
-
-static bt_player_settinngs_t player_status[] = {
- { STATUS_STOPPED, "stopped" },
- { STATUS_PLAYING, "playing" },
- { STATUS_PAUSED, "paused" },
- { STATUS_FORWARD_SEEK, "forward-seek" },
- { STATUS_REVERSE_SEEK, "reverse-seek" },
- { STATUS_ERROR, "error" },
- { STATUS_INVALID, "" }
-};
-
-static guint avrcp_reg_id = 0;
-
-/* Introspection data exposed from bt-service */
-static const gchar bt_avrcp_bluez_introspection_xml[] =
-"<node name='/'>"
-" <interface name='org.freedesktop.DBus.Properties'>"
-" <method name='Set'>"
-" <arg type='s' name='interface' direction='in'/>"
-" <arg type='s' name='property' direction='in'/>"
-" <arg type='v' name='value' direction='in'/>"
-" </method>"
-" </interface>"
-"</node>";
-
-static gboolean __bt_media_emit_property_changed(GDBusConnection *connection,
- const char *path, const char *interface, const char *name,
- const GVariant *variant)
-{
- GVariantBuilder *builder = NULL;
- GError *error = NULL;
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- g_variant_builder_add(builder, "{sv}", name, variant);
-
- g_dbus_connection_emit_signal(connection, NULL, path,
- BT_PROPERTIES_INTERFACE,
- "PropertiesChanged",
- g_variant_new("(sa{sv})",
- interface, builder),
- &error);
-
- g_variant_builder_unref(builder);
- if (error) {
- BT_ERR("Could not Emit PropertiesChanged Signal: errCode[%x], message[%s]",
- error->code, error->message);
- g_clear_error(&error);
- return FALSE;
- }
-
- return TRUE;
-}
-
-static GQuark __bt_avrcp_error_quark(void)
-{
- static GQuark quark = 0;
-
- if (!quark)
- quark = g_quark_from_static_string("bt-avrcp");
-
- return quark;
-}
-
-static GError *__bt_avrcp_set_error(bt_avrcp_error_t error)
-{
- BT_ERR("error[%d]\n", error);
-
- switch (error) {
- case BT_AVRCP_ERROR_INVALID_PARAM:
- return g_error_new(BT_AVRCP_ERROR, error,
- BT_ERROR_INVALID_PARAM);
- case BT_AVRCP_ERROR_INVALID_INTERFACE:
- return g_error_new(BT_AVRCP_ERROR, error,
- BT_ERROR_INVALID_INTERFACE);
- case BT_AVRCP_ERROR_INTERNAL:
- default:
- return g_error_new(BT_AVRCP_ERROR, error,
- BT_ERROR_INTERNAL);
- }
-}
-
-static void __bt_avrcp_agent_method(GDBusConnection *connection,
- const gchar *sender,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *method_name,
- GVariant *parameters,
- GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- BT_DBG("+");
- BT_INFO("method %s", method_name);
- BT_INFO("object_path %s", object_path);
- int ret = BT_AVRCP_ERROR_NONE;
- GError *err = NULL;
- gboolean shuffle_status;
- guint32 status;
- gchar *interface = NULL;
- gchar *property = NULL;
- gchar *loop_status = NULL;
- GVariant *value = NULL;
-
- if (g_strcmp0(method_name, "Set") == 0) {
- g_variant_get(parameters, "(&s&sv)", &interface, &property,
- &value);
-
- if (g_strcmp0(interface, BT_MEDIA_PLAYER_INTERFACE) != 0) {
- ret = BT_AVRCP_ERROR_INVALID_INTERFACE;
- goto fail;
- }
- }
-
- if (value == NULL) {
- BT_ERR("value is NULL");
- goto fail;
- }
-
- BT_DBG("Property: %s\n", property);
- if (g_strcmp0(property, "Shuffle") == 0) {
-
- if (!g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
- BT_ERR("Error");
- ret = BT_AVRCP_ERROR_INVALID_PARAM;
- goto fail;
- }
-
- shuffle_status = g_variant_get_boolean(value);
- BT_DBG("Value: %s\n", shuffle_status ? "TRUE" : "FALSE");
- if (shuffle_status == TRUE)
- status = SHUFFLE_ALL_TRACK;
- else
- status = SHUFFLE_MODE_OFF;
-
- _bt_send_event(BT_AVRCP_EVENT,
- BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
- g_variant_new("(u)", status));
- } else if (g_strcmp0(property, "LoopStatus") == 0) {
-
- if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
- BT_ERR("Error");
- ret = BT_AVRCP_ERROR_INVALID_PARAM;
- goto fail;
- }
-
- loop_status = (gchar *)g_variant_get_string(value, NULL);
- BT_DBG("Value: %s\n", loop_status);
-
- if (g_strcmp0(loop_status, "Track") == 0)
- status = REPEAT_SINGLE_TRACK;
- else if (g_strcmp0(loop_status, "Playlist") == 0)
- status = REPEAT_ALL_TRACK;
- else if (g_strcmp0(loop_status, "None") == 0)
- status = REPEAT_MODE_OFF;
- else
- status = REPEAT_INVALID;
-
- _bt_send_event(BT_AVRCP_EVENT,
- BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
- g_variant_new("(u)", status));
- }
-
- BT_DBG("-");
- return;
-
-fail:
- if (value)
- g_variant_unref(value);
- err = __bt_avrcp_set_error(ret);
- g_dbus_method_invocation_return_gerror(invocation, err);
- g_clear_error(&err);
- BT_INFO("-");
-}
-
-static const GDBusInterfaceVTable method_table = {
- __bt_avrcp_agent_method,
- NULL,
- NULL,
-};
-
-static GDBusNodeInfo *__bt_avrcp_create_method_node_info
- (const gchar *introspection_data)
-{
- GError *err = NULL;
- GDBusNodeInfo *node_info = NULL;
-
- if (introspection_data == NULL)
- return NULL;
-
- node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
-
- if (err) {
- BT_ERR("Unable to create node: %s", err->message);
- g_clear_error(&err);
- }
-
- return node_info;
-}
-
-int _bt_register_media_player(void)
-{
- BT_DBG("+");
- GDBusConnection *g_conn;
- gchar *adapter_path;
- gboolean shuffle_status;
- gchar *path;
- GDBusNodeInfo *node_info;
- GDBusProxy *proxy;
- GVariantBuilder *builder;
- GVariant *ret;
- GError *error = NULL;
-
- media_player_settings_t player_settings = {0,};
-
- player_settings.repeat = REPEAT_MODE_OFF;
- player_settings.status = STATUS_STOPPED;
- player_settings.position = 0;
- shuffle_status = FALSE;
-
- g_conn = _bt_gdbus_get_system_gconn();
- retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- node_info = __bt_avrcp_create_method_node_info(
- bt_avrcp_bluez_introspection_xml);
- if (node_info == NULL)
- return BLUETOOTH_ERROR_INTERNAL;
-
- avrcp_reg_id = g_dbus_connection_register_object(g_conn,
- BT_MEDIA_OBJECT_PATH,
- node_info->interfaces[0],
- &method_table,
- NULL, NULL, &error);
- g_dbus_node_info_unref(node_info);
-
- if (avrcp_reg_id == 0) {
- BT_ERR("Failed to register: %s", error->message);
- g_clear_error(&error);
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- adapter_path = _bt_get_adapter_path();
- retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- proxy = g_dbus_proxy_new_sync(g_conn,
- G_DBUS_PROXY_FLAGS_NONE, NULL,
- BT_BLUEZ_NAME, adapter_path,
- BT_MEDIA_INTERFACE, NULL, &error);
- g_free(adapter_path);
-
- if (proxy == NULL) {
- BT_ERR("Unable to create proxy");
- if (error) {
- BT_ERR("Error: %s", error->message);
- g_clear_error(&error);
- }
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-
- g_variant_builder_add(builder, "{sv}", "LoopStatus",
- g_variant_new("s",
- loopstatus_settings[player_settings.repeat].property));
- BT_ERR("LoopStatus: %s", loopstatus_settings[player_settings.repeat].property);
-
- g_variant_builder_add(builder, "{sv}", "Shuffle",
- g_variant_new("b", shuffle_status));
-
- g_variant_builder_add(builder, "{sv}", "PlaybackStatus",
- g_variant_new("s",
- player_status[player_settings.status].property));
- BT_ERR("PlaybackStatus: %s", player_status[player_settings.status].property);
-
- g_variant_builder_add(builder, "{sv}", "Position",
- g_variant_new("u", player_settings.position));
-
- path = g_strdup(BT_MEDIA_OBJECT_PATH);
- ret = g_dbus_proxy_call_sync(proxy, "RegisterPlayer",
- g_variant_new("(oa{sv})", path, builder),
- G_DBUS_CALL_FLAGS_NONE, -1,
- NULL, &error);
-
- g_object_unref(proxy);
- g_free(path);
- g_variant_builder_unref(builder);
-
- if (ret == NULL) {
- BT_ERR("Call RegisterPlayer Failed");
- if (error) {
- BT_ERR("errCode[%x], message[%s]",
- error->code, error->message);
- g_clear_error(&error);
- }
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- g_variant_unref(ret);
- return BLUETOOTH_ERROR_NONE;
-}
-
-static void __bt_avrcp_unregister_object_path(void)
-{
- GDBusConnection *g_conn;
-
- g_conn = _bt_gdbus_get_system_gconn();
- ret_if(g_conn == NULL);
-
- if (avrcp_reg_id > 0) {
- g_dbus_connection_unregister_object(g_conn,
- avrcp_reg_id);
- avrcp_reg_id = 0;
- }
-}
-
-int _bt_unregister_media_player(void)
-{
- BT_DBG("+");
- GDBusConnection *g_conn;
- GDBusProxy *proxy;
- gchar *adapter_path;
- GVariant *ret;
- GError *error = NULL;
- gchar *path;
- int result = BLUETOOTH_ERROR_NONE;
-
- adapter_path = _bt_get_adapter_path();
- if (adapter_path == NULL) {
- result = BLUETOOTH_ERROR_INTERNAL;
- goto FAIL;
- }
-
- g_conn = _bt_gdbus_get_system_gconn();
- if (g_conn == NULL) {
- BT_ERR("g_conn is NULL");
- g_free(adapter_path);
- result = BLUETOOTH_ERROR_INTERNAL;
- goto FAIL;
- }
-
- proxy = g_dbus_proxy_new_sync(g_conn,
- G_DBUS_PROXY_FLAGS_NONE, NULL,
- BT_BLUEZ_NAME, adapter_path,
- BT_MEDIA_INTERFACE, NULL, &error);
- g_free(adapter_path);
-
- if (proxy == NULL) {
- BT_ERR("Unable to create proxy");
- if (error) {
- BT_ERR("Error: %s", error->message);
- g_clear_error(&error);
- }
- result = BLUETOOTH_ERROR_INTERNAL;
- goto FAIL;
- }
-
- path = g_strdup(BT_MEDIA_OBJECT_PATH);
- BT_DBG("path is [%s]", path);
-
- ret = g_dbus_proxy_call_sync(proxy, "UnregisterPlayer",
- g_variant_new("(o)", path),
- G_DBUS_CALL_FLAGS_NONE, -1,
- NULL, &error);
- g_free(path);
- g_object_unref(proxy);
-
- if (ret == NULL) {
- BT_ERR("UnregisterPlayer failed");
- if (error) {
- BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
- error->code, error->message);
- g_clear_error(&error);
- }
- result = BLUETOOTH_ERROR_INTERNAL;
- }
- g_variant_unref(ret);
-
-FAIL:
- __bt_avrcp_unregister_object_path();
-
- BT_DBG("-");
- return result;
-}
-#if 0
-int _bt_avrcp_set_track_info(media_metadata_attributes_t *meta_data)
-{
- BT_DBG("+");
- char *interface = BT_MEDIA_PLAYER_INTERFACE;
- GDBusConnection *g_conn;
- GError *error = NULL;
- GVariantBuilder *builder = NULL;
- GVariantBuilder *inner_builder = NULL;
- GVariant *children[1];
- gboolean ret;
-
- retv_if(meta_data == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- g_conn = _bt_gdbus_get_system_gconn();;
- retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- inner_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:title", g_variant_new_string(meta_data->title));
-
- children[0] = g_variant_new_string(meta_data->artist);
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:artist", g_variant_new_array(G_VARIANT_TYPE_STRING,
- children, 1));
-
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:album", g_variant_new_string(meta_data->album));
-
- children[0] = g_variant_new_string(meta_data->genre);
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:genre", g_variant_new_array(G_VARIANT_TYPE_STRING,
- children, 1));
-
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:totalTracks", g_variant_new_int32(meta_data->total_tracks));
-
- g_variant_builder_add(inner_builder, "{sv}",
- "xesam:trackNumber", g_variant_new_int32(meta_data->number));
-
- g_variant_builder_add(inner_builder, "{sv}",
- "mpris:length", g_variant_new_int64(meta_data->duration));
-
- g_variant_builder_add(builder, "{sv}",
- "Metadata", g_variant_new("a{sv}", inner_builder));
-
- ret = g_dbus_connection_emit_signal(g_conn, NULL, BT_MEDIA_OBJECT_PATH,
- BT_PROPERTIES_INTERFACE,
- "PropertiesChanged",
- g_variant_new("(sa{sv})",
- interface, builder),
- &error);
-
- g_variant_builder_unref(inner_builder);
- g_variant_builder_unref(builder);
-
- if (!ret) {
- if (error != NULL) {
- BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
- error->code, error->message);
- g_clear_error(&error);
- }
- }
-
- BT_DBG("-");
- return BLUETOOTH_ERROR_NONE;
-}
-#endif
-int _bt_avrcp_set_interal_property(int type, media_player_settings_t *properties)
-{
- BT_DBG("+");
- GDBusConnection *g_conn;
- int value;
- media_metadata_attributes_t meta_data;
- gboolean shuffle;
- GVariantBuilder *builder = NULL;
- GVariant *children[1];
-
- g_conn = _bt_gdbus_get_system_gconn();;
- retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- switch (type) {
- case REPEAT:
- value = properties->repeat;
- if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
- BT_MEDIA_PLAYER_INTERFACE, "LoopStatus",
- g_variant_new_string(loopstatus_settings[value].property))) {
- BT_ERR("Error sending the PropertyChanged signal \n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
- break;
- case SHUFFLE:
- value = properties->shuffle;
- if (g_strcmp0(shuffle_settings[value].property, "off") == 0)
- shuffle = FALSE;
- else
- shuffle = TRUE;
-
- if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
- BT_MEDIA_PLAYER_INTERFACE, "Shuffle",
- g_variant_new_boolean(shuffle))) {
- BT_ERR("Error sending the PropertyChanged signal \n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
- break;
- case STATUS:
- value = properties->status;
- if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
- BT_MEDIA_PLAYER_INTERFACE, "PlaybackStatus",
- g_variant_new_string(player_status[value].property))) {
- BT_ERR("Error sending the PropertyChanged signal \n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
- break;
- case POSITION:
- value = properties->position;
- if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
- BT_MEDIA_PLAYER_INTERFACE, "Position",
- g_variant_new_uint32(value))) {
- BT_ERR("Error sending the PropertyChanged signal \n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
- break;
- case METADATA:
- meta_data = properties->metadata;
-
- builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- g_variant_builder_add(builder, "{sv}",
- "xesam:title", g_variant_new_string(meta_data.title));
-
- children[0] = g_variant_new_string(meta_data.artist);
- g_variant_builder_add(builder, "{sv}",
- "xesam:artist", g_variant_new_array(G_VARIANT_TYPE_STRING,
- children, 1));
-
- g_variant_builder_add(builder, "{sv}",
- "xesam:album", g_variant_new_string(meta_data.album));
-
- children[0] = g_variant_new_string(meta_data.genre);
- g_variant_builder_add(builder, "{sv}",
- "xesam:genre", g_variant_new_array(G_VARIANT_TYPE_STRING,
- children, 1));
-
- g_variant_builder_add(builder, "{sv}",
- "xesam:totalTracks", g_variant_new_int32(meta_data.total_tracks));
-
- g_variant_builder_add(builder, "{sv}",
- "xesam:trackNumber", g_variant_new_int32(meta_data.number));
-
- g_variant_builder_add(builder, "{sv}",
- "mpris:length", g_variant_new_int64(meta_data.duration));
-
- if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
- BT_MEDIA_PLAYER_INTERFACE, "Metadata",
- g_variant_new("a{sv}", builder))) {
- BT_ERR("Error sending the PropertyChanged signal \n");
- g_variant_builder_unref(builder);
- return BLUETOOTH_ERROR_INTERNAL;
- }
- g_variant_builder_unref(builder);
- break;
- default:
- BT_ERR("Invalid Type\n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
- BT_DBG("-");
- return BLUETOOTH_ERROR_NONE;
-}
-#if 0
-int _bt_avrcp_set_properties(media_player_settings_t *properties)
-{
- BT_DBG("+");
-
- if (_bt_avrcp_set_interal_property(REPEAT,
- properties) != BLUETOOTH_ERROR_NONE) {
- return BLUETOOTH_ERROR_INTERNAL;
- }
- if (_bt_avrcp_set_interal_property(SHUFFLE,
- properties) != BLUETOOTH_ERROR_NONE) {
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- if (_bt_avrcp_set_interal_property(STATUS,
- properties) != BLUETOOTH_ERROR_NONE) {
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- if (_bt_avrcp_set_interal_property(POSITION,
- properties) != BLUETOOTH_ERROR_NONE) {
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- if (_bt_avrcp_set_interal_property(METADATA,
- properties) != BLUETOOTH_ERROR_NONE) {
- return BLUETOOTH_ERROR_INTERNAL;
- }
- BT_DBG("-");
- return BLUETOOTH_ERROR_NONE;
-}
-
-int _bt_avrcp_set_property(int type, unsigned int value)
-{
- BT_DBG("+");
- media_player_settings_t properties;
-
- switch (type) {
- case REPEAT:
- properties.repeat = value;
- break;
- case SHUFFLE:
- properties.shuffle = value;
- break;
- case STATUS:
- properties.status = value;
- break;
- case POSITION:
- properties.position = value;
- break;
- default:
- BT_DBG("Invalid Type\n");
- return BLUETOOTH_ERROR_INTERNAL;
- }
-
- if (_bt_avrcp_set_interal_property(type,
- &properties) != BLUETOOTH_ERROR_NONE)
- return BLUETOOTH_ERROR_INTERNAL;
-
- BT_DBG("-");
-
- return BLUETOOTH_ERROR_NONE;
-}
-#endif
-
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-
-#ifndef _BT_SERVICE_AUDIO_H_
-#define _BT_SERVICE_AUDIO_H_
-
-#include <glib.h>
-#include <sys/types.h>
-#include "bluetooth-api.h"
-#include "bluetooth-audio-api.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
- int req_id;
- int type;
- int disconnection_type;
- char *address;
- gboolean ag_flag;
-} bt_headset_wait_t;
-
-typedef struct {
- int key;
- const char *property;
-} bt_player_settinngs_t;
-
-typedef enum {
- BT_PENDING_NONE = 0x00,
- BT_PENDING_CONNECT,
- BT_PENDING_DISCONNECT
-} bt_pending_request_t;
-
-typedef struct {
- int req_id;
- char *address;
- bt_pending_request_t pending;
- int type;
-} bt_audio_function_data_t;
-
-typedef enum {
- BT_AUDIO_HSP = 0x01,
- BT_AUDIO_A2DP,
- BT_AUDIO_ALL,
- BT_AVRCP,
- BT_AUDIO_A2DP_SOURCE,
- BT_AVRCP_TARGET
-} bt_audio_type_t;
-
-typedef enum {
- BT_STATE_NONE = 0x00,
- BT_STATE_CONNECTING,
- BT_STATE_CONNECTED,
- BT_STATE_DISCONNECTING,
- BT_STATE_DISCONNECTED
-} bt_headset_device_state_t;
-
-#define BT_CONTENT_PROTECTION_PATH "/org/tizen/bluetooth/a2dpcontentprotection"
-#define BT_CONTENT_PROTECTION_INTERFACE "org.tizen.bluetooth.A2dpContentProtection"
-
-#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
-#define BT_AUTO_CONNECT_TIMEOUT_AFTER_BT_ACTIVATED 2 /* 2 sec */
-#define BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS 30 /* 30 sec */
-#define BT_AUTO_CONNECT_TIMEOUT_RETRY_TIME 3600 /* 60 minute */
-#endif
-
-typedef enum {
- BLUETOOTH_A2DP_SOURCE,
- BLUETOOTH_A2DP_SINK,
-} bluetooth_audio_role_t;
-
-int _bt_audio_select_role(bluetooth_audio_role_t role);
-
-int _bt_audio_connect(int request_id, int type,
- bluetooth_device_address_t *device_address,
- GArray *out_param1);
-
-int _bt_audio_disconnect(int request_id, int type,
- bluetooth_device_address_t *device_address,
- GArray *out_param1);
-
-int _bt_hf_connect(int request_id,
- bluetooth_device_address_t *device_address,
- GArray *out_param1);
-
-int _bt_hf_disconnect(int request_id,
- bluetooth_device_address_t *device_address,
- GArray *out_param1);
-
-int _bt_audio_get_speaker_gain(unsigned int *gain);
-
-int _bt_audio_set_speaker_gain(unsigned int gain);
-
-int _bt_audio_set_content_protect(gboolean status);
-
-void _bt_set_audio_wait_data_flag(gboolean flag);
-
-bt_headset_wait_t *_bt_get_audio_wait_data(void);
-
-void _bt_rel_wait_data(void);
-
-void _bt_add_headset_to_list(int type, int status, const char *address);
-
-void _bt_remove_headset_from_list(int type, const char *address);
-
-gboolean _bt_is_headset_type_connected(int type, char *address);
-#ifdef TIZEN_BT_DUAL_HEADSET_CONNECT
-void _bt_check_already_connected_headset(int type, char *address);
-#endif
-void _bt_remove_from_connected_list(const char *address);
-
-int _bt_get_device_state_from_list(int type, const char *address);
-
-void _bt_remove_from_connected_list(const char *address);
-
-void _bt_audio_check_pending_connect();
-
-gboolean _bt_is_service_connected(char *address, int type);
-
-#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
-int _bt_audio_start_auto_connect(gboolean linkloss_flag);
-
-int _bt_audio_stop_auto_connect(void);
-
-void _bt_audio_set_auto_connect_device_addr(const char *address);
-#endif
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /*_BT_SERVICE_AUDIO_H_*/
-
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-
-#ifndef _BT_SERVICE_AVRCP_H_
-#define _BT_SERVICE_AVRCP_H_
-
-#include <glib.h>
-#include <sys/types.h>
-
-#include "bluetooth-api.h"
-#include "bluetooth-media-control.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define BT_MEDIA_OBJECT_PATH "/Musicplayer"
-
-#define BT_AVRCP_ERROR (__bt_avrcp_error_quark())
-
-#define BT_ERROR_INTERNAL "InternalError"
-#define BT_ERROR_INVALID_PARAM "InvalidParameters"
-#define BT_ERROR_INVALID_INTERFACE "InvalidInterface"
-
-typedef enum {
- BT_AVRCP_ERROR_NONE,
- BT_AVRCP_ERROR_INTERNAL,
- BT_AVRCP_ERROR_INVALID_PARAM,
- BT_AVRCP_ERROR_NOT_SUPPORTED,
- BT_AVRCP_ERROR_INVALID_INTERFACE
-} bt_avrcp_error_t;
-
-int _bt_register_media_player(void);
-
-int _bt_unregister_media_player(void);
-
-int _bt_avrcp_set_track_info(media_metadata_attributes_t *meta_data);
-
-int _bt_avrcp_set_properties(media_player_settings_t *properties);
-
-int _bt_avrcp_set_property(int type, unsigned int value);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /*_BT_SERVICE_AVRCP_H_*/
-
%if %{bt_bluez_hal} == ENABLED
export BT_INCLUDE_OAL_BLUEZ=ENABLED
export CFLAGS="$CFLAGS -DTIZEN_BT_INCLUDE_OAL_BLUEZ"
-export CFLAGS="$CFLAGS -DTIZEN_SYSPOPUP_SUPPORTED"
%else
export BT_INCLUDE_OAL_BLUEZ=DISABLED
%endif
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff