blob: 94c45d92f18ad52f2962154bbc68d560a044d7b4 [file] [log] [blame]
/** @file
* @brief Bluetooth Media Control Client/Protocol implementation
*/
/*
* Copyright (c) 2019 - 2021 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/zephyr.h>
#include <zephyr/types.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/check.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/audio/mcc.h>
#include <zephyr/bluetooth/services/ots.h>
#include "../services/ots/ots_client_internal.h"
/* TODO: Temporarily copied here from media_proxy_internal.h - clean up */
/* Debug output of 48 bit Object ID value */
/* (Zephyr does not yet support debug output of more than 32 bit values.) */
/* Takes a text and a 64-bit integer as input */
#define BT_DBG_OBJ_ID(text, id64) \
do { \
if (IS_ENABLED(CONFIG_BT_DEBUG_MCS)) { \
char t[BT_OTS_OBJ_ID_STR_LEN]; \
(void)bt_ots_obj_id_to_str(id64, t, sizeof(t)); \
BT_DBG(text "0x%s", t); \
} \
} while (0)
#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_MCC)
#define LOG_MODULE_NAME bt_mcc
#include "common/log.h"
struct mcs_instance_t {
uint16_t start_handle;
uint16_t end_handle;
uint16_t player_name_handle;
#ifdef CONFIG_BT_MCC_OTS
uint16_t icon_obj_id_handle;
#endif /* CONFIG_BT_MCC_OTS */
uint16_t icon_url_handle;
uint16_t track_changed_handle;
uint16_t track_title_handle;
uint16_t track_duration_handle;
uint16_t track_position_handle;
uint16_t playback_speed_handle;
uint16_t seeking_speed_handle;
#ifdef CONFIG_BT_MCC_OTS
uint16_t segments_obj_id_handle;
uint16_t current_track_obj_id_handle;
uint16_t next_track_obj_id_handle;
uint16_t current_group_obj_id_handle;
uint16_t parent_group_obj_id_handle;
#endif /* CONFIG_BT_MCC_OTS */
uint16_t playing_order_handle;
uint16_t playing_orders_supported_handle;
uint16_t media_state_handle;
uint16_t cp_handle;
uint16_t opcodes_supported_handle;
#ifdef CONFIG_BT_MCC_OTS
uint16_t scp_handle;
uint16_t search_results_obj_id_handle;
#endif /* CONFIG_BT_MCC_OTS */
uint16_t content_control_id_handle;
struct bt_gatt_subscribe_params player_name_sub_params;
struct bt_gatt_subscribe_params track_changed_sub_params;
struct bt_gatt_subscribe_params track_title_sub_params;
struct bt_gatt_subscribe_params track_duration_sub_params;
struct bt_gatt_subscribe_params track_position_sub_params;
struct bt_gatt_subscribe_params playback_speed_sub_params;
struct bt_gatt_subscribe_params seeking_speed_sub_params;
#ifdef CONFIG_BT_MCC_OTS
struct bt_gatt_subscribe_params current_track_obj_sub_params;
struct bt_gatt_subscribe_params next_track_obj_sub_params;
struct bt_gatt_subscribe_params parent_group_obj_sub_params;
struct bt_gatt_subscribe_params current_group_obj_sub_params;
#endif /* CONFIG_BT_MCC_OTS */
struct bt_gatt_subscribe_params playing_order_sub_params;
struct bt_gatt_subscribe_params media_state_sub_params;
struct bt_gatt_subscribe_params cp_sub_params;
struct bt_gatt_subscribe_params opcodes_supported_sub_params;
#ifdef CONFIG_BT_MCC_OTS
struct bt_gatt_subscribe_params scp_sub_params;
struct bt_gatt_subscribe_params search_results_obj_sub_params;
#endif /* CONFIG_BT_MCC_OTS */
/* The write buffer is used for
* - track position (4 octets)
* - playback speed (1 octet)
* - playing order (1 octet)
* - the control point (5 octets)
* (1 octet opcode + optionally 4 octet param)
* (mpl_cmd.opcode + mpl_cmd.param)
* If the object transfer client is included, it is also used for
* - object IDs (6 octets - BT_OTS_OBJ_ID_SIZE) and
* - the search control point (64 octets - SEARCH_LEN_MAX)
*
* If there is no OTC, the largest is control point
* If OTC is included, the largest is the search control point
*/
#ifdef CONFIG_BT_MCC_OTS
char write_buf[SEARCH_LEN_MAX];
#else
/* Trick to be able to use sizeof on members of a struct type */
/* TODO: Rewrite the mpl_cmd to have the "use_param" parameter */
/* separately, and the opcode and param alone as a struct */
char write_buf[sizeof(((struct mpl_cmd *)0)->opcode) +
sizeof(((struct mpl_cmd *)0)->param)];
#endif /* CONFIG_BT_MCC_OTS */
struct bt_gatt_write_params write_params;
bool busy;
#ifdef CONFIG_BT_MCC_OTS
struct bt_ots_client otc;
#endif /* CONFIG_BT_MCC_OTS */
};
static struct bt_gatt_discover_params discover_params;
static struct bt_gatt_read_params read_params;
static struct mcs_instance_t *cur_mcs_inst;
static struct mcs_instance_t mcs_inst;
static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0);
static struct bt_mcc_cb *mcc_cb;
static bool subscribe_all;
#ifdef CONFIG_BT_MCC_OTS
NET_BUF_SIMPLE_DEFINE_STATIC(otc_obj_buf, CONFIG_BT_MCC_OTC_OBJ_BUF_SIZE);
static struct bt_ots_client_cb otc_cb;
#endif /* CONFIG_BT_MCC_OTS */
#ifdef CONFIG_BT_MCC_OTS
void on_obj_selected(struct bt_ots_client *otc_inst,
struct bt_conn *conn, int err);
void on_object_metadata(struct bt_ots_client *otc_inst,
struct bt_conn *conn, int err,
uint8_t metadata_read);
int on_icon_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete);
#endif /* CONFIG_BT_MCC_OTS */
static uint8_t mcc_read_player_name_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
char name[CONFIG_BT_MCC_MEDIA_PLAYER_NAME_MAX];
cur_mcs_inst->busy = false;
BT_DBG("err: 0x%02x, length: %d, data: %p", err, length, data);
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!data) {
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(data, length, "Player name read");
if (length >= sizeof(name)) {
length = sizeof(name) - 1;
}
(void)memcpy(&name, data, length);
name[length] = '\0';
BT_DBG("Player name: %s", name);
}
if (mcc_cb && mcc_cb->read_player_name) {
mcc_cb->read_player_name(conn, cb_err, name);
}
return BT_GATT_ITER_STOP;
}
#ifdef CONFIG_BT_MCC_OTS
static uint8_t mcc_read_icon_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
BT_DBG("err: 0x%02x, length: %d, data: %p", err, length, data);
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!pid) || (length != BT_OTS_OBJ_ID_SIZE)) {
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Icon Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Icon Object ID: ", id);
}
if (mcc_cb && mcc_cb->read_icon_obj_id) {
mcc_cb->read_icon_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
#endif /* CONFIG_BT_MCC_OTS */
static uint8_t mcc_read_icon_url_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
char url[CONFIG_BT_MCC_ICON_URL_MAX];
cur_mcs_inst->busy = false;
BT_DBG("err: 0x%02x, length: %d, data: %p", err, length, data);
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!data) {
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else if (length >= sizeof(url)) {
cb_err = BT_ATT_ERR_INSUFFICIENT_RESOURCES;
} else {
BT_HEXDUMP_DBG(data, length, "Icon URL");
(void)memcpy(&url, data, length);
url[length] = '\0';
BT_DBG("Icon URL: %s", url);
}
if (mcc_cb && mcc_cb->read_icon_url) {
mcc_cb->read_icon_url(conn, cb_err, url);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_track_title_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
char title[CONFIG_BT_MCC_TRACK_TITLE_MAX];
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!data) {
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(data, length, "Track title");
if (length >= sizeof(title)) {
/* If the description is too long; clip it. */
length = sizeof(title) - 1;
}
(void)memcpy(&title, data, length);
title[length] = '\0';
BT_DBG("Track title: %s", title);
}
if (mcc_cb && mcc_cb->read_track_title) {
mcc_cb->read_track_title(conn, cb_err, title);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_track_duration_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
int32_t dur = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(dur))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
dur = sys_get_le32((uint8_t *)data);
BT_DBG("Track duration: %d", dur);
BT_HEXDUMP_DBG(data, sizeof(int32_t), "Track duration");
}
if (mcc_cb && mcc_cb->read_track_duration) {
mcc_cb->read_track_duration(conn, cb_err, dur);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_track_position_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
int32_t pos = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(pos))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
pos = sys_get_le32((uint8_t *)data);
BT_DBG("Track position: %d", pos);
BT_HEXDUMP_DBG(data, sizeof(pos), "Track position");
}
if (mcc_cb && mcc_cb->read_track_position) {
mcc_cb->read_track_position(conn, cb_err, pos);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_track_position_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
int32_t pos = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != sizeof(pos)) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
pos = sys_get_le32((uint8_t *)params->data);
BT_DBG("Track position: %d", pos);
BT_HEXDUMP_DBG(params->data, sizeof(pos),
"Track position in callback");
}
if (mcc_cb && mcc_cb->set_track_position) {
mcc_cb->set_track_position(conn, cb_err, pos);
}
}
static uint8_t mcc_read_playback_speed_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
int8_t speed = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(speed))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
speed = *(int8_t *)data;
BT_DBG("Playback speed: %d", speed);
BT_HEXDUMP_DBG(data, sizeof(int8_t), "Playback speed");
}
if (mcc_cb && mcc_cb->read_playback_speed) {
mcc_cb->read_playback_speed(conn, cb_err, speed);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_playback_speed_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
int8_t speed = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != sizeof(speed)) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
speed = *(int8_t *)params->data;
BT_DBG("Playback_speed: %d", speed);
}
if (mcc_cb && mcc_cb->set_playback_speed) {
mcc_cb->set_playback_speed(conn, cb_err, speed);
}
}
static uint8_t mcc_read_seeking_speed_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
int8_t speed = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(speed))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
speed = *(int8_t *)data;
BT_DBG("Seeking speed: %d", speed);
BT_HEXDUMP_DBG(data, sizeof(int8_t), "Seeking speed");
}
if (mcc_cb && mcc_cb->read_seeking_speed) {
mcc_cb->read_seeking_speed(conn, cb_err, speed);
}
return BT_GATT_ITER_STOP;
}
#ifdef CONFIG_BT_MCC_OTS
static uint8_t mcc_read_segments_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
cb_err = err;
} else if ((!pid) || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Segments Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Segments Object ID: ", id);
cb_err = 0;
}
if (mcc_cb && mcc_cb->read_segments_obj_id) {
mcc_cb->read_segments_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_current_track_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
cb_err = err;
} else if ((!pid) || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Current Track Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Current Track Object ID: ", id);
cb_err = 0;
}
if (mcc_cb && mcc_cb->read_current_track_obj_id) {
mcc_cb->read_current_track_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_current_track_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
uint64_t obj_id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != BT_OTS_OBJ_ID_SIZE) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
obj_id = sys_get_le48((const uint8_t *)params->data);
BT_DBG_OBJ_ID("Object ID: ", obj_id);
}
if (mcc_cb && mcc_cb->set_current_track_obj_id) {
mcc_cb->set_current_track_obj_id(conn, cb_err, obj_id);
}
}
static uint8_t mcc_read_next_track_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (length == 0) {
BT_DBG("Characteristic is empty");
} else if (!pid || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Next Track Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Next Track Object ID: ", id);
}
if (mcc_cb && mcc_cb->read_next_track_obj_id) {
mcc_cb->read_next_track_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_next_track_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
uint64_t obj_id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != BT_OTS_OBJ_ID_SIZE) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
obj_id = sys_get_le48((const uint8_t *)params->data);
BT_DBG_OBJ_ID("Object ID: ", obj_id);
}
if (mcc_cb && mcc_cb->set_next_track_obj_id) {
mcc_cb->set_next_track_obj_id(conn, cb_err, obj_id);
}
}
static uint8_t mcc_read_parent_group_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!pid || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Parent Group Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Parent Group Object ID: ", id);
}
if (mcc_cb && mcc_cb->read_parent_group_obj_id) {
mcc_cb->read_parent_group_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_current_group_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!pid || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
BT_HEXDUMP_DBG(pid, length, "Current Group Object ID");
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Current Group Object ID: ", id);
}
if (mcc_cb && mcc_cb->read_current_group_obj_id) {
mcc_cb->read_current_group_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_current_group_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
uint64_t obj_id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != BT_OTS_OBJ_ID_SIZE) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
obj_id = sys_get_le48((const uint8_t *)params->data);
BT_DBG_OBJ_ID("Object ID: ", obj_id);
}
if (mcc_cb && mcc_cb->set_current_group_obj_id) {
mcc_cb->set_current_group_obj_id(conn, cb_err, obj_id);
}
}
#endif /* CONFIG_BT_MCC_OTS */
static uint8_t mcc_read_playing_order_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t order = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(order))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
order = *(uint8_t *)data;
BT_DBG("Playing order: %d", order);
BT_HEXDUMP_DBG(data, sizeof(order), "Playing order");
}
if (mcc_cb && mcc_cb->read_playing_order) {
mcc_cb->read_playing_order(conn, cb_err, order);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_playing_order_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
uint8_t order = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data || params->length != sizeof(order)) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
order = *(uint8_t *)params->data;
BT_DBG("Playing order: %d", *(uint8_t *)params->data);
}
if (mcc_cb && mcc_cb->set_playing_order) {
mcc_cb->set_playing_order(conn, cb_err, order);
}
}
static uint8_t mcc_read_playing_orders_supported_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint16_t orders = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!data || length != sizeof(orders)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
orders = sys_get_le16((uint8_t *)data);
BT_DBG("Playing orders_supported: %d", orders);
BT_HEXDUMP_DBG(data, sizeof(orders), "Playing orders supported");
}
if (mcc_cb && mcc_cb->read_playing_orders_supported) {
mcc_cb->read_playing_orders_supported(conn, cb_err, orders);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcc_read_media_state_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t state = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!data || length != sizeof(state)) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
state = *(uint8_t *)data;
BT_DBG("Media state: %d", state);
BT_HEXDUMP_DBG(data, sizeof(uint8_t), "Media state");
}
if (mcc_cb && mcc_cb->read_media_state) {
mcc_cb->read_media_state(conn, cb_err, state);
}
return BT_GATT_ITER_STOP;
}
static void mcs_write_cp_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
struct mpl_cmd cmd = {0};
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data ||
(params->length != sizeof(cmd.opcode) &&
params->length != sizeof(cmd.opcode) + sizeof(cmd.param))) {
/* Above: No data pointer, or length not equal to any of the */
/* two possible values */
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
(void)memcpy(&cmd.opcode, params->data, sizeof(cmd.opcode));
if (params->length == sizeof(cmd.opcode) + sizeof(cmd.param)) {
(void)memcpy(&cmd.param,
(char *)(params->data) + sizeof(cmd.opcode),
sizeof(cmd.param));
cmd.use_param = true;
BT_DBG("Command in callback: %d, param: %d", cmd.opcode, cmd.param);
}
}
if (mcc_cb && mcc_cb->send_cmd) {
mcc_cb->send_cmd(conn, cb_err, &cmd);
}
}
static uint8_t mcc_read_opcodes_supported_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
int32_t operations = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(operations))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
operations = sys_get_le32((uint8_t *)data);
BT_DBG("Opcodes supported: %d", operations);
BT_HEXDUMP_DBG(data, sizeof(operations), "Opcodes_supported");
}
if (mcc_cb && mcc_cb->read_opcodes_supported) {
mcc_cb->read_opcodes_supported(conn, cb_err, operations);
}
return BT_GATT_ITER_STOP;
}
#ifdef CONFIG_BT_MCC_OTS
static void mcs_write_scp_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_write_params *params)
{
int cb_err = err;
struct mpl_search search = {0};
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (!params->data ||
(params->length > SEARCH_LEN_MAX)) {
BT_DBG("length: %d, data: %p", params->length, params->data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
search.len = params->length;
(void)memcpy(search.search, params->data, params->length);
BT_DBG("Length of returned value in callback: %d", search.len);
}
if (mcc_cb && mcc_cb->send_search) {
mcc_cb->send_search(conn, cb_err, &search);
}
}
static uint8_t mcc_read_search_results_obj_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t *pid = (uint8_t *)data;
uint64_t id = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if (length == 0) {
/* OK - this characteristic may be zero length */
/* cb_err and id already have correct values */
BT_DBG("Zero-length Search Results Object ID");
} else if (!pid || (length != BT_OTS_OBJ_ID_SIZE)) {
BT_DBG("length: %d, pid: %p", length, pid);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
id = sys_get_le48(pid);
BT_DBG_OBJ_ID("Search Results Object ID: ", id);
}
if (mcc_cb && mcc_cb->read_search_results_obj_id) {
mcc_cb->read_search_results_obj_id(conn, cb_err, id);
}
return BT_GATT_ITER_STOP;
}
#endif /* CONFIG_BT_MCC_OTS */
static uint8_t mcc_read_content_control_id_cb(struct bt_conn *conn, uint8_t err,
struct bt_gatt_read_params *params,
const void *data, uint16_t length)
{
int cb_err = err;
uint8_t ccid = 0;
cur_mcs_inst->busy = false;
if (err) {
BT_DBG("err: 0x%02x", err);
} else if ((!data) || (length != sizeof(ccid))) {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
} else {
ccid = *(uint8_t *)data;
BT_DBG("Content control ID: %d", ccid);
}
if (mcc_cb && mcc_cb->read_content_control_id) {
mcc_cb->read_content_control_id(conn, cb_err, ccid);
}
return BT_GATT_ITER_STOP;
}
static uint8_t mcs_notify_handler(struct bt_conn *conn,
struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length)
{
uint16_t handle = params->value_handle;
if (conn == NULL) {
return BT_GATT_ITER_CONTINUE;
}
BT_DBG("Notification, handle: %d", handle);
if (data) {
if (handle == cur_mcs_inst->player_name_handle) {
BT_DBG("Player Name notification");
mcc_read_player_name_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->track_changed_handle) {
/* The Track Changed characteristic can only be */
/* notified, so that is handled directly here */
int cb_err = 0;
BT_DBG("Track Changed notification");
BT_DBG("data: %p, length: %u", data, length);
if (length != 0) {
BT_DBG("Non-zero length: %u", length);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
}
if (mcc_cb && mcc_cb->track_changed_ntf) {
mcc_cb->track_changed_ntf(conn, cb_err);
}
} else if (handle == cur_mcs_inst->track_title_handle) {
BT_DBG("Track Title notification");
mcc_read_track_title_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->track_duration_handle) {
BT_DBG("Track Duration notification");
mcc_read_track_duration_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->track_position_handle) {
BT_DBG("Track Position notification");
mcc_read_track_position_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->playback_speed_handle) {
BT_DBG("Playback Speed notification");
mcc_read_playback_speed_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->seeking_speed_handle) {
BT_DBG("Seeking Speed notification");
mcc_read_seeking_speed_cb(conn, 0, NULL, data, length);
#ifdef CONFIG_BT_MCC_OTS
} else if (handle == cur_mcs_inst->current_track_obj_id_handle) {
BT_DBG("Current Track notification");
mcc_read_current_track_obj_id_cb(conn, 0, NULL, data,
length);
} else if (handle == cur_mcs_inst->next_track_obj_id_handle) {
BT_DBG("Next Track notification");
mcc_read_next_track_obj_id_cb(conn, 0, NULL, data,
length);
} else if (handle == cur_mcs_inst->parent_group_obj_id_handle) {
BT_DBG("Parent Group notification");
mcc_read_parent_group_obj_id_cb(conn, 0, NULL, data,
length);
} else if (handle == cur_mcs_inst->current_group_obj_id_handle) {
BT_DBG("Current Group notification");
mcc_read_current_group_obj_id_cb(conn, 0, NULL, data,
length);
#endif /* CONFIG_BT_MCC_OTS */
} else if (handle == cur_mcs_inst->playing_order_handle) {
BT_DBG("Playing Order notification");
mcc_read_playing_order_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->media_state_handle) {
BT_DBG("Media State notification");
mcc_read_media_state_cb(conn, 0, NULL, data, length);
} else if (handle == cur_mcs_inst->cp_handle) {
/* The control point is is a special case - only */
/* writable and notifiable. Handle directly here. */
int cb_err = 0;
struct mpl_cmd_ntf ntf = {0};
BT_DBG("Control Point notification");
if (length == sizeof(ntf.requested_opcode) + sizeof(ntf.result_code)) {
ntf.requested_opcode = *(uint8_t *)data;
ntf.result_code = *((uint8_t *)data +
sizeof(ntf.requested_opcode));
BT_DBG("Command: %d, result: %d",
ntf.requested_opcode, ntf.result_code);
} else {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
}
if (mcc_cb && mcc_cb->cmd_ntf) {
mcc_cb->cmd_ntf(conn, cb_err, &ntf);
}
} else if (handle == cur_mcs_inst->opcodes_supported_handle) {
BT_DBG("Opcodes Supported notification");
mcc_read_opcodes_supported_cb(conn, 0, NULL, data,
length);
#ifdef CONFIG_BT_MCC_OTS
} else if (handle == cur_mcs_inst->scp_handle) {
/* The search control point is a special case - only */
/* writable and notifiable. Handle directly here. */
int cb_err = 0;
uint8_t result_code = 0;
BT_DBG("Search Control Point notification");
if (length == sizeof(result_code)) {
result_code = *(uint8_t *)data;
BT_DBG("Result: %d", result_code);
} else {
BT_DBG("length: %d, data: %p", length, data);
cb_err = BT_GATT_ERR(BT_ATT_ERR_INVALID_ATTRIBUTE_LEN);
}
if (mcc_cb && mcc_cb->search_ntf) {
mcc_cb->search_ntf(conn, cb_err, result_code);
}
} else if (handle == cur_mcs_inst->search_results_obj_id_handle) {
BT_DBG("Search Results notification");
mcc_read_search_results_obj_id_cb(conn, 0, NULL, data,
length);
#endif /* CONFIG_BT_MCC_OTS */
} else {
BT_DBG("Unknown handle: %d (0x%04X)", handle, handle);
}
}
return BT_GATT_ITER_CONTINUE;
}
/* Called when discovery is completed - successfully or with error */
static void discovery_complete(struct bt_conn *conn, int err)
{
BT_DBG("Discovery completed, err: %d", err);
/* TODO: Handle resets of instance, and re-discovery.
* For now, reset instance on error.
*/
if (err) {
cur_mcs_inst = NULL;
}
if (mcc_cb && mcc_cb->discover_mcs) {
mcc_cb->discover_mcs(conn, err);
}
}
#ifdef CONFIG_BT_MCC_OTS
static uint8_t discover_otc_char_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
int err = 0;
struct bt_gatt_chrc *chrc;
struct bt_gatt_subscribe_params *sub_params = NULL;
if (attr) {
/* Found an attribute */
BT_DBG("[ATTRIBUTE] handle 0x%04X", attr->handle);
if (params->type != BT_GATT_DISCOVER_CHARACTERISTIC) {
/* But it was not a characteristic - continue search */
return BT_GATT_ITER_CONTINUE;
}
/* We have found an attribute, and it is a characteristic */
/* Find out which attribute, and subscribe if we should */
chrc = (struct bt_gatt_chrc *)attr->user_data;
if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_FEATURE)) {
BT_DBG("OTS Features");
cur_mcs_inst->otc.feature_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_NAME)) {
BT_DBG("Object Name");
cur_mcs_inst->otc.obj_name_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_TYPE)) {
BT_DBG("Object Type");
cur_mcs_inst->otc.obj_type_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_SIZE)) {
BT_DBG("Object Size");
cur_mcs_inst->otc.obj_size_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_ID)) {
BT_DBG("Object ID");
cur_mcs_inst->otc.obj_id_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_PROPERTIES)) {
BT_DBG("Object properties %d", chrc->value_handle);
cur_mcs_inst->otc.obj_properties_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_ACTION_CP)) {
BT_DBG("Object Action Control Point");
cur_mcs_inst->otc.oacp_handle = chrc->value_handle;
sub_params = &cur_mcs_inst->otc.oacp_sub_params;
sub_params->disc_params = &cur_mcs_inst->otc.oacp_sub_disc_params;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_OTS_LIST_CP)) {
BT_DBG("Object List Control Point");
cur_mcs_inst->otc.olcp_handle = chrc->value_handle;
sub_params = &cur_mcs_inst->otc.olcp_sub_params;
sub_params->disc_params = &cur_mcs_inst->otc.olcp_sub_disc_params;
}
if (sub_params) {
/* With ccc_handle == 0 it will use auto discovery */
sub_params->ccc_handle = 0;
sub_params->end_handle = cur_mcs_inst->otc.end_handle;
sub_params->value = BT_GATT_CCC_INDICATE;
sub_params->value_handle = chrc->value_handle;
sub_params->notify = bt_ots_client_indicate_handler;
bt_gatt_subscribe(conn, sub_params);
}
return BT_GATT_ITER_CONTINUE;
}
/* No more attributes found */
cur_mcs_inst->otc.cb = &otc_cb;
bt_ots_client_register(&cur_mcs_inst->otc);
BT_DBG("Setup complete for included OTS");
(void)memset(params, 0, sizeof(*params));
discovery_complete(conn, err);
return BT_GATT_ITER_STOP;
}
#endif /* CONFIG_BT_MCC_OTS */
#ifdef CONFIG_BT_MCC_OTS
/* This function is called when an included service is found.
* The function will store the start and end handle for the service,
* and continue the search for more instances of included services.
* Lastly, it will start discovery of OTS characteristics.
*/
static uint8_t discover_include_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_gatt_include *include;
int err = 0;
if (attr) {
BT_DBG("[ATTRIBUTE] handle 0x%04X", attr->handle);
__ASSERT(params->type == BT_GATT_DISCOVER_INCLUDE,
"Wrong type");
/* We have found an included service */
include = (struct bt_gatt_include *)attr->user_data;
BT_DBG("Include UUID %s", bt_uuid_str(include->uuid));
if (bt_uuid_cmp(include->uuid, BT_UUID_OTS)) {
/* But it is not OTS - continue search */
BT_WARN("Included service is not OTS");
return BT_GATT_ITER_CONTINUE;
}
/* We have the included OTS service (MCS includes only one) */
BT_DBG("Discover include complete for GMCS: OTS");
cur_mcs_inst->otc.start_handle = include->start_handle;
cur_mcs_inst->otc.end_handle = include->end_handle;
(void)memset(params, 0, sizeof(*params));
/* Discover characteristics of the included OTS */
discover_params.start_handle = cur_mcs_inst->otc.start_handle;
discover_params.end_handle = cur_mcs_inst->otc.end_handle;
discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
discover_params.func = discover_otc_char_func;
BT_DBG("Start discovery of OTS characteristics");
err = bt_gatt_discover(conn, &discover_params);
if (err) {
BT_DBG("Discovery of OTS chars. failed");
discovery_complete(conn, err);
}
return BT_GATT_ITER_STOP;
}
BT_DBG("No included OTS found");
/* This is OK, the server may not support OTS. But in that case,
* discovery stops here.
*/
discovery_complete(conn, err);
return BT_GATT_ITER_STOP;
}
/* Start discovery of included services */
static void discover_included(struct bt_conn *conn)
{
int err;
discover_params.start_handle = cur_mcs_inst->start_handle;
discover_params.end_handle = cur_mcs_inst->end_handle;
discover_params.type = BT_GATT_DISCOVER_INCLUDE;
discover_params.func = discover_include_func;
BT_DBG("Start discovery of included services");
err = bt_gatt_discover(conn, &discover_params);
if (err) {
BT_DBG("Discovery of included service failed: %d", err);
discovery_complete(conn, err);
}
}
#endif /* CONFIG_BT_MCC_OTS */
static bool subscribe_next_mcs_char(struct bt_conn *conn);
/* This function will subscribe to GMCS CCCDs.
* After this, the function will start discovery of included services.
*/
static void subscribe_mcs_char_func(struct bt_conn *conn, uint8_t err,
struct bt_gatt_subscribe_params *params)
{
bool subscription_done;
if (err) {
BT_DBG("Subscription callback error: %u", err);
discovery_complete(conn, err);
return;
}
BT_DBG("Subscribed: value handle: %d, ccc handle: %d",
params->value_handle, params->ccc_handle);
/* Subscribe to next characteristic */
subscription_done = subscribe_next_mcs_char(conn);
if (subscription_done) {
#ifdef CONFIG_BT_MCC_OTS
/* Start discovery of included services to find OTS */
discover_included(conn);
#else
/* If OTS is not configured, discovery ends here */
discovery_complete(conn, 0);
#endif /* CONFIG_BT_MCC_OTS */
}
}
/* Subscribe to a characteristic - helper function */
static int do_subscribe(struct bt_conn *conn, uint16_t handle,
struct bt_gatt_subscribe_params *sub_params)
{
/* With ccc_handle == 0 it will use auto discovery */
sub_params->ccc_handle = 0;
sub_params->end_handle = cur_mcs_inst->end_handle;
sub_params->value = BT_GATT_CCC_NOTIFY;
sub_params->value_handle = handle;
sub_params->notify = mcs_notify_handler;
sub_params->subscribe = subscribe_mcs_char_func;
/* disc_params pointer is also used as subscription flag */
sub_params->disc_params = &discover_params;
BT_DBG("Subscring to handle %d", handle);
return bt_gatt_subscribe(conn, sub_params);
}
/* Subscribe to the next GMCS CCCD.
* @return true if there are no more characteristics to subscribe to
*/
static bool subscribe_next_mcs_char(struct bt_conn *conn)
{
struct bt_gatt_subscribe_params *sub_params = NULL;
int err = 0;
/* The characteristics may be in any order on the server, and
* not all of them may exist => need to check all.
* For each of the subscribable characteristics
* - check if we have a handle for it
* - check sub_params.disc_params pointer to see if we have
* already subscribed to it (set in do_subscribe() ).
*/
if (cur_mcs_inst->player_name_handle &&
cur_mcs_inst->player_name_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->player_name_sub_params;
err = do_subscribe(conn, cur_mcs_inst->player_name_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->track_changed_handle &&
cur_mcs_inst->track_changed_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->track_changed_sub_params;
err = do_subscribe(conn, cur_mcs_inst->track_changed_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->track_title_handle &&
cur_mcs_inst->track_title_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->track_title_sub_params;
err = do_subscribe(conn, cur_mcs_inst->track_title_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->track_duration_handle &&
cur_mcs_inst->track_duration_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->track_duration_sub_params;
err = do_subscribe(conn, cur_mcs_inst->track_duration_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->track_position_handle &&
cur_mcs_inst->track_position_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->track_position_sub_params;
err = do_subscribe(conn, cur_mcs_inst->track_position_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->playback_speed_handle &&
cur_mcs_inst->playback_speed_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->playback_speed_sub_params;
err = do_subscribe(conn, cur_mcs_inst->playback_speed_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->seeking_speed_handle &&
cur_mcs_inst->seeking_speed_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->seeking_speed_sub_params;
err = do_subscribe(conn, cur_mcs_inst->seeking_speed_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
#ifdef CONFIG_BT_MCC_OTS
if (cur_mcs_inst->current_track_obj_id_handle &&
cur_mcs_inst->current_track_obj_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->current_track_obj_sub_params;
err = do_subscribe(conn, cur_mcs_inst->current_track_obj_id_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->next_track_obj_id_handle &&
cur_mcs_inst->next_track_obj_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->next_track_obj_sub_params;
err = do_subscribe(conn, cur_mcs_inst->next_track_obj_id_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->parent_group_obj_id_handle &&
cur_mcs_inst->parent_group_obj_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->parent_group_obj_sub_params;
err = do_subscribe(conn, cur_mcs_inst->parent_group_obj_id_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->current_group_obj_id_handle &&
cur_mcs_inst->parent_group_obj_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->current_group_obj_sub_params;
err = do_subscribe(conn, cur_mcs_inst->current_group_obj_id_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
#endif /* CONFIG_BT_MCC_OTS */
if (cur_mcs_inst->playing_order_handle &&
cur_mcs_inst->playing_order_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->playing_order_sub_params;
err = do_subscribe(conn, cur_mcs_inst->playing_order_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->media_state_handle &&
cur_mcs_inst->media_state_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->media_state_sub_params;
err = do_subscribe(conn, cur_mcs_inst->media_state_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->cp_handle &&
cur_mcs_inst->cp_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->cp_sub_params;
err = do_subscribe(conn, cur_mcs_inst->cp_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->opcodes_supported_handle &&
cur_mcs_inst->opcodes_supported_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->opcodes_supported_sub_params;
err = do_subscribe(conn, cur_mcs_inst->opcodes_supported_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
#ifdef CONFIG_BT_MCC_OTS
if (cur_mcs_inst->scp_handle &&
cur_mcs_inst->scp_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->scp_sub_params;
err = do_subscribe(conn, cur_mcs_inst->scp_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
if (cur_mcs_inst->search_results_obj_id_handle &&
cur_mcs_inst->search_results_obj_sub_params.disc_params == NULL) {
sub_params = &cur_mcs_inst->search_results_obj_sub_params;
err = do_subscribe(conn, cur_mcs_inst->search_results_obj_id_handle, sub_params);
if (err) {
BT_DBG("Could not subscribe: %d", err);
discovery_complete(conn, err);
}
return false;
}
#endif /* CONFIG_BT_MCC_OTS */
/* If we have come here, there are no more characteristics to
* subscribe to, and we are done.
*/
return true;
}
/* This function is called when characteristics are found.
* The function will store handles to GMCS characteristics.
* After this, the function will start subscription to characteristics
*/
static uint8_t discover_mcs_char_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_gatt_chrc *chrc;
bool subscription_done = true;
if (attr) {
/* Found an attribute */
BT_DBG("[ATTRIBUTE] handle 0x%04X", attr->handle);
if (params->type != BT_GATT_DISCOVER_CHARACTERISTIC) {
/* But it was not a characteristic - continue search */
return BT_GATT_ITER_CONTINUE;
}
/* We have found an attribute, and it is a characteristic */
/* Find out which attribute, and subscribe if we should */
chrc = (struct bt_gatt_chrc *)attr->user_data;
if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_PLAYER_NAME)) {
BT_DBG("Player name, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->player_name_handle = chrc->value_handle;
/* Use discovery params pointer as subscription flag */
cur_mcs_inst->player_name_sub_params.disc_params = NULL;
#ifdef CONFIG_BT_MCC_OTS
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_ICON_OBJ_ID)) {
BT_DBG("Icon Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->icon_obj_id_handle = chrc->value_handle;
#endif /* CONFIG_BT_MCC_OTS */
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_ICON_URL)) {
BT_DBG("Icon URL, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->icon_url_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_TRACK_CHANGED)) {
BT_DBG("Track Changed, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->track_changed_handle = chrc->value_handle;
cur_mcs_inst->track_changed_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_TRACK_TITLE)) {
BT_DBG("Track Title, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->track_title_handle = chrc->value_handle;
cur_mcs_inst->track_title_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_TRACK_DURATION)) {
BT_DBG("Track Duration, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->track_duration_handle = chrc->value_handle;
cur_mcs_inst->track_duration_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_TRACK_POSITION)) {
BT_DBG("Track Position, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->track_position_handle = chrc->value_handle;
cur_mcs_inst->track_position_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_PLAYBACK_SPEED)) {
BT_DBG("Playback Speed, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->playback_speed_handle = chrc->value_handle;
cur_mcs_inst->playback_speed_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_SEEKING_SPEED)) {
BT_DBG("Seeking Speed, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->seeking_speed_handle = chrc->value_handle;
cur_mcs_inst->seeking_speed_sub_params.disc_params = NULL;
#ifdef CONFIG_BT_MCC_OTS
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_TRACK_SEGMENTS_OBJ_ID)) {
BT_DBG("Track Segments Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->segments_obj_id_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_CURRENT_TRACK_OBJ_ID)) {
BT_DBG("Current Track Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->current_track_obj_id_handle = chrc->value_handle;
cur_mcs_inst->current_track_obj_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_NEXT_TRACK_OBJ_ID)) {
BT_DBG("Next Track Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->next_track_obj_id_handle = chrc->value_handle;
cur_mcs_inst->next_track_obj_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_PARENT_GROUP_OBJ_ID)) {
BT_DBG("Parent Group Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->parent_group_obj_id_handle = chrc->value_handle;
cur_mcs_inst->parent_group_obj_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_CURRENT_GROUP_OBJ_ID)) {
BT_DBG("Group Object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->current_group_obj_id_handle = chrc->value_handle;
cur_mcs_inst->current_group_obj_sub_params.disc_params = NULL;
#endif /* CONFIG_BT_MCC_OTS */
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_PLAYING_ORDER)) {
BT_DBG("Playing Order, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->playing_order_handle = chrc->value_handle;
cur_mcs_inst->playing_order_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_PLAYING_ORDERS)) {
BT_DBG("Playing Orders supported, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->playing_orders_supported_handle = chrc->value_handle;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_MEDIA_STATE)) {
BT_DBG("Media State, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->media_state_handle = chrc->value_handle;
cur_mcs_inst->media_state_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_MEDIA_CONTROL_POINT)) {
BT_DBG("Media Control Point, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->cp_handle = chrc->value_handle;
cur_mcs_inst->cp_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_MEDIA_CONTROL_OPCODES)) {
BT_DBG("Media control opcodes supported, UUID: %s",
bt_uuid_str(chrc->uuid));
cur_mcs_inst->opcodes_supported_handle = chrc->value_handle;
cur_mcs_inst->opcodes_supported_sub_params.disc_params = NULL;
#ifdef CONFIG_BT_MCC_OTS
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_SEARCH_CONTROL_POINT)) {
BT_DBG("Search control point, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->scp_handle = chrc->value_handle;
cur_mcs_inst->scp_sub_params.disc_params = NULL;
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_MCS_SEARCH_RESULTS_OBJ_ID)) {
BT_DBG("Search Results object, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->search_results_obj_id_handle = chrc->value_handle;
cur_mcs_inst->search_results_obj_sub_params.disc_params = NULL;
#endif /* CONFIG_BT_MCC_OTS */
} else if (!bt_uuid_cmp(chrc->uuid, BT_UUID_CCID)) {
BT_DBG("Content Control ID, UUID: %s", bt_uuid_str(chrc->uuid));
cur_mcs_inst->content_control_id_handle = chrc->value_handle;
}
/* Continue to search for more attributes */
return BT_GATT_ITER_CONTINUE;
}
/* No more attributes found */
BT_DBG("GMCS characteristics found");
(void)memset(params, 0, sizeof(*params));
/* Either subscribe to characteristics, or continue to discovery of
*included services.
* Subscription is done after discovery, not in parallel with it,
* to avoid queuing many ATT requests that requires buffers.
*/
if (subscribe_all) {
subscription_done = subscribe_next_mcs_char(conn);
}
if (subscription_done) {
/* Not subscribing, or there was nothing to subscribe to */
#ifdef CONFIG_BT_MCC_OTS
/* Start discovery of included services to find OTS */
discover_included(conn);
#else
/* If OTS is not configured, discovery ends here */
discovery_complete(conn, 0);
#endif /* CONFIG_BT_MCC_OTS */
}
return BT_GATT_ITER_STOP;
}
/* This function is called when a (primary) GMCS service has been discovered.
* The function will store the start and end handle for the service. It will
* then start discovery of the characteristics of the GMCS service.
*/
static uint8_t discover_primary_func(struct bt_conn *conn,
const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params)
{
struct bt_gatt_service_val *prim_service;
if (attr) {
int err;
/* Found an attribute */
BT_DBG("[ATTRIBUTE] handle 0x%04X", attr->handle);
if (params->type != BT_GATT_DISCOVER_PRIMARY) {
/* But it was not a primary service - continue search */
BT_WARN("Unexpected parameters");
return BT_GATT_ITER_CONTINUE;
}
/* We have found an attribute, and it is a primary service */
/* (Must be GMCS, since that is the one we searched for.) */
BT_DBG("Primary discovery complete");
BT_DBG("UUID: %s", bt_uuid_str(attr->uuid));
prim_service = (struct bt_gatt_service_val *)attr->user_data;
BT_DBG("UUID: %s", bt_uuid_str(prim_service->uuid));
cur_mcs_inst = &mcs_inst;
cur_mcs_inst->start_handle = attr->handle + 1;
cur_mcs_inst->end_handle = prim_service->end_handle;
/* Start discovery of characteristics */
discover_params.uuid = NULL;
discover_params.start_handle = cur_mcs_inst->start_handle;
discover_params.end_handle = cur_mcs_inst->end_handle;
discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC;
discover_params.func = discover_mcs_char_func;
BT_DBG("Start discovery of GMCS characteristics");
err = bt_gatt_discover(conn, &discover_params);
if (err) {
BT_DBG("Discovery failed: %d", err);
discovery_complete(conn, err);
}
return BT_GATT_ITER_STOP;
}
/* No attribute of the searched for type found */
BT_DBG("Could not find an GMCS instance on the server");
cur_mcs_inst = NULL;
discovery_complete(conn, -ENODATA);
return BT_GATT_ITER_STOP;
}
int bt_mcc_init(struct bt_mcc_cb *cb)
{
mcc_cb = cb;
#ifdef CONFIG_BT_MCC_OTS
/* Set up the callbacks from OTC */
/* TODO: Have one single content callback. */
/* For now: Use the icon callback for content - it is the first, */
/* and this will anyway be reset later. */
otc_cb.obj_data_read = on_icon_content;
otc_cb.obj_selected = on_obj_selected;
otc_cb.obj_metadata_read = on_object_metadata;
BT_DBG("Object selected callback: %p", otc_cb.obj_selected);
BT_DBG("Object content callback: %p", otc_cb.obj_data_read);
BT_DBG("Object metadata callback: %p", otc_cb.obj_metadata_read);
#endif /* CONFIG_BT_MCC_OTS */
return 0;
}
/* Initiate discovery.
* Discovery is handled by a chain of functions, where each function does its
* part, and then initiates a further discovery, with a new callback function.
*
* The order of discovery is follows:
* 1: Discover GMCS primary service (started here)
* 2: Discover characteristics of GMCS
* 3: Subscribe to characteristics of GMCS
* 4: Discover OTS service included in GMCS
* 5: Discover characteristics of OTS and subscribe to them
*/
int bt_mcc_discover_mcs(struct bt_conn *conn, bool subscribe)
{
CHECKIF(!conn) {
return -EINVAL;
} else if (cur_mcs_inst) {
return -EBUSY;
}
subscribe_all = subscribe;
memset(&discover_params, 0, sizeof(discover_params));
memset(&mcs_inst, 0, sizeof(mcs_inst));
(void)memcpy(&uuid, BT_UUID_GMCS, sizeof(uuid));
discover_params.func = discover_primary_func;
discover_params.uuid = &uuid.uuid;
discover_params.type = BT_GATT_DISCOVER_PRIMARY;
discover_params.start_handle = BT_ATT_FIRST_ATTRIBUTE_HANDLE;
discover_params.end_handle = BT_ATT_LAST_ATTRIBUTE_HANDLE;
BT_DBG("start discovery of GMCS primary service");
return bt_gatt_discover(conn, &discover_params);
}
int bt_mcc_read_player_name(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->player_name_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_player_name_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->player_name_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#ifdef CONFIG_BT_MCC_OTS
int bt_mcc_read_icon_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->icon_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_icon_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->icon_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#endif /* CONFIG_BT_MCC_OTS */
int bt_mcc_read_icon_url(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->icon_url_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_icon_url_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->icon_url_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_track_title(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->track_title_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_track_title_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->track_title_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_track_duration(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->track_duration_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_track_duration_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->track_duration_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_track_position(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->track_position_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_track_position_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->track_position_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_track_position(struct bt_conn *conn, int32_t pos)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->track_position_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
(void)memcpy(cur_mcs_inst->write_buf, &pos, sizeof(pos));
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = sizeof(pos);
cur_mcs_inst->write_params.handle = cur_mcs_inst->track_position_handle;
cur_mcs_inst->write_params.func = mcs_write_track_position_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, sizeof(pos),
"Track position sent");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_playback_speed(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->playback_speed_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_playback_speed_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->playback_speed_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_playback_speed(struct bt_conn *conn, int8_t speed)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->playback_speed_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
(void)memcpy(cur_mcs_inst->write_buf, &speed, sizeof(speed));
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = sizeof(speed);
cur_mcs_inst->write_params.handle = cur_mcs_inst->playback_speed_handle;
cur_mcs_inst->write_params.func = mcs_write_playback_speed_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, sizeof(speed),
"Playback speed");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_seeking_speed(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->seeking_speed_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_seeking_speed_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->seeking_speed_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#ifdef CONFIG_BT_MCC_OTS
int bt_mcc_read_segments_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->segments_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_segments_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->segments_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_current_track_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->current_track_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_current_track_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->current_track_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_current_track_obj_id(struct bt_conn *conn, uint64_t obj_id)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
CHECKIF(obj_id < BT_OTS_OBJ_ID_MIN || obj_id > BT_OTS_OBJ_ID_MAX) {
BT_DBG("Object ID invalid");
return -EINVAL;
}
if (!cur_mcs_inst->current_track_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
sys_put_le48(obj_id, cur_mcs_inst->write_buf);
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = BT_OTS_OBJ_ID_SIZE;
cur_mcs_inst->write_params.handle = cur_mcs_inst->current_track_obj_id_handle;
cur_mcs_inst->write_params.func = mcs_write_current_track_obj_id_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, BT_OTS_OBJ_ID_SIZE, "Object Id");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_next_track_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->next_track_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_next_track_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->next_track_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_next_track_obj_id(struct bt_conn *conn, uint64_t obj_id)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
CHECKIF(obj_id < BT_OTS_OBJ_ID_MIN || obj_id > BT_OTS_OBJ_ID_MAX) {
BT_DBG("Object ID invalid");
return -EINVAL;
}
if (!cur_mcs_inst->next_track_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
sys_put_le48(obj_id, cur_mcs_inst->write_buf);
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = BT_OTS_OBJ_ID_SIZE;
cur_mcs_inst->write_params.handle = cur_mcs_inst->next_track_obj_id_handle;
cur_mcs_inst->write_params.func = mcs_write_next_track_obj_id_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, BT_OTS_OBJ_ID_SIZE, "Object Id");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_parent_group_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->parent_group_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_parent_group_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->parent_group_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_current_group_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->current_group_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_current_group_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->current_group_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_current_group_obj_id(struct bt_conn *conn, uint64_t obj_id)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
CHECKIF(obj_id < BT_OTS_OBJ_ID_MIN || obj_id > BT_OTS_OBJ_ID_MAX) {
BT_DBG("Object ID invalid");
return -EINVAL;
}
if (!cur_mcs_inst->current_group_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
sys_put_le48(obj_id, cur_mcs_inst->write_buf);
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = BT_OTS_OBJ_ID_SIZE;
cur_mcs_inst->write_params.handle = cur_mcs_inst->current_group_obj_id_handle;
cur_mcs_inst->write_params.func = mcs_write_current_group_obj_id_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, BT_OTS_OBJ_ID_SIZE, "Object Id");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#endif /* CONFIG_BT_MCC_OTS */
int bt_mcc_read_playing_order(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->playing_order_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_playing_order_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->playing_order_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_set_playing_order(struct bt_conn *conn, uint8_t order)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->playing_order_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
(void)memcpy(cur_mcs_inst->write_buf, &order, sizeof(order));
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = sizeof(order);
cur_mcs_inst->write_params.handle = cur_mcs_inst->playing_order_handle;
cur_mcs_inst->write_params.func = mcs_write_playing_order_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, sizeof(order),
"Playing order");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_playing_orders_supported(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->playing_orders_supported_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_playing_orders_supported_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->playing_orders_supported_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_media_state(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->media_state_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_media_state_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->media_state_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_send_cmd(struct bt_conn *conn, const struct mpl_cmd *cmd)
{
int err;
int length = sizeof(cmd->opcode);
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->cp_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
(void)memcpy(cur_mcs_inst->write_buf, &cmd->opcode, length);
if (cmd->use_param) {
length += sizeof(cmd->param);
(void)memcpy(&cur_mcs_inst->write_buf[sizeof(cmd->opcode)], &cmd->param,
sizeof(cmd->param));
}
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = length;
cur_mcs_inst->write_params.handle = cur_mcs_inst->cp_handle;
cur_mcs_inst->write_params.func = mcs_write_cp_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, sizeof(*cmd),
"Command sent");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_opcodes_supported(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->opcodes_supported_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_opcodes_supported_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->opcodes_supported_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#ifdef CONFIG_BT_MCC_OTS
int bt_mcc_send_search(struct bt_conn *conn, const struct mpl_search *search)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->scp_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
(void)memcpy(cur_mcs_inst->write_buf, &search->search, search->len);
cur_mcs_inst->write_params.offset = 0;
cur_mcs_inst->write_params.data = cur_mcs_inst->write_buf;
cur_mcs_inst->write_params.length = search->len;
cur_mcs_inst->write_params.handle = cur_mcs_inst->scp_handle;
cur_mcs_inst->write_params.func = mcs_write_scp_cb;
BT_HEXDUMP_DBG(cur_mcs_inst->write_params.data, search->len,
"Search sent");
err = bt_gatt_write(conn, &cur_mcs_inst->write_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
int bt_mcc_read_search_results_obj_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->search_results_obj_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_search_results_obj_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->search_results_obj_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#endif /* CONFIG_BT_MCC_OTS */
int bt_mcc_read_content_control_id(struct bt_conn *conn)
{
int err;
CHECKIF(!conn) {
return -EINVAL;
}
if (!cur_mcs_inst->content_control_id_handle) {
BT_DBG("Handle not set");
return -EINVAL;
} else if (cur_mcs_inst->busy) {
return -EBUSY;
}
read_params.func = mcc_read_content_control_id_cb;
read_params.handle_count = 1;
read_params.single.handle = cur_mcs_inst->content_control_id_handle;
read_params.single.offset = 0U;
err = bt_gatt_read(conn, &read_params);
if (!err) {
cur_mcs_inst->busy = true;
}
return err;
}
#ifdef CONFIG_BT_MCC_OTS
void on_obj_selected(struct bt_ots_client *otc_inst,
struct bt_conn *conn, int result)
{
BT_DBG("Current object selected");
/* TODO: Read metadata here? */
/* For now: Left to the application */
/* Only one object at a time is selected in OTS */
/* When the selected callback comes, a new object is selected */
/* Reset the object buffer */
net_buf_simple_reset(&otc_obj_buf);
if (mcc_cb && mcc_cb->otc_obj_selected) {
mcc_cb->otc_obj_selected(conn, OLCP_RESULT_TO_ERROR(result));
}
}
/* TODO: Merge the object callback functions into one */
/* Use a notion of the "active" object, as done in mpl.c, for tracking */
int on_icon_content(struct bt_ots_client *otc_inst, struct bt_conn *conn,
uint32_t offset, uint32_t len, uint8_t *data_p,
bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Media Player Icon content, %i bytes at offset %i",
len, offset);
BT_HEXDUMP_DBG(data_p, len, "Icon content");
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Icon object received");
if (mcc_cb && mcc_cb->otc_icon_object) {
mcc_cb->otc_icon_object(conn, cb_err, &otc_obj_buf);
}
/* Reset buf in case the same object is read again without */
/* calling select in between */
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
#if CONFIG_BT_DEBUG_MCC
struct track_seg_t {
uint8_t name_len;
char name[CONFIG_BT_MCC_SEGMENT_NAME_MAX];
int32_t pos;
};
struct track_segs_t {
uint16_t cnt;
struct track_seg_t segs[CONFIG_BT_MCC_TRACK_SEGS_MAX_CNT];
};
static void decode_track_segments(struct net_buf_simple *buff,
struct track_segs_t *track_segs)
{
uint16_t i;
struct track_seg_t *seg;
uint8_t *name;
struct net_buf_simple tmp_buf;
/* Copy the buf, to not consume the original in this debug function */
net_buf_simple_clone(buff, &tmp_buf);
while (tmp_buf.len &&
track_segs->cnt < CONFIG_BT_MCC_TRACK_SEGS_MAX_CNT) {
i = track_segs->cnt++;
seg = &track_segs->segs[i];
seg->name_len = net_buf_simple_pull_u8(&tmp_buf);
if (seg->name_len + sizeof(int32_t) > tmp_buf.len) {
BT_WARN("Segment too long");
return;
}
if (seg->name_len) {
name = net_buf_simple_pull_mem(&tmp_buf, seg->name_len);
if (seg->name_len >= CONFIG_BT_MCC_SEGMENT_NAME_MAX) {
seg->name_len =
CONFIG_BT_MCC_SEGMENT_NAME_MAX - 1;
}
(void)memcpy(seg->name, name, seg->name_len);
}
seg->name[seg->name_len] = '\0';
track_segs->segs[i].pos = (int32_t)net_buf_simple_pull_le32(&tmp_buf);
}
}
#endif /* CONFIG_BT_DEBUG_MCC */
int on_track_segments_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Track Segments content, %i bytes at offset %i",
len, offset);
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Track segment object received");
#if CONFIG_BT_DEBUG_MCC
struct track_segs_t track_segments;
track_segments.cnt = 0;
decode_track_segments(&otc_obj_buf, &track_segments);
for (int i = 0; i < track_segments.cnt; i++) {
BT_DBG("Track segment %i:", i);
BT_DBG("\t-Name\t:%s",
track_segments.segs[i].name);
BT_DBG("\t-Position\t:%d", track_segments.segs[i].pos);
}
#endif /* CONFIG_BT_DEBUG_MCC */
if (mcc_cb && mcc_cb->otc_track_segments_object) {
mcc_cb->otc_track_segments_object(conn,
cb_err, &otc_obj_buf);
}
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
int on_current_track_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Current Track content, %i bytes at offset %i",
len, offset);
BT_HEXDUMP_DBG(data_p, len, "Track content");
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Current Track Object received");
if (mcc_cb && mcc_cb->otc_current_track_object) {
mcc_cb->otc_current_track_object(conn, cb_err, &otc_obj_buf);
}
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
int on_next_track_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset, uint32_t len,
uint8_t *data_p, bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Next Track content, %i bytes at offset %i",
len, offset);
BT_HEXDUMP_DBG(data_p, len, "Track content");
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Next Track Object received");
if (mcc_cb && mcc_cb->otc_next_track_object) {
mcc_cb->otc_next_track_object(conn, cb_err, &otc_obj_buf);
}
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
#if CONFIG_BT_DEBUG_MCC
struct id_list_elem_t {
uint8_t type;
uint64_t id;
};
struct id_list_t {
struct id_list_elem_t ids[CONFIG_BT_MCC_GROUP_RECORDS_MAX];
uint16_t cnt;
};
static void decode_group(struct net_buf_simple *buff,
struct id_list_t *ids)
{
struct net_buf_simple tmp_buf;
/* Copy the buf, to not consume the original in this debug function */
net_buf_simple_clone(buff, &tmp_buf);
while ((tmp_buf.len) && (ids->cnt < CONFIG_BT_MCC_GROUP_RECORDS_MAX)) {
ids->ids[ids->cnt].type = net_buf_simple_pull_u8(&tmp_buf);
ids->ids[ids->cnt++].id = net_buf_simple_pull_le48(&tmp_buf);
}
}
#endif /* CONFIG_BT_DEBUG_MCC */
int on_parent_group_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Parent Group content, %i bytes at offset %i",
len, offset);
BT_HEXDUMP_DBG(data_p, len, "Group content");
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Parent Group object received");
#if CONFIG_BT_DEBUG_MCC
struct id_list_t group = {0};
decode_group(&otc_obj_buf, &group);
for (int i = 0; i < group.cnt; i++) {
char t[BT_OTS_OBJ_ID_STR_LEN];
(void)bt_ots_obj_id_to_str(group.ids[i].id, t,
BT_OTS_OBJ_ID_STR_LEN);
BT_DBG("Object type: %d, object ID: %s",
group.ids[i].type, t);
}
#endif /* CONFIG_BT_DEBUG_MCC */
if (mcc_cb && mcc_cb->otc_parent_group_object) {
mcc_cb->otc_parent_group_object(conn, cb_err, &otc_obj_buf);
}
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
int on_current_group_content(struct bt_ots_client *otc_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete)
{
int cb_err = 0;
BT_DBG("Received Current Group content, %i bytes at offset %i",
len, offset);
BT_HEXDUMP_DBG(data_p, len, "Group content");
if (len > net_buf_simple_tailroom(&otc_obj_buf)) {
BT_WARN("Can not fit whole object");
cb_err = -EMSGSIZE;
}
net_buf_simple_add_mem(&otc_obj_buf, data_p,
MIN(net_buf_simple_tailroom(&otc_obj_buf), len));
if (is_complete) {
BT_DBG("Current Group object received");
#if CONFIG_BT_DEBUG_MCC
struct id_list_t group = {0};
decode_group(&otc_obj_buf, &group);
for (int i = 0; i < group.cnt; i++) {
char t[BT_OTS_OBJ_ID_STR_LEN];
(void)bt_ots_obj_id_to_str(group.ids[i].id, t,
BT_OTS_OBJ_ID_STR_LEN);
BT_DBG("Object type: %d, object ID: %s",
group.ids[i].type, t);
}
#endif /* CONFIG_BT_DEBUG_MCC */
if (mcc_cb && mcc_cb->otc_current_group_object) {
mcc_cb->otc_current_group_object(conn, cb_err, &otc_obj_buf);
}
net_buf_simple_reset(&otc_obj_buf);
}
return BT_OTS_CONTINUE;
}
void on_object_metadata(struct bt_ots_client *otc_inst,
struct bt_conn *conn, int err,
uint8_t metadata_read)
{
BT_INFO("Object's meta data:");
BT_INFO("\tCurrent size\t:%u", otc_inst->cur_object.size.cur);
if (otc_inst->cur_object.size.cur > otc_obj_buf.size) {
BT_DBG("Object larger than allocated buffer");
}
bt_ots_metadata_display(&otc_inst->cur_object, 1);
if (mcc_cb && mcc_cb->otc_obj_metadata) {
mcc_cb->otc_obj_metadata(conn, err);
}
}
int bt_mcc_otc_read_object_metadata(struct bt_conn *conn)
{
int err;
err = bt_ots_client_read_object_metadata(&cur_mcs_inst->otc, conn,
BT_OTS_METADATA_REQ_ALL);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_icon_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
cur_mcs_inst->otc.cb->obj_data_read = on_icon_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_track_segments_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
/* TODO: Assumes object is already selected */
cur_mcs_inst->otc.cb->obj_data_read = on_track_segments_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_current_track_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
/* TODO: Assumes object is already selected */
cur_mcs_inst->otc.cb->obj_data_read = on_current_track_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_next_track_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
/* TODO: Assumes object is already selected */
cur_mcs_inst->otc.cb->obj_data_read = on_next_track_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_parent_group_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
/* TODO: Assumes object is already selected */
/* Reuse callback for current group */
cur_mcs_inst->otc.cb->obj_data_read = on_parent_group_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
int bt_mcc_otc_read_current_group_object(struct bt_conn *conn)
{
int err;
/* TODO: Add handling for busy - either MCS or OTS */
/* TODO: Assumes object is already selected */
cur_mcs_inst->otc.cb->obj_data_read = on_current_group_content;
err = bt_ots_client_read_object_data(&cur_mcs_inst->otc, conn);
if (err) {
BT_DBG("Error reading the object: %d", err);
}
return err;
}
#if defined(CONFIG_BT_MCC_SHELL)
struct bt_ots_client *bt_mcc_otc_inst(void)
{
return &cur_mcs_inst->otc;
}
#endif /* defined(CONFIG_BT_MCC_SHELL) */
#endif /* CONFIG_BT_MCC_OTS */