subsys/bluetooth/shell/bass_client.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /**
  * @file
  * @brief Shell APIs for Bluetooth BASS client
  *
  * Copyright (c) 2020-2021 Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/types.h>

 #include <zephyr/kernel.h>
 #include <zephyr/types.h>
 #include <zephyr/shell/shell.h>
 #include <stdlib.h>
 #include <zephyr/bluetooth/gatt.h>
 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/bluetooth/hci.h>
 #include <zephyr/bluetooth/audio/bass.h>
 #include "bt.h"
 #include "../host/hci_core.h"

 static void bass_client_discover_cb(struct bt_conn *conn, int err,
 				    uint8_t recv_state_count)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS discover failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS discover done with %u recv states",
 			    recv_state_count);
 	}

 }

 static void bass_client_scan_cb(const struct bt_le_scan_recv_info *info,
 				uint32_t broadcast_id)
 {
 	char le_addr[BT_ADDR_LE_STR_LEN];
 	char name[30];

 	(void)memset(name, 0, sizeof(name));

 	bt_addr_le_to_str(info->addr, le_addr, sizeof(le_addr));
 	shell_print(ctx_shell, "[DEVICE]: %s (%s), broadcast_id %u, "
 		    "interval (ms) %u), SID 0x%x, RSSI %i",
 		    le_addr, name, broadcast_id, info->interval * 5 / 4,
 		    info->sid, info->rssi);

 }

 static bool metadata_entry(struct bt_data *data, void *user_data)
 {
 	char metadata[512];

 	bin2hex(data->data, data->data_len, metadata, sizeof(metadata));

 	shell_print(ctx_shell, "\t\tMetadata length %u, type %u, data: %s",
 		    data->data_len, data->type, metadata);

 	return true;
 }

 static void bass_client_recv_state_cb(struct bt_conn *conn, int err,
 				      const struct bt_bass_recv_state *state)
 {
 	char le_addr[BT_ADDR_LE_STR_LEN];
 	char bad_code[33];

 	if (err != 0) {
 		shell_error(ctx_shell, "BASS recv state read failed (%d)", err);
 		return;
 	}

 	bt_addr_le_to_str(&state->addr, le_addr, sizeof(le_addr));
 	bin2hex(state->bad_code, BT_BASS_BROADCAST_CODE_SIZE,
 		bad_code, sizeof(bad_code));
 	shell_print(ctx_shell, "BASS recv state: src_id %u, addr %s, "
 		    "sid %u, sync_state %u, encrypt_state %u%s%s",
 		    state->src_id, le_addr, state->adv_sid,
 		    state->pa_sync_state, state->encrypt_state,
 		    state->encrypt_state == BT_BASS_BIG_ENC_STATE_BAD_CODE ? ", bad code" : "",
 		    bad_code);

 	for (int i = 0; i < state->num_subgroups; i++) {
 		const struct bt_bass_subgroup *subgroup = &state->subgroups[i];
 		struct net_buf_simple buf;

 		shell_print(ctx_shell, "\t[%d]: BIS sync %u, metadata_len %u",
 			    i, subgroup->bis_sync, subgroup->metadata_len);

 		net_buf_simple_init_with_data(&buf, (void *)subgroup->metadata,
 					      subgroup->metadata_len);
 		bt_data_parse(&buf, metadata_entry, NULL);
 	}


 	if (state->pa_sync_state == BT_BASS_PA_STATE_INFO_REQ) {
 		struct bt_le_per_adv_sync *per_adv_sync = NULL;
 		struct bt_le_ext_adv *ext_adv = NULL;

 		/* Lookup matching PA sync */
 		for (int i = 0; i < ARRAY_SIZE(per_adv_syncs); i++) {
 			if (per_adv_syncs[i] &&
 			    bt_addr_le_cmp(&per_adv_syncs[i]->addr,
 					    &state->addr) == 0) {
 				per_adv_sync = per_adv_syncs[i];
 				break;
 			}
 		}

 		if (per_adv_sync) {
 			shell_print(ctx_shell, "Sending PAST");

 			err = bt_le_per_adv_sync_transfer(per_adv_sync,
 							  conn,
 							  BT_UUID_BASS_VAL);

 			if (err != 0) {
 				shell_error(ctx_shell, "Could not transfer periodic adv sync: %d",
 					    err);
 			}

 			return;
 		}

 		/* If no PA sync was found, check for local advertisers */
 		for (int i = 0; i < ARRAY_SIZE(adv_sets); i++) {
 			struct bt_le_oob oob_local;

 			if (adv_sets[i] == NULL) {
 				continue;
 			}

 			err = bt_le_ext_adv_oob_get_local(adv_sets[i],
 							  &oob_local);

 			if (err != 0) {
 				shell_error(ctx_shell,
 					    "Could not get local OOB %d",
 					    err);
 				return;
 			}

 			if (bt_addr_le_cmp(&oob_local.addr,
 					   &state->addr) == 0) {
 				ext_adv = adv_sets[i];
 				break;
 			}
 		}

 		if (ext_adv != NULL && IS_ENABLED(CONFIG_BT_PER_ADV)) {
 			shell_print(ctx_shell, "Sending local PAST");

 			err = bt_le_per_adv_set_info_transfer(ext_adv, conn,
 							      BT_UUID_BASS_VAL);

 			if (err != 0) {
 				shell_error(ctx_shell,
 					    "Could not transfer per adv set info: %d",
 					    err);
 			}
 		} else {
 			shell_error(ctx_shell, "Could not send PA to BASS server");
 		}
 	}
 }

 static void bass_client_recv_state_removed_cb(struct bt_conn *conn, int err,
 					      uint8_t src_id)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS recv state removed failed (%d)",
 			    err);
 	} else {
 		shell_print(ctx_shell, "BASS recv state %u removed", src_id);
 	}
 }

 static void bass_client_scan_start_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS scan start failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS scan start successful");
 	}
 }

 static void bass_client_scan_stop_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS scan stop failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS scan stop successful");
 	}
 }

 static void bass_client_add_src_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS add source failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS add source successful");
 	}
 }

 static void bass_client_mod_src_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS modify source failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS modify source successful");
 	}
 }

 static void bass_client_broadcast_code_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS broadcast code failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS broadcast code successful");
 	}
 }

 static void bass_client_rem_src_cb(struct bt_conn *conn, int err)
 {
 	if (err != 0) {
 		shell_error(ctx_shell, "BASS remove source failed (%d)", err);
 	} else {
 		shell_print(ctx_shell, "BASS remove source successful");
 	}
 }

 static struct bt_bass_client_cb cbs = {
 	.discover = bass_client_discover_cb,
 	.scan = bass_client_scan_cb,
 	.recv_state = bass_client_recv_state_cb,
 	.recv_state_removed = bass_client_recv_state_removed_cb,
 	.scan_start = bass_client_scan_start_cb,
 	.scan_stop = bass_client_scan_stop_cb,
 	.add_src = bass_client_add_src_cb,
 	.mod_src = bass_client_mod_src_cb,
 	.broadcast_code = bass_client_broadcast_code_cb,
 	.rem_src = bass_client_rem_src_cb,
 };

 static int cmd_bass_client_discover(const struct shell *sh, size_t argc,
 				    char **argv)
 {
 	int result;

 	bt_bass_client_register_cb(&cbs);

 	result = bt_bass_client_discover(default_conn);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_scan_start(const struct shell *sh, size_t argc,
 				      char **argv)
 {
 	int result;
 	int start_scan = false;

 	if (argc > 1) {
 		start_scan = strtol(argv[1], NULL, 0);

 		if (start_scan != 0 && start_scan != 1) {
 			shell_error(sh, "Value shall be boolean");
 			return -ENOEXEC;
 		}
 	}

 	result = bt_bass_client_scan_start(default_conn, (bool)start_scan);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_scan_stop(const struct shell *sh, size_t argc,
 				     char **argv)
 {
 	int result;

 	result = bt_bass_client_scan_stop(default_conn);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_add_src(const struct shell *sh, size_t argc,
 				   char **argv)
 {
 	int result;
 	struct bt_bass_add_src_param param = { 0 };
 	struct bt_bass_subgroup subgroup = { 0 };

 	result = bt_addr_le_from_str(argv[1], argv[2], &param.addr);
 	if (result) {
 		shell_error(sh, "Invalid peer address (err %d)", result);
 		return -ENOEXEC;
 	}

 	param.adv_sid = strtol(argv[3], NULL, 0);
 	if (param.adv_sid < 0 || param.adv_sid > 0x0F) {
 		shell_error(sh, "adv_sid shall be 0x00-0x0f");
 		return -ENOEXEC;
 	}

 	param.pa_sync = strtol(argv[4], NULL, 0);
 	if (param.pa_sync < 0 || param.pa_sync > 1) {
 		shell_error(sh, "pa_sync shall be boolean");
 		return -ENOEXEC;
 	}

 	param.broadcast_id = strtol(argv[5], NULL, 0);
 	if (param.broadcast_id < 0 ||
 	    param.broadcast_id > 0xFFFFFF /* 24 bits */) {
 		shell_error(sh, "Broadcast ID maximum 24 bits (was %x)",
 			    param.broadcast_id);
 		return -ENOEXEC;
 	}

 	if (argc > 6) {
 		param.pa_interval = strtol(argv[6], NULL, 0);
 	} else {
 		param.pa_interval = BT_BASS_PA_INTERVAL_UNKNOWN;
 	}

 	/* TODO: Support multiple subgroups */
 	if (argc > 7) {
 		subgroup.bis_sync = strtoul(argv[7], NULL, 0);
 		if (subgroup.bis_sync > UINT32_MAX) {
 			shell_error(sh,
 				    "bis_sync shall be 0x00000000 to 0xFFFFFFFF");
 			return -ENOEXEC;
 		}
 	}

 	if (argc > 8) {
 		subgroup.metadata_len = hex2bin(argv[8], strlen(argv[8]),
 						subgroup.metadata,
 						sizeof(subgroup.metadata));

 		if (!subgroup.metadata_len) {
 			shell_error(sh, "Could not parse metadata");
 			return -ENOEXEC;
 		}
 	}

 	param.num_subgroups = 1;
 	param.subgroups = &subgroup;

 	result = bt_bass_client_add_src(default_conn, &param);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_mod_src(const struct shell *sh, size_t argc,
 				   char **argv)
 {
 	int result;
 	struct bt_bass_mod_src_param param = { 0 };
 	struct bt_bass_subgroup subgroup = { 0 };

 	param.src_id = strtol(argv[1], NULL, 0);
 	if (param.src_id < 0 || param.src_id > UINT8_MAX) {
 		shell_error(sh, "adv_sid shall be 0x00-0xff");
 		return -ENOEXEC;
 	}

 	param.pa_sync = strtol(argv[2], NULL, 0);
 	if (param.pa_sync < 0 || param.pa_sync > 1) {
 		shell_error(sh, "pa_sync shall be boolean");
 		return -ENOEXEC;
 	}

 	if (argc > 3) {
 		param.pa_interval = strtol(argv[3], NULL, 0);
 	} else {
 		param.pa_interval = BT_BASS_PA_INTERVAL_UNKNOWN;
 	}

 	/* TODO: Support multiple subgroups */
 	if (argc > 3) {
 		subgroup.bis_sync = strtoul(argv[3], NULL, 0);
 		if (subgroup.bis_sync > UINT32_MAX) {
 			shell_error(sh,
 				    "bis_sync shall be 0x00000000 to 0xFFFFFFFF");
 			return -ENOEXEC;
 		}
 	}

 	if (argc > 5) {
 		subgroup.metadata_len = hex2bin(argv[5], strlen(argv[5]),
 						subgroup.metadata,
 						sizeof(subgroup.metadata));

 		if (!subgroup.metadata_len) {
 			shell_error(sh, "Could not parse metadata");
 			return -ENOEXEC;
 		}
 	}

 	param.num_subgroups = 1;
 	param.subgroups = &subgroup;

 	result = bt_bass_client_mod_src(default_conn, &param);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_broadcast_code(const struct shell *sh,
 					  size_t argc, char **argv)
 {
 	int result;
 	int src_id;
 	uint8_t broadcast_code[BT_BASS_BROADCAST_CODE_SIZE] = { 0 };

 	src_id = strtol(argv[1], NULL, 0);
 	if (src_id < 0 || src_id > UINT8_MAX) {
 		shell_error(sh, "adv_sid shall be 0x00-0xff");
 		return -ENOEXEC;
 	}

 	for (int i = 0; i < argc - 2; i++) {
 		broadcast_code[i] = strtol(argv[i + 2], NULL, 0);
 	}

 	result = bt_bass_client_set_broadcast_code(default_conn, src_id,
 						   broadcast_code);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_rem_src(const struct shell *sh, size_t argc,
 				   char **argv)
 {
 	int result;
 	int src_id;

 	src_id = strtol(argv[1], NULL, 0);
 	if (src_id < 0 || src_id > UINT8_MAX) {
 		shell_error(sh, "adv_sid shall be 0x00-0xff");
 		return -ENOEXEC;
 	}

 	result = bt_bass_client_rem_src(default_conn, src_id);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client_read_recv_state(const struct shell *sh,
 					   size_t argc, char **argv)
 {
 	int result;
 	int idx;

 	idx = strtol(argv[1], NULL, 0);
 	if (idx < 0 || idx > UINT8_MAX) {
 		shell_error(sh, "adv_sid shall be 0x00-0xff");
 		return -ENOEXEC;
 	}

 	result = bt_bass_client_read_recv_state(default_conn, idx);
 	if (result) {
 		shell_print(sh, "Fail: %d", result);
 	}

 	return result;
 }

 static int cmd_bass_client(const struct shell *sh, size_t argc, char **argv)
 {
 	if (argc > 1) {
 		shell_error(sh, "%s unknown parameter: %s",
 			    argv[0], argv[1]);
 	} else {
 		shell_error(sh, "%s Missing subcommand", argv[0]);
 	}

 	return -ENOEXEC;
 }

 SHELL_STATIC_SUBCMD_SET_CREATE(bass_client_cmds,
 	SHELL_CMD_ARG(discover, NULL,
 		      "Discover BASS on the server",
 		      cmd_bass_client_discover, 1, 0),
 	SHELL_CMD_ARG(scan_start, NULL,
 		      "Start scanning for broadcasters",
 		      cmd_bass_client_scan_start, 1, 0),
 	SHELL_CMD_ARG(scan_stop, NULL,
 		      "Stop scanning for BISs",
 		      cmd_bass_client_scan_stop, 1, 0),
 	SHELL_CMD_ARG(add_src, NULL,
 		      "Add a source <address: XX:XX:XX:XX:XX:XX> "
 		      "<type: public/random> <adv_sid> <sync_pa> "
 		      "<broadcast_id> [<pa_interval>] [<sync_bis>] "
 		      "[<metadata>]",
 		      cmd_bass_client_add_src, 6, 3),
 	SHELL_CMD_ARG(mod_src, NULL,
 		      "Set sync <src_id> <sync_pa> [<pa_interval>] "
 		      "[<sync_bis>] [<metadata>]",
 		      cmd_bass_client_mod_src, 3, 2),
 	SHELL_CMD_ARG(broadcast_code, NULL,
 		      "Send a space separated broadcast code of up to 16 bytes "
 		      "<src_id> [broadcast code]",
 		      cmd_bass_client_broadcast_code, 2, 16),
 	SHELL_CMD_ARG(rem_src, NULL,
 		      "Remove a source <src_id>",
 		      cmd_bass_client_rem_src, 2, 0),
 	SHELL_CMD_ARG(read_state, NULL,
 		      "Remove a source <index>",
 		      cmd_bass_client_read_recv_state, 2, 0),
 	SHELL_SUBCMD_SET_END
 );

 SHELL_CMD_ARG_REGISTER(bass_client, &bass_client_cmds,
 		       "Bluetooth BASS client shell commands",
 		       cmd_bass_client, 1, 1);
	/**
	* @file
	* @brief Shell APIs for Bluetooth BASS client
	*
	* Copyright (c) 2020-2021 Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/types.h>

	#include <zephyr/kernel.h>
	#include <zephyr/types.h>
	#include <zephyr/shell/shell.h>
	#include <stdlib.h>
	#include <zephyr/bluetooth/gatt.h>
	#include <zephyr/bluetooth/bluetooth.h>
	#include <zephyr/bluetooth/hci.h>
	#include <zephyr/bluetooth/audio/bass.h>
	#include "bt.h"
	#include "../host/hci_core.h"

	static void bass_client_discover_cb(struct bt_conn *conn, int err,
	uint8_t recv_state_count)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS discover failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS discover done with %u recv states",
	recv_state_count);
	}

	}

	static void bass_client_scan_cb(const struct bt_le_scan_recv_info *info,
	uint32_t broadcast_id)
	{
	char le_addr[BT_ADDR_LE_STR_LEN];
	char name[30];

	(void)memset(name, 0, sizeof(name));

	bt_addr_le_to_str(info->addr, le_addr, sizeof(le_addr));
	shell_print(ctx_shell, "[DEVICE]: %s (%s), broadcast_id %u, "
	"interval (ms) %u), SID 0x%x, RSSI %i",
	le_addr, name, broadcast_id, info->interval * 5 / 4,
	info->sid, info->rssi);

	}

	static bool metadata_entry(struct bt_data data, void user_data)
	{
	char metadata[512];

	bin2hex(data->data, data->data_len, metadata, sizeof(metadata));

	shell_print(ctx_shell, "\t\tMetadata length %u, type %u, data: %s",
	data->data_len, data->type, metadata);

	return true;
	}

	static void bass_client_recv_state_cb(struct bt_conn *conn, int err,
	const struct bt_bass_recv_state *state)
	{
	char le_addr[BT_ADDR_LE_STR_LEN];
	char bad_code[33];

	if (err != 0) {
	shell_error(ctx_shell, "BASS recv state read failed (%d)", err);
	return;
	}

	bt_addr_le_to_str(&state->addr, le_addr, sizeof(le_addr));
	bin2hex(state->bad_code, BT_BASS_BROADCAST_CODE_SIZE,
	bad_code, sizeof(bad_code));
	shell_print(ctx_shell, "BASS recv state: src_id %u, addr %s, "
	"sid %u, sync_state %u, encrypt_state %u%s%s",
	state->src_id, le_addr, state->adv_sid,
	state->pa_sync_state, state->encrypt_state,
	state->encrypt_state == BT_BASS_BIG_ENC_STATE_BAD_CODE ? ", bad code" : "",
	bad_code);

	for (int i = 0; i < state->num_subgroups; i++) {
	const struct bt_bass_subgroup *subgroup = &state->subgroups[i];
	struct net_buf_simple buf;

	shell_print(ctx_shell, "\t[%d]: BIS sync %u, metadata_len %u",
	i, subgroup->bis_sync, subgroup->metadata_len);

	net_buf_simple_init_with_data(&buf, (void *)subgroup->metadata,
	subgroup->metadata_len);
	bt_data_parse(&buf, metadata_entry, NULL);
	}


	if (state->pa_sync_state == BT_BASS_PA_STATE_INFO_REQ) {
	struct bt_le_per_adv_sync *per_adv_sync = NULL;
	struct bt_le_ext_adv *ext_adv = NULL;

	/* Lookup matching PA sync */
	for (int i = 0; i < ARRAY_SIZE(per_adv_syncs); i++) {
	if (per_adv_syncs[i] &&
	bt_addr_le_cmp(&per_adv_syncs[i]->addr,
	&state->addr) == 0) {
	per_adv_sync = per_adv_syncs[i];
	break;
	}
	}

	if (per_adv_sync) {
	shell_print(ctx_shell, "Sending PAST");

	err = bt_le_per_adv_sync_transfer(per_adv_sync,
	conn,
	BT_UUID_BASS_VAL);

	if (err != 0) {
	shell_error(ctx_shell, "Could not transfer periodic adv sync: %d",
	err);
	}

	return;
	}

	/* If no PA sync was found, check for local advertisers */
	for (int i = 0; i < ARRAY_SIZE(adv_sets); i++) {
	struct bt_le_oob oob_local;

	if (adv_sets[i] == NULL) {
	continue;
	}

	err = bt_le_ext_adv_oob_get_local(adv_sets[i],
	&oob_local);

	if (err != 0) {
	shell_error(ctx_shell,
	"Could not get local OOB %d",
	err);
	return;
	}

	if (bt_addr_le_cmp(&oob_local.addr,
	&state->addr) == 0) {
	ext_adv = adv_sets[i];
	break;
	}
	}

	if (ext_adv != NULL && IS_ENABLED(CONFIG_BT_PER_ADV)) {
	shell_print(ctx_shell, "Sending local PAST");

	err = bt_le_per_adv_set_info_transfer(ext_adv, conn,
	BT_UUID_BASS_VAL);

	if (err != 0) {
	shell_error(ctx_shell,
	"Could not transfer per adv set info: %d",
	err);
	}
	} else {
	shell_error(ctx_shell, "Could not send PA to BASS server");
	}
	}
	}

	static void bass_client_recv_state_removed_cb(struct bt_conn *conn, int err,
	uint8_t src_id)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS recv state removed failed (%d)",
	err);
	} else {
	shell_print(ctx_shell, "BASS recv state %u removed", src_id);
	}
	}

	static void bass_client_scan_start_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS scan start failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS scan start successful");
	}
	}

	static void bass_client_scan_stop_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS scan stop failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS scan stop successful");
	}
	}

	static void bass_client_add_src_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS add source failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS add source successful");
	}
	}

	static void bass_client_mod_src_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS modify source failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS modify source successful");
	}
	}

	static void bass_client_broadcast_code_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS broadcast code failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS broadcast code successful");
	}
	}

	static void bass_client_rem_src_cb(struct bt_conn *conn, int err)
	{
	if (err != 0) {
	shell_error(ctx_shell, "BASS remove source failed (%d)", err);
	} else {
	shell_print(ctx_shell, "BASS remove source successful");
	}
	}

	static struct bt_bass_client_cb cbs = {
	.discover = bass_client_discover_cb,
	.scan = bass_client_scan_cb,
	.recv_state = bass_client_recv_state_cb,
	.recv_state_removed = bass_client_recv_state_removed_cb,
	.scan_start = bass_client_scan_start_cb,
	.scan_stop = bass_client_scan_stop_cb,
	.add_src = bass_client_add_src_cb,
	.mod_src = bass_client_mod_src_cb,
	.broadcast_code = bass_client_broadcast_code_cb,
	.rem_src = bass_client_rem_src_cb,
	};

	static int cmd_bass_client_discover(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;

	bt_bass_client_register_cb(&cbs);

	result = bt_bass_client_discover(default_conn);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_scan_start(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;
	int start_scan = false;

	if (argc > 1) {
	start_scan = strtol(argv[1], NULL, 0);

	if (start_scan != 0 && start_scan != 1) {
	shell_error(sh, "Value shall be boolean");
	return -ENOEXEC;
	}
	}

	result = bt_bass_client_scan_start(default_conn, (bool)start_scan);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_scan_stop(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;

	result = bt_bass_client_scan_stop(default_conn);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_add_src(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;
	struct bt_bass_add_src_param param = { 0 };
	struct bt_bass_subgroup subgroup = { 0 };

	result = bt_addr_le_from_str(argv[1], argv[2], &param.addr);
	if (result) {
	shell_error(sh, "Invalid peer address (err %d)", result);
	return -ENOEXEC;
	}

	param.adv_sid = strtol(argv[3], NULL, 0);
	if (param.adv_sid < 0 \|\| param.adv_sid > 0x0F) {
	shell_error(sh, "adv_sid shall be 0x00-0x0f");
	return -ENOEXEC;
	}

	param.pa_sync = strtol(argv[4], NULL, 0);
	if (param.pa_sync < 0 \|\| param.pa_sync > 1) {
	shell_error(sh, "pa_sync shall be boolean");
	return -ENOEXEC;
	}

	param.broadcast_id = strtol(argv[5], NULL, 0);
	if (param.broadcast_id < 0 \|\|
	param.broadcast_id > 0xFFFFFF /* 24 bits */) {
	shell_error(sh, "Broadcast ID maximum 24 bits (was %x)",
	param.broadcast_id);
	return -ENOEXEC;
	}

	if (argc > 6) {
	param.pa_interval = strtol(argv[6], NULL, 0);
	} else {
	param.pa_interval = BT_BASS_PA_INTERVAL_UNKNOWN;
	}

	/* TODO: Support multiple subgroups */
	if (argc > 7) {
	subgroup.bis_sync = strtoul(argv[7], NULL, 0);
	if (subgroup.bis_sync > UINT32_MAX) {
	shell_error(sh,
	"bis_sync shall be 0x00000000 to 0xFFFFFFFF");
	return -ENOEXEC;
	}
	}

	if (argc > 8) {
	subgroup.metadata_len = hex2bin(argv[8], strlen(argv[8]),
	subgroup.metadata,
	sizeof(subgroup.metadata));

	if (!subgroup.metadata_len) {
	shell_error(sh, "Could not parse metadata");
	return -ENOEXEC;
	}
	}

	param.num_subgroups = 1;
	param.subgroups = &subgroup;

	result = bt_bass_client_add_src(default_conn, &param);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_mod_src(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;
	struct bt_bass_mod_src_param param = { 0 };
	struct bt_bass_subgroup subgroup = { 0 };

	param.src_id = strtol(argv[1], NULL, 0);
	if (param.src_id < 0 \|\| param.src_id > UINT8_MAX) {
	shell_error(sh, "adv_sid shall be 0x00-0xff");
	return -ENOEXEC;
	}

	param.pa_sync = strtol(argv[2], NULL, 0);
	if (param.pa_sync < 0 \|\| param.pa_sync > 1) {
	shell_error(sh, "pa_sync shall be boolean");
	return -ENOEXEC;
	}

	if (argc > 3) {
	param.pa_interval = strtol(argv[3], NULL, 0);
	} else {
	param.pa_interval = BT_BASS_PA_INTERVAL_UNKNOWN;
	}

	/* TODO: Support multiple subgroups */
	if (argc > 3) {
	subgroup.bis_sync = strtoul(argv[3], NULL, 0);
	if (subgroup.bis_sync > UINT32_MAX) {
	shell_error(sh,
	"bis_sync shall be 0x00000000 to 0xFFFFFFFF");
	return -ENOEXEC;
	}
	}

	if (argc > 5) {
	subgroup.metadata_len = hex2bin(argv[5], strlen(argv[5]),
	subgroup.metadata,
	sizeof(subgroup.metadata));

	if (!subgroup.metadata_len) {
	shell_error(sh, "Could not parse metadata");
	return -ENOEXEC;
	}
	}

	param.num_subgroups = 1;
	param.subgroups = &subgroup;

	result = bt_bass_client_mod_src(default_conn, &param);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_broadcast_code(const struct shell *sh,
	size_t argc, char **argv)
	{
	int result;
	int src_id;
	uint8_t broadcast_code[BT_BASS_BROADCAST_CODE_SIZE] = { 0 };

	src_id = strtol(argv[1], NULL, 0);
	if (src_id < 0 \|\| src_id > UINT8_MAX) {
	shell_error(sh, "adv_sid shall be 0x00-0xff");
	return -ENOEXEC;
	}

	for (int i = 0; i < argc - 2; i++) {
	broadcast_code[i] = strtol(argv[i + 2], NULL, 0);
	}

	result = bt_bass_client_set_broadcast_code(default_conn, src_id,
	broadcast_code);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_rem_src(const struct shell *sh, size_t argc,
	char **argv)
	{
	int result;
	int src_id;

	src_id = strtol(argv[1], NULL, 0);
	if (src_id < 0 \|\| src_id > UINT8_MAX) {
	shell_error(sh, "adv_sid shall be 0x00-0xff");
	return -ENOEXEC;
	}

	result = bt_bass_client_rem_src(default_conn, src_id);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client_read_recv_state(const struct shell *sh,
	size_t argc, char **argv)
	{
	int result;
	int idx;

	idx = strtol(argv[1], NULL, 0);
	if (idx < 0 \|\| idx > UINT8_MAX) {
	shell_error(sh, "adv_sid shall be 0x00-0xff");
	return -ENOEXEC;
	}

	result = bt_bass_client_read_recv_state(default_conn, idx);
	if (result) {
	shell_print(sh, "Fail: %d", result);
	}

	return result;
	}

	static int cmd_bass_client(const struct shell sh, size_t argc, char *argv)
	{
	if (argc > 1) {
	shell_error(sh, "%s unknown parameter: %s",
	argv[0], argv[1]);
	} else {
	shell_error(sh, "%s Missing subcommand", argv[0]);
	}

	return -ENOEXEC;
	}

	SHELL_STATIC_SUBCMD_SET_CREATE(bass_client_cmds,
	SHELL_CMD_ARG(discover, NULL,
	"Discover BASS on the server",
	cmd_bass_client_discover, 1, 0),
	SHELL_CMD_ARG(scan_start, NULL,
	"Start scanning for broadcasters",
	cmd_bass_client_scan_start, 1, 0),
	SHELL_CMD_ARG(scan_stop, NULL,
	"Stop scanning for BISs",
	cmd_bass_client_scan_stop, 1, 0),
	SHELL_CMD_ARG(add_src, NULL,
	"Add a source <address: XX:XX:XX:XX:XX:XX> "
	"<type: public/random> <adv_sid> <sync_pa> "
	"<broadcast_id> [<pa_interval>] [<sync_bis>] "
	"[<metadata>]",
	cmd_bass_client_add_src, 6, 3),
	SHELL_CMD_ARG(mod_src, NULL,
	"Set sync <src_id> <sync_pa> [<pa_interval>] "
	"[<sync_bis>] [<metadata>]",
	cmd_bass_client_mod_src, 3, 2),
	SHELL_CMD_ARG(broadcast_code, NULL,
	"Send a space separated broadcast code of up to 16 bytes "
	"<src_id> [broadcast code]",
	cmd_bass_client_broadcast_code, 2, 16),
	SHELL_CMD_ARG(rem_src, NULL,
	"Remove a source <src_id>",
	cmd_bass_client_rem_src, 2, 0),
	SHELL_CMD_ARG(read_state, NULL,
	"Remove a source <index>",
	cmd_bass_client_read_recv_state, 2, 0),
	SHELL_SUBCMD_SET_END
	);

	SHELL_CMD_ARG_REGISTER(bass_client, &bass_client_cmds,
	"Bluetooth BASS client shell commands",
	cmd_bass_client, 1, 1);