blob: d1d902030b7c1cef4a42253446776d6a5cdee1d0 [file] [log] [blame]
/** @file
* @brief Media Control Client shell implementation
*
*/
/*
* Copyright (c) 2020 - 2021 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <zephyr/bluetooth/audio/mcc.h>
#include <zephyr/shell/shell.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include "bt.h"
#include <zephyr/bluetooth/services/ots.h>
#include "../services/ots/ots_client_internal.h"
#include "../audio/media_proxy_internal.h"
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(bt_mcc_shell, CONFIG_BT_MCC_LOG_LEVEL);
static struct bt_mcc_cb cb;
#ifdef CONFIG_BT_MCC_OTS
struct object_ids_t {
uint64_t icon_obj_id;
uint64_t track_segments_obj_id;
uint64_t current_track_obj_id;
uint64_t next_track_obj_id;
uint64_t parent_group_obj_id;
uint64_t current_group_obj_id;
uint64_t search_results_obj_id;
};
static struct object_ids_t obj_ids;
#endif /* CONFIG_BT_MCC_OTS */
static void mcc_discover_mcs_cb(struct bt_conn *conn, int err)
{
if (err) {
shell_error(ctx_shell, "Discovery failed (%d)", err);
return;
}
shell_print(ctx_shell, "Discovery complete");
}
static void mcc_read_player_name_cb(struct bt_conn *conn, int err, const char *name)
{
if (err) {
shell_error(ctx_shell, "Player Name read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Player name: %s", name);
}
#ifdef CONFIG_BT_MCC_OTS
static void mcc_read_icon_obj_id_cb(struct bt_conn *conn, int err, uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Icon Object ID read failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Icon object ID: %s", str);
obj_ids.icon_obj_id = id;
}
#endif /* CONFIG_BT_MCC_OTS */
static void mcc_read_icon_url_cb(struct bt_conn *conn, int err, const char *url)
{
if (err) {
shell_error(ctx_shell, "Icon URL read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Icon URL: 0x%s", url);
}
static void mcc_read_track_title_cb(struct bt_conn *conn, int err, const char *title)
{
if (err) {
shell_error(ctx_shell, "Track title read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track title: %s", title);
}
static void mcc_track_changed_ntf_cb(struct bt_conn *conn, int err)
{
if (err) {
shell_error(ctx_shell, "Track changed notification failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track changed");
}
static void mcc_read_track_duration_cb(struct bt_conn *conn, int err, int32_t dur)
{
if (err) {
shell_error(ctx_shell, "Track duration read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track duration: %d", dur);
}
static void mcc_read_track_position_cb(struct bt_conn *conn, int err, int32_t pos)
{
if (err) {
shell_error(ctx_shell, "Track position read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track Position: %d", pos);
}
static void mcc_set_track_position_cb(struct bt_conn *conn, int err, int32_t pos)
{
if (err) {
shell_error(ctx_shell, "Track Position set failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track Position: %d", pos);
}
static void mcc_read_playback_speed_cb(struct bt_conn *conn, int err,
int8_t speed)
{
if (err) {
shell_error(ctx_shell, "Playback speed read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Playback speed: %d", speed);
}
static void mcc_set_playback_speed_cb(struct bt_conn *conn, int err, int8_t speed)
{
if (err) {
shell_error(ctx_shell, "Playback speed set failed (%d)", err);
return;
}
shell_print(ctx_shell, "Playback speed: %d", speed);
}
static void mcc_read_seeking_speed_cb(struct bt_conn *conn, int err,
int8_t speed)
{
if (err) {
shell_error(ctx_shell, "Seeking speed read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Seeking speed: %d", speed);
}
#ifdef CONFIG_BT_MCC_OTS
static void mcc_read_segments_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell,
"Track Segments Object ID read failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Track Segments Object ID: %s", str);
obj_ids.track_segments_obj_id = id;
}
static void mcc_read_current_track_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Current Track Object ID read failed (%d)",
err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Current Track Object ID: %s", str);
obj_ids.current_track_obj_id = id;
}
static void mcc_set_current_track_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Current Track Object ID set failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Current Track Object ID written: %s", str);
}
static void mcc_read_next_track_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Next Track Object ID read failed (%d)",
err);
return;
}
if (id == MPL_NO_TRACK_ID) {
shell_print(ctx_shell, "Next Track Object ID is empty");
} else {
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Next Track Object ID: %s", str);
}
obj_ids.next_track_obj_id = id;
}
static void mcc_set_next_track_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Next Track Object ID set failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Next Track Object ID written: %s", str);
}
static void mcc_read_parent_group_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell,
"Parent Group Object ID read failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Parent Group Object ID: %s", str);
obj_ids.parent_group_obj_id = id;
}
static void mcc_read_current_group_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell,
"Current Group Object ID read failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Current Group Object ID: %s", str);
obj_ids.current_group_obj_id = id;
}
static void mcc_set_current_group_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell, "Current Group Object ID set failed (%d)", err);
return;
}
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Current Group Object ID written: %s", str);
}
#endif /* CONFIG_BT_MCC_OTS */
static void mcc_read_playing_order_cb(struct bt_conn *conn, int err, uint8_t order)
{
if (err) {
shell_error(ctx_shell, "Playing order read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Playing order: %d", order);
}
static void mcc_set_playing_order_cb(struct bt_conn *conn, int err, uint8_t order)
{
if (err) {
shell_error(ctx_shell, "Playing order set failed (%d)", err);
return;
}
shell_print(ctx_shell, "Playing order: %d", order);
}
static void mcc_read_playing_orders_supported_cb(struct bt_conn *conn, int err,
uint16_t orders)
{
if (err) {
shell_error(ctx_shell,
"Playing orders supported read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Playing orders supported: %d", orders);
}
static void mcc_read_media_state_cb(struct bt_conn *conn, int err, uint8_t state)
{
if (err) {
shell_error(ctx_shell, "Media State read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Media State: %d", state);
}
static void mcc_send_cmd_cb(struct bt_conn *conn, int err, const struct mpl_cmd *cmd)
{
if (err) {
shell_error(ctx_shell,
"Command send failed (%d) - opcode: %d, param: %d",
err, cmd->opcode, cmd->param);
return;
}
shell_print(ctx_shell, "Command opcode: %d, param: %d", cmd->opcode, cmd->param);
}
static void mcc_cmd_ntf_cb(struct bt_conn *conn, int err,
const struct mpl_cmd_ntf *ntf)
{
if (err) {
shell_error(ctx_shell,
"Command notification error (%d) - opcode: %d, result: %d",
err, ntf->requested_opcode, ntf->result_code);
return;
}
shell_print(ctx_shell, "Command opcode: %d, result: %d",
ntf->requested_opcode, ntf->result_code);
}
static void mcc_read_opcodes_supported_cb(struct bt_conn *conn, int err,
uint32_t opcodes)
{
if (err) {
shell_error(ctx_shell, "Opcodes supported read failed (%d)",
err);
return;
}
shell_print(ctx_shell, "Opcodes supported: %d", opcodes);
}
#ifdef CONFIG_BT_MCC_OTS
static void mcc_send_search_cb(struct bt_conn *conn, int err,
const struct mpl_search *search)
{
if (err) {
shell_error(ctx_shell,
"Search send failed (%d)", err);
return;
}
shell_print(ctx_shell, "Search sent");
}
static void mcc_search_ntf_cb(struct bt_conn *conn, int err, uint8_t result_code)
{
if (err) {
shell_error(ctx_shell,
"Search notification error (%d), result code: %d",
err, result_code);
return;
}
shell_print(ctx_shell, "Search notification result code: %d",
result_code);
}
static void mcc_read_search_results_obj_id_cb(struct bt_conn *conn, int err,
uint64_t id)
{
char str[BT_OTS_OBJ_ID_STR_LEN];
if (err) {
shell_error(ctx_shell,
"Search Results Object ID read failed (%d)", err);
return;
}
if (id == 0) {
shell_print(ctx_shell, "Search Results Object ID: 0x000000000000");
} else {
(void)bt_ots_obj_id_to_str(id, str, sizeof(str));
shell_print(ctx_shell, "Search Results Object ID: %s", str);
}
obj_ids.search_results_obj_id = id;
}
#endif /* CONFIG_BT_MCC_OTS */
static void mcc_read_content_control_id_cb(struct bt_conn *conn, int err, uint8_t ccid)
{
if (err) {
shell_error(ctx_shell, "Content Control ID read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Content Control ID: %d", ccid);
}
#ifdef CONFIG_BT_MCC_OTS
/**** Callback functions for the included Object Transfer service *************/
static void mcc_otc_obj_selected_cb(struct bt_conn *conn, int err)
{
if (err) {
shell_error(ctx_shell,
"Error in selecting object (err %d)", err);
return;
}
shell_print(ctx_shell, "Selecting object succeeded");
}
static void mcc_otc_obj_metadata_cb(struct bt_conn *conn, int err)
{
if (err) {
shell_error(ctx_shell,
"Error in reading object metadata (err %d)", err);
return;
}
shell_print(ctx_shell, "Reading object metadata succeeded\n");
}
static void mcc_icon_object_read_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Icon Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Icon content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
/* TODO: May want to use a parsed type, instead of the raw buf, here */
static void mcc_track_segments_object_read_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Track Segments Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Track Segments content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
static void mcc_otc_read_current_track_object_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Current Track Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Current Track content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
static void mcc_otc_read_next_track_object_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Next Track Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Next Track content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
static void mcc_otc_read_parent_group_object_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Parent Group Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Parent Group content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
static void mcc_otc_read_current_group_object_cb(struct bt_conn *conn, int err,
struct net_buf_simple *buf)
{
if (err) {
shell_error(ctx_shell,
"Current Group Object read failed (%d)", err);
return;
}
shell_print(ctx_shell, "Current Group content (%d octets)", buf->len);
shell_hexdump(ctx_shell, buf->data, buf->len);
}
#endif /* CONFIG_BT_MCC_OTS */
static int cmd_mcc_init(const struct shell *sh, size_t argc, char **argv)
{
int result;
if (!ctx_shell) {
ctx_shell = sh;
}
/* Set up the callbacks */
cb.discover_mcs = mcc_discover_mcs_cb;
cb.read_player_name = mcc_read_player_name_cb;
#ifdef CONFIG_BT_MCC_OTS
cb.read_icon_obj_id = mcc_read_icon_obj_id_cb;
#endif /* CONFIG_BT_MCC_OTS */
cb.read_icon_url = mcc_read_icon_url_cb;
cb.track_changed_ntf = mcc_track_changed_ntf_cb;
cb.read_track_title = mcc_read_track_title_cb;
cb.read_track_duration = mcc_read_track_duration_cb;
cb.read_track_position = mcc_read_track_position_cb;
cb.set_track_position = mcc_set_track_position_cb;
cb.read_playback_speed = mcc_read_playback_speed_cb;
cb.set_playback_speed = mcc_set_playback_speed_cb;
cb.read_seeking_speed = mcc_read_seeking_speed_cb;
#ifdef CONFIG_BT_MCC_OTS
cb.read_segments_obj_id = mcc_read_segments_obj_id_cb;
cb.read_current_track_obj_id = mcc_read_current_track_obj_id_cb;
cb.set_current_track_obj_id = mcc_set_current_track_obj_id_cb;
cb.read_next_track_obj_id = mcc_read_next_track_obj_id_cb;
cb.set_next_track_obj_id = mcc_set_next_track_obj_id_cb;
cb.read_parent_group_obj_id = mcc_read_parent_group_obj_id_cb;
cb.read_current_group_obj_id = mcc_read_current_group_obj_id_cb;
cb.set_current_group_obj_id = mcc_set_current_group_obj_id_cb;
#endif /* CONFIG_BT_MCC_OTS */
cb.read_playing_order = mcc_read_playing_order_cb;
cb.set_playing_order = mcc_set_playing_order_cb;
cb.read_playing_orders_supported = mcc_read_playing_orders_supported_cb;
cb.read_media_state = mcc_read_media_state_cb;
cb.send_cmd = mcc_send_cmd_cb;
cb.cmd_ntf = mcc_cmd_ntf_cb;
cb.read_opcodes_supported = mcc_read_opcodes_supported_cb;
#ifdef CONFIG_BT_MCC_OTS
cb.send_search = mcc_send_search_cb;
cb.search_ntf = mcc_search_ntf_cb;
cb.read_search_results_obj_id = mcc_read_search_results_obj_id_cb;
#endif /* CONFIG_BT_MCC_OTS */
cb.read_content_control_id = mcc_read_content_control_id_cb;
#ifdef CONFIG_BT_MCC_OTS
cb.otc_obj_selected = mcc_otc_obj_selected_cb;
cb.otc_obj_metadata = mcc_otc_obj_metadata_cb;
cb.otc_icon_object = mcc_icon_object_read_cb;
cb.otc_track_segments_object = mcc_track_segments_object_read_cb;
cb.otc_current_track_object = mcc_otc_read_current_track_object_cb;
cb.otc_next_track_object = mcc_otc_read_next_track_object_cb;
cb.otc_parent_group_object = mcc_otc_read_parent_group_object_cb;
cb.otc_current_group_object = mcc_otc_read_current_group_object_cb;
#endif /* CONFIG_BT_MCC_OTS */
/* Initialize the module */
result = bt_mcc_init(&cb);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_discover_mcs(const struct shell *sh, size_t argc,
char **argv)
{
int result;
int subscribe = 1;
if (argc > 1) {
subscribe = strtol(argv[1], NULL, 0);
if (subscribe < 0 || subscribe > 1) {
shell_error(sh, "Invalid parameter");
return -ENOEXEC;
}
}
result = bt_mcc_discover_mcs(default_conn, (bool)subscribe);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_player_name(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_player_name(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#ifdef CONFIG_BT_MCC_OTS
static int cmd_mcc_read_icon_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_icon_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#endif /* CONFIG_BT_MCC_OTS */
static int cmd_mcc_read_icon_url(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_icon_url(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_track_title(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_track_title(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_track_duration(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_track_duration(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_track_position(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_track_position(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_track_position(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
int32_t pos = strtol(argv[1], NULL, 0);
/* Todo: Check input "pos" for validity, or for errors in conversion? */
result = bt_mcc_set_track_position(default_conn, pos);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_playback_speed(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_playback_speed(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_playback_speed(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
int8_t speed = strtol(argv[1], NULL, 0);
result = bt_mcc_set_playback_speed(default_conn, speed);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_seeking_speed(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_seeking_speed(default_conn);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
#ifdef CONFIG_BT_MCC_OTS
static int cmd_mcc_read_track_segments_obj_id(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
result = bt_mcc_read_segments_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_current_track_obj_id(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
result = bt_mcc_read_current_track_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_current_track_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
uint64_t id = strtoul(argv[1], NULL, 0);
id = id & 0x0000FFFFFFFFFFFFUL; /* 48 bits only */
result = bt_mcc_set_current_track_obj_id(default_conn, id);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_next_track_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_next_track_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_next_track_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
uint64_t id = strtoul(argv[1], NULL, 0);
id = id & 0x0000FFFFFFFFFFFFUL; /* 48 bits only */
result = bt_mcc_set_next_track_obj_id(default_conn, id);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_parent_group_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_parent_group_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_current_group_obj_id(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
result = bt_mcc_read_current_group_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_current_group_obj_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
uint64_t id = strtoul(argv[1], NULL, 0);
id = id & 0x0000FFFFFFFFFFFFUL; /* 48 bits only */
result = bt_mcc_set_current_group_obj_id(default_conn, id);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
#endif /* CONFIG_BT_MCC_OTS */
static int cmd_mcc_read_playing_order(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_playing_order(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_set_playing_order(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
uint8_t order = strtol(argv[1], NULL, 0);
result = bt_mcc_set_playing_order(default_conn, order);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_playing_orders_supported(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
result = bt_mcc_read_playing_orders_supported(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_read_media_state(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_media_state(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_play(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_PLAY,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC play failed: %d", err);
}
return err;
}
static int cmd_mcc_pause(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_PAUSE,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC pause failed: %d", err);
}
return err;
}
static int cmd_mcc_fast_rewind(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_FAST_REWIND,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC fast rewind failed: %d", err);
}
return err;
}
static int cmd_mcc_fast_forward(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_FAST_FORWARD,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC fast forward failed: %d", err);
}
return err;
}
static int cmd_mcc_stop(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_STOP,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC stop failed: %d", err);
}
return err;
}
static int cmd_mcc_move_relative(const struct shell *sh, size_t argc,
char *argv[])
{
struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_MOVE_RELATIVE,
.use_param = true,
};
long offset;
int err;
err = 0;
offset = shell_strtol(argv[1], 10, &err);
if (err != 0) {
shell_error(sh, "Failed to parse offset: %d", err);
return err;
}
if (!IN_RANGE(offset, INT32_MIN, INT32_MAX)) {
shell_error(sh, "Invalid offset: %ld", offset);
return -ENOEXEC;
}
cmd.param = (int32_t)offset;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC move relative failed: %d", err);
}
return err;
}
static int cmd_mcc_prev_segment(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_PREV_SEGMENT,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC previous segment failed: %d", err);
}
return err;
}
static int cmd_mcc_next_segment(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_NEXT_SEGMENT,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC next segment failed: %d", err);
}
return err;
}
static int cmd_mcc_first_segment(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_FIRST_SEGMENT,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC first segment failed: %d", err);
}
return err;
}
static int cmd_mcc_last_segment(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_LAST_SEGMENT,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC last segment failed: %d", err);
}
return err;
}
static int cmd_mcc_goto_segment(const struct shell *sh, size_t argc,
char *argv[])
{
struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_GOTO_SEGMENT,
.use_param = true,
};
long segment;
int err;
err = 0;
segment = shell_strtol(argv[1], 10, &err);
if (err != 0) {
shell_error(sh, "Failed to parse segment: %d", err);
return err;
}
if (!IN_RANGE(segment, INT32_MIN, INT32_MAX)) {
shell_error(sh, "Invalid segment: %ld", segment);
return -ENOEXEC;
}
cmd.param = (int32_t)segment;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC goto segment failed: %d", err);
}
return err;
}
static int cmd_mcc_prev_track(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_PREV_TRACK,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC previous track failed: %d", err);
}
return err;
}
static int cmd_mcc_next_track(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_NEXT_TRACK,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC next track failed: %d", err);
}
return err;
}
static int cmd_mcc_first_track(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_FIRST_TRACK,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC first track failed: %d", err);
}
return err;
}
static int cmd_mcc_last_track(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_LAST_TRACK,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC last track failed: %d", err);
}
return err;
}
static int cmd_mcc_goto_track(const struct shell *sh, size_t argc, char *argv[])
{
struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_GOTO_TRACK,
.use_param = true,
};
long track;
int err;
err = 0;
track = shell_strtol(argv[1], 10, &err);
if (err != 0) {
shell_error(sh, "Failed to parse track: %d", err);
return err;
}
if (!IN_RANGE(track, INT32_MIN, INT32_MAX)) {
shell_error(sh, "Invalid track: %ld", track);
return -ENOEXEC;
}
cmd.param = (int32_t)track;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC goto track failed: %d", err);
}
return err;
}
static int cmd_mcc_prev_group(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_PREV_GROUP,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC previous group failed: %d", err);
}
return err;
}
static int cmd_mcc_next_group(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_NEXT_GROUP,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC next group failed: %d", err);
}
return err;
}
static int cmd_mcc_first_group(const struct shell *sh, size_t argc,
char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_FIRST_GROUP,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC first group failed: %d", err);
}
return err;
}
static int cmd_mcc_last_group(const struct shell *sh, size_t argc, char *argv[])
{
const struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_LAST_GROUP,
.use_param = false,
.param = 0,
};
int err;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC last group failed: %d", err);
}
return err;
}
static int cmd_mcc_goto_group(const struct shell *sh, size_t argc, char *argv[])
{
struct mpl_cmd cmd = {
.opcode = BT_MCS_OPC_GOTO_GROUP,
.use_param = true,
};
long group;
int err;
err = 0;
group = shell_strtol(argv[1], 10, &err);
if (err != 0) {
shell_error(sh, "Failed to parse group: %d", err);
return err;
}
if (!IN_RANGE(group, INT32_MIN, INT32_MAX)) {
shell_error(sh, "Invalid group: %ld", group);
return -ENOEXEC;
}
cmd.param = (int32_t)group;
err = bt_mcc_send_cmd(default_conn, &cmd);
if (err != 0) {
shell_error(sh, "MCC goto group failed: %d", err);
}
return err;
}
static int cmd_mcc_read_opcodes_supported(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_opcodes_supported(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#ifdef CONFIG_BT_MCC_OTS
static int cmd_mcc_send_search_raw(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
struct mpl_search search;
search.len = strlen(argv[1]);
memcpy(search.search, argv[1], search.len);
LOG_DBG("Search string: %s", argv[1]);
result = bt_mcc_send_search(default_conn, &search);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_send_search_ioptest(const struct shell *sh, size_t argc,
char *argv[])
{
/* Implementation follows Media control service testspec 0.9.0r13 */
/* Testcase MCS/SR/SCP/BV-01-C [Search Control Point], rounds 1 - 9 */
int result;
uint8_t testround;
struct mpl_sci sci_1 = {0};
struct mpl_sci sci_2 = {0};
struct mpl_search search;
testround = strtol(argv[1], NULL, 0);
switch (testround) {
case 1:
case 8:
case 9:
/* 1, 8 and 9 have the same first SCI */
sci_1.type = BT_MCS_SEARCH_TYPE_TRACK_NAME;
strcpy(sci_1.param, "TSPX_Track_Name");
break;
case 2:
sci_1.type = BT_MCS_SEARCH_TYPE_ARTIST_NAME;
strcpy(sci_1.param, "TSPX_Artist_Name");
break;
case 3:
sci_1.type = BT_MCS_SEARCH_TYPE_ALBUM_NAME;
strcpy(sci_1.param, "TSPX_Album_Name");
break;
case 4:
sci_1.type = BT_MCS_SEARCH_TYPE_GROUP_NAME;
strcpy(sci_1.param, "TSPX_Group_Name");
break;
case 5:
sci_1.type = BT_MCS_SEARCH_TYPE_EARLIEST_YEAR;
strcpy(sci_1.param, "TSPX_Earliest_Year");
break;
case 6:
sci_1.type = BT_MCS_SEARCH_TYPE_LATEST_YEAR;
strcpy(sci_1.param, "TSPX_Latest_Year");
break;
case 7:
sci_1.type = BT_MCS_SEARCH_TYPE_GENRE;
strcpy(sci_1.param, "TSPX_Genre");
break;
default:
shell_error(sh, "Invalid parameter");
return -ENOEXEC;
}
switch (testround) {
case 8:
sci_2.type = BT_MCS_SEARCH_TYPE_ONLY_TRACKS;
break;
case 9:
sci_2.type = BT_MCS_SEARCH_TYPE_ONLY_GROUPS;
break;
}
/* Length is length of type, plus length of param w/o termination */
sci_1.len = sizeof(sci_1.type) + strlen(sci_1.param);
search.len = 0;
memcpy(&search.search[search.len], &sci_1.len, sizeof(sci_1.len));
search.len += sizeof(sci_1.len);
memcpy(&search.search[search.len], &sci_1.type, sizeof(sci_1.type));
search.len += sizeof(sci_1.type);
memcpy(&search.search[search.len], &sci_1.param, strlen(sci_1.param));
search.len += strlen(sci_1.param);
if (testround == 8 || testround == 9) {
sci_2.len = sizeof(sci_2.type); /* The type only, no param */
memcpy(&search.search[search.len], &sci_2.len,
sizeof(sci_2.len));
search.len += sizeof(sci_2.len);
memcpy(&search.search[search.len], &sci_2.type,
sizeof(sci_2.type));
search.len += sizeof(sci_2.type);
}
shell_print(sh, "Search string: ");
shell_hexdump(sh, (uint8_t *)&search.search, search.len);
result = bt_mcc_send_search(default_conn, &search);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
#if defined(CONFIG_BT_MCC_LOG_LEVEL_DBG) && defined(CONFIG_BT_TESTING)
static int cmd_mcc_test_send_search_iop_invalid_type(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
struct mpl_search search;
search.search[0] = 2;
search.search[1] = (char)14; /* Invalid type value */
search.search[2] = 't'; /* Anything */
search.len = 3;
shell_print(sh, "Search string: ");
shell_hexdump(sh, (uint8_t *)&search.search, search.len);
result = bt_mcc_send_search(default_conn, &search);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_test_send_search_invalid_sci_len(const struct shell *sh,
size_t argc, char *argv[])
{
/* Reproduce a search that caused hard fault when sent from peer */
/* in IOP testing */
int result;
struct mpl_search search;
char offending_search[9] = {6, 1, 't', 'r', 'a', 'c', 'k', 0, 1 };
search.len = 9;
memcpy(&search.search, offending_search, search.len);
shell_print(sh, "Search string: ");
shell_hexdump(sh, (uint8_t *)&search.search, search.len);
result = bt_mcc_send_search(default_conn, &search);
if (result) {
shell_print(sh, "Fail: %d", result);
}
return result;
}
#endif /* CONFIG_BT_MCC_LOG_LEVEL_DBG && CONFIG_BT_TESTING */
static int cmd_mcc_read_search_results_obj_id(const struct shell *sh,
size_t argc, char *argv[])
{
int result;
result = bt_mcc_read_search_results_obj_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#endif /* CONFIG_BT_MCC_OTS */
static int cmd_mcc_read_content_control_id(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_mcc_read_content_control_id(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#ifdef CONFIG_BT_MCC_OTS
static int cmd_mcc_otc_read_features(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_read_feature(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read(const struct shell *sh, size_t argc, char *argv[])
{
int result;
result = bt_ots_client_read_object_data(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_metadata(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_read_object_metadata(bt_mcc_otc_inst(default_conn),
default_conn,
BT_OTS_METADATA_REQ_ALL);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_select(const struct shell *sh, size_t argc, char *argv[])
{
int result;
uint64_t id;
if (argc > 1) {
id = strtol(argv[1], NULL, 0);
} else {
shell_error(sh, "Invalid parameter, requires the Object ID");
return -ENOEXEC;
}
result = bt_ots_client_select_id(bt_mcc_otc_inst(default_conn),
default_conn, id);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_select_first(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_select_first(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_select_last(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_select_last(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_select_next(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_select_next(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_select_prev(const struct shell *sh, size_t argc,
char *argv[])
{
int result;
result = bt_ots_client_select_prev(bt_mcc_otc_inst(default_conn),
default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_icon_object(const struct shell *sh, size_t argc,
char *argv[])
{
/* Assumes the Icon Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_icon_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_track_segments_object(const struct shell *sh,
size_t argc, char *argv[])
{
/* Assumes the Segment Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_track_segments_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_current_track_object(const struct shell *sh,
size_t argc, char *argv[])
{
/* Assumes the Curent Track Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_current_track_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_next_track_object(const struct shell *sh,
size_t argc, char *argv[])
{
/* Assumes the Next Track Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_next_track_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_parent_group_object(const struct shell *sh,
size_t argc, char *argv[])
{
/* Assumes the Parent Group Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_parent_group_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
static int cmd_mcc_otc_read_current_group_object(const struct shell *sh,
size_t argc, char *argv[])
{
/* Assumes the Current Group Object has already been selected by ID */
int result;
result = bt_mcc_otc_read_current_group_object(default_conn);
if (result) {
shell_error(sh, "Fail: %d", result);
}
return result;
}
#endif /* CONFIG_BT_MCC_OTS */
static int cmd_mcc(const struct shell *sh, size_t argc, char **argv)
{
shell_error(sh, "%s unknown parameter: %s", argv[0], argv[1]);
return -ENOEXEC;
}
SHELL_STATIC_SUBCMD_SET_CREATE(mcc_cmds,
SHELL_CMD_ARG(init, NULL, "Initialize client",
cmd_mcc_init, 1, 0),
SHELL_CMD_ARG(discover_mcs, NULL,
"Discover Media Control Service [subscribe]",
cmd_mcc_discover_mcs, 1, 1),
SHELL_CMD_ARG(read_player_name, NULL, "Read Media Player Name",
cmd_mcc_read_player_name, 1, 0),
#ifdef CONFIG_BT_MCC_OTS
SHELL_CMD_ARG(read_icon_obj_id, NULL, "Read Icon Object ID",
cmd_mcc_read_icon_obj_id, 1, 0),
#endif /* CONFIG_BT_MCC_OTS */
SHELL_CMD_ARG(read_icon_url, NULL, "Read Icon URL",
cmd_mcc_read_icon_url, 1, 0),
SHELL_CMD_ARG(read_track_title, NULL, "Read Track Title",
cmd_mcc_read_track_title, 1, 0),
SHELL_CMD_ARG(read_track_duration, NULL, "Read Track Duration",
cmd_mcc_read_track_duration, 1, 0),
SHELL_CMD_ARG(read_track_position, NULL, "Read Track Position",
cmd_mcc_read_track_position, 1, 0),
SHELL_CMD_ARG(set_track_position, NULL, "Set Track position <position>",
cmd_mcc_set_track_position, 2, 0),
SHELL_CMD_ARG(read_playback_speed, NULL, "Read Playback Speed",
cmd_mcc_read_playback_speed, 1, 0),
SHELL_CMD_ARG(set_playback_speed, NULL, "Set Playback Speed <speed>",
cmd_mcc_set_playback_speed, 2, 0),
SHELL_CMD_ARG(read_seeking_speed, NULL, "Read Seeking Speed",
cmd_mcc_read_seeking_speed, 1, 0),
#ifdef CONFIG_BT_MCC_OTS
SHELL_CMD_ARG(read_track_segments_obj_id, NULL,
"Read Track Segments Object ID",
cmd_mcc_read_track_segments_obj_id, 1, 0),
SHELL_CMD_ARG(read_current_track_obj_id, NULL,
"Read Current Track Object ID",
cmd_mcc_read_current_track_obj_id, 1, 0),
SHELL_CMD_ARG(set_current_track_obj_id, NULL,
"Set Current Track Object ID <id: 48 bits or less>",
cmd_mcc_set_current_track_obj_id, 2, 0),
SHELL_CMD_ARG(read_next_track_obj_id, NULL,
"Read Next Track Object ID",
cmd_mcc_read_next_track_obj_id, 1, 0),
SHELL_CMD_ARG(set_next_track_obj_id, NULL,
"Set Next Track Object ID <id: 48 bits or less>",
cmd_mcc_set_next_track_obj_id, 2, 0),
SHELL_CMD_ARG(read_current_group_obj_id, NULL,
"Read Current Group Object ID",
cmd_mcc_read_current_group_obj_id, 1, 0),
SHELL_CMD_ARG(read_parent_group_obj_id, NULL,
"Read Parent Group Object ID",
cmd_mcc_read_parent_group_obj_id, 1, 0),
SHELL_CMD_ARG(set_current_group_obj_id, NULL,
"Set Current Group Object ID <id: 48 bits or less>",
cmd_mcc_set_current_group_obj_id, 2, 0),
#endif /* CONFIG_BT_MCC_OTS */
SHELL_CMD_ARG(read_playing_order, NULL, "Read Playing Order",
cmd_mcc_read_playing_order, 1, 0),
SHELL_CMD_ARG(set_playing_order, NULL, "Set Playing Order <order>",
cmd_mcc_set_playing_order, 2, 0),
SHELL_CMD_ARG(read_playing_orders_supported, NULL,
"Read Playing Orders Supported",
cmd_mcc_read_playing_orders_supported, 1, 0),
SHELL_CMD_ARG(read_media_state, NULL, "Read Media State",
cmd_mcc_read_media_state, 1, 0),
SHELL_CMD_ARG(play, NULL, "Send the play command", cmd_mcc_play, 1, 0),
SHELL_CMD_ARG(pause, NULL, "Send the pause command",
cmd_mcc_pause, 1, 0),
SHELL_CMD_ARG(fast_rewind, NULL, "Send the fast rewind command",
cmd_mcc_fast_rewind, 1, 0),
SHELL_CMD_ARG(fast_forward, NULL, "Send the fast forward command",
cmd_mcc_fast_forward, 1, 0),
SHELL_CMD_ARG(stop, NULL, "Send the stop command", cmd_mcc_stop, 1, 0),
SHELL_CMD_ARG(move_relative, NULL,
"Send the move relative command <int32_t: offset>",
cmd_mcc_move_relative, 2, 0),
SHELL_CMD_ARG(prev_segment, NULL, "Send the prev segment command",
cmd_mcc_prev_segment, 1, 0),
SHELL_CMD_ARG(next_segment, NULL, "Send the next segment command",
cmd_mcc_next_segment, 1, 0),
SHELL_CMD_ARG(first_segment, NULL, "Send the first segment command",
cmd_mcc_first_segment, 1, 0),
SHELL_CMD_ARG(last_segment, NULL, "Send the last segment command",
cmd_mcc_last_segment, 1, 0),
SHELL_CMD_ARG(goto_segment, NULL,
"Send the goto segment command <int32_t: segment>",
cmd_mcc_goto_segment, 2, 0),
SHELL_CMD_ARG(prev_track, NULL, "Send the prev track command",
cmd_mcc_prev_track, 1, 0),
SHELL_CMD_ARG(next_track, NULL, "Send the next track command",
cmd_mcc_next_track, 1, 0),
SHELL_CMD_ARG(first_track, NULL, "Send the first track command",
cmd_mcc_first_track, 1, 0),
SHELL_CMD_ARG(last_track, NULL, "Send the last track command",
cmd_mcc_last_track, 1, 0),
SHELL_CMD_ARG(goto_track, NULL,
"Send the goto track command <int32_t: track>",
cmd_mcc_goto_track, 2, 0),
SHELL_CMD_ARG(prev_group, NULL, "Send the prev group command",
cmd_mcc_prev_group, 1, 0),
SHELL_CMD_ARG(next_group, NULL, "Send the next group command",
cmd_mcc_next_group, 1, 0),
SHELL_CMD_ARG(first_group, NULL, "Send the first group command",
cmd_mcc_first_group, 1, 0),
SHELL_CMD_ARG(last_group, NULL, "Send the last group command",
cmd_mcc_last_group, 1, 0),
SHELL_CMD_ARG(goto_group, NULL,
"Send the goto group command <int32_t: group>",
cmd_mcc_goto_group, 2, 0),
SHELL_CMD_ARG(read_opcodes_supported, NULL, "Send the Read Opcodes Supported",
cmd_mcc_read_opcodes_supported, 1, 0),
#ifdef CONFIG_BT_MCC_OTS
SHELL_CMD_ARG(send_search_raw, NULL, "Send search <search control item sequence>",
cmd_mcc_send_search_raw, 2, 0),
SHELL_CMD_ARG(send_search_scp_ioptest, NULL,
"Send search - IOP test round as input <round number>",
cmd_mcc_send_search_ioptest, 2, 0),
#if defined(CONFIG_BT_MCC_LOG_LEVEL_DBG) && defined(CONFIG_BT_TESTING)
SHELL_CMD_ARG(test_send_search_iop_invalid_type, NULL,
"Send search - IOP test, invalid type value (test)",
cmd_mcc_test_send_search_iop_invalid_type, 1, 0),
SHELL_CMD_ARG(test_send_Search_invalid_sci_len, NULL,
"Send search - invalid sci length (test)",
cmd_mcc_test_send_search_invalid_sci_len, 1, 0),
#endif /* CONFIG_BT_MCC_LOG_LEVEL_DBG && CONFIG_BT_TESTING */
SHELL_CMD_ARG(read_search_results_obj_id, NULL,
"Read Search Results Object ID",
cmd_mcc_read_search_results_obj_id, 1, 0),
#endif /* CONFIG_BT_MCC_OTS */
SHELL_CMD_ARG(read_content_control_id, NULL, "Read Content Control ID",
cmd_mcc_read_content_control_id, 1, 0),
#ifdef CONFIG_BT_MCC_OTS
SHELL_CMD_ARG(ots_read_features, NULL, "Read OTC Features",
cmd_mcc_otc_read_features, 1, 0),
SHELL_CMD_ARG(ots_oacp_read, NULL, "Read current object",
cmd_mcc_otc_read, 1, 0),
SHELL_CMD_ARG(ots_read_metadata, NULL, "Read current object's metadata",
cmd_mcc_otc_read_metadata, 1, 0),
SHELL_CMD_ARG(ots_select, NULL, "Select an object by its ID <ID>",
cmd_mcc_otc_select, 2, 0),
SHELL_CMD_ARG(ots_read_icon_object, NULL, "Read Icon Object",
cmd_mcc_otc_read_icon_object, 1, 0),
SHELL_CMD_ARG(ots_read_track_segments_object, NULL,
"Read Track Segments Object",
cmd_mcc_otc_read_track_segments_object, 1, 0),
SHELL_CMD_ARG(ots_read_current_track_object, NULL,
"Read Current Track Object",
cmd_mcc_otc_read_current_track_object, 1, 0),
SHELL_CMD_ARG(ots_read_next_track_object, NULL,
"Read Next Track Object",
cmd_mcc_otc_read_next_track_object, 1, 0),
SHELL_CMD_ARG(ots_read_parent_group_object, NULL,
"Read Parent Group Object",
cmd_mcc_otc_read_parent_group_object, 1, 0),
SHELL_CMD_ARG(ots_read_current_group_object, NULL,
"Read Current Group Object",
cmd_mcc_otc_read_current_group_object, 1, 0),
SHELL_CMD_ARG(ots_select_first, NULL, "Select first object",
cmd_mcc_otc_select_first, 1, 0),
SHELL_CMD_ARG(ots_select_last, NULL, "Select last object",
cmd_mcc_otc_select_last, 1, 0),
SHELL_CMD_ARG(ots_select_next, NULL, "Select next object",
cmd_mcc_otc_select_next, 1, 0),
SHELL_CMD_ARG(ots_select_previous, NULL, "Select previous object",
cmd_mcc_otc_select_prev, 1, 0),
#endif /* CONFIG_BT_MCC_OTS */
SHELL_SUBCMD_SET_END
);
SHELL_CMD_ARG_REGISTER(mcc, &mcc_cmds, "MCC commands",
cmd_mcc, 1, 1);