[Invisalign2] define tBTM_SP_EVT and tBTM_LE_EVT as enums (b3fbff91) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_sec.cc

+32 −50

Original line number	Diff line number	Diff line
		@@ -16,8 +16,6 @@

		#define LOG_TAG "bt_bta_dm_sec"

		#include <base/logging.h>

		#include <cstdint>

		#include "bta/dm/bta_dm_act.h"
		@@ -82,13 +80,12 @@ void btm_sec_on_hw_on() {
		void bta_dm_ble_sirk_sec_cb_register(tBTA_DM_SEC_CBACK* p_cback) {
		/* Save the callback to be called when a request of member validation will be
		* needed. */
		LOG_DEBUG("");
		bta_dm_sec_cb.p_sec_sirk_cback = p_cback;
		}

		void bta_dm_ble_sirk_confirm_device_reply(const RawAddress& bd_addr,
		bool accept) {
		LOG_DEBUG("");
		LOG_DEBUG("addr:%s", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
		get_btm_client_interface().security.BTM_BleSirkConfirmDeviceReply(
		bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED);
		}
		@@ -140,8 +137,7 @@ void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
		msg->bd_addr, dc, msg->bd_name, nullptr, p_lc, msg->key_type,
		msg->pin_length);
		if (!add_result) {
		LOG(ERROR) << "BTA_DM: Error adding device "
		<< ADDRESS_TO_LOGGABLE_STR(msg->bd_addr);
		LOG_ERROR("Error adding device:%s", ADDRESS_TO_LOGGABLE_CSTR(msg->bd_addr));
		}
		}

		@@ -189,7 +185,7 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) {
		tBTM_STATUS status;
		tBTA_DM_SEC sec_event;

		LOG_VERBOSE(" bta_dm_bond_cancel ");
		LOG_DEBUG("addr:%s", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

		status = get_btm_client_interface().security.BTM_SecBondCancel(bd_addr);

		@@ -311,7 +307,8 @@ static uint8_t bta_dm_pin_cback(const RawAddress& bd_addr, DEV_CLASS dev_class,
		BTM_CMD_STARTED)
		return BTM_CMD_STARTED;

		LOG_WARN(" bta_dm_pin_cback() -> Failed to start Remote Name Request ");
		LOG_WARN("Failed to start Remote Name Request, addr:%s",
		ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
		}

		tBTA_DM_SEC sec_event = {.pin_req = {
		@@ -413,9 +410,7 @@ static void bta_dm_authentication_complete_cback(
		case HCI_ERR_KEY_MISSING:
		case HCI_ERR_HOST_REJECT_SECURITY:
		case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
		LOG_WARN(
		"Deleting device record as authentication failed entry:%s "
		"reason:%s",
		LOG_WARN("authentication failed entry:%s, reason:%s",
		ADDRESS_TO_LOGGABLE_CSTR(bd_addr),
		hci_reason_code_text(reason).c_str());
		break;
		@@ -441,7 +436,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
		tBTA_DM_SEC sec_event = {};
		tBTA_DM_SEC_EVT pin_evt = BTA_DM_SP_KEY_NOTIF_EVT;

		LOG_VERBOSE("bta_dm_sp_cback: %d", event);
		LOG_VERBOSE("event:%s", sp_evt_to_text(event).c_str());
		if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

		bool sp_rmt_result = false;
		@@ -534,8 +529,8 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
		p_data->key_notif.bd_addr, bta_dm_pinname_cback,
		BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)
		return BTM_CMD_STARTED;
		LOG_WARN(
		" bta_dm_sp_cback() -> Failed to start Remote Name Request ");
		LOG_WARN("Failed to start Remote Name Request, addr:%s",
		ADDRESS_TO_LOGGABLE_CSTR(p_data->key_notif.bd_addr));
		} else {
		sec_event.key_notif.bd_addr = p_data->key_notif.bd_addr;
		sec_event.key_notif.dev_class = p_data->key_notif.dev_class;
		@@ -564,7 +559,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
		#ifdef BTIF_DM_OOB_TEST
		sp_rmt_result = btif_dm_proc_rmt_oob(p_data->rmt_oob.bd_addr, &c, &r);
		#endif
		LOG_VERBOSE("bta_dm_ci_rmt_oob: result=%d", sp_rmt_result);
		LOG_VERBOSE("result=%d", sp_rmt_result);
		bta_dm_ci_rmt_oob(sp_rmt_result, p_data->rmt_oob.bd_addr, c, r);
		break;
		}
		@@ -620,8 +615,8 @@ static void bta_dm_remove_sec_dev_entry(const RawAddress& remote_bd_addr) {
		BT_TRANSPORT_LE) \|\|
		get_btm_client_interface().peer.BTM_IsAclConnectionUp(
		remote_bd_addr, BT_TRANSPORT_BR_EDR)) {
		LOG_VERBOSE("%s ACL is not down. Schedule for Dev Removal when ACL closes",
		__func__);
		LOG_DEBUG("ACL is not down. Schedule for Dev Removal when ACL closes:%s",
		ADDRESS_TO_LOGGABLE_CSTR(remote_bd_addr));
		get_btm_client_interface().security.BTM_SecClearSecurityFlags(
		remote_bd_addr);
		for (int i = 0; i < bta_dm_cb.device_list.count; i++) {
		@@ -718,6 +713,9 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
		tBTA_DM_SEC sec_event;
		const char* p_name = NULL;

		LOG_DEBUG("addr:%s,event:%s", ADDRESS_TO_LOGGABLE_CSTR(bda),
		ble_evt_to_text(event).c_str());

		if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

		memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
		@@ -726,7 +724,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
		ble_io_req(bda, &p_data->io_req.io_cap, &p_data->io_req.oob_data,
		&p_data->io_req.auth_req, &p_data->io_req.max_key_size,
		&p_data->io_req.init_keys, &p_data->io_req.resp_keys);
		LOG_VERBOSE("io mitm: %d oob_data:%d", p_data->io_req.auth_req,
		LOG_INFO("io mitm:%d oob_data:%d", p_data->io_req.auth_req,
		p_data->io_req.oob_data);
		break;

		@@ -822,9 +820,9 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
		// Bonded device failed to encrypt - to test this remove battery from
		// HID device right after connection, but before encryption is
		// established
		LOG(INFO) << __func__
		<< ": bonded device disconnected when encrypting - no "
		"reason to unbond";
		LOG_WARN(
		"bonded device disconnected when encrypting - no reason to "
		"unbond");
		} else {
		/* delete this device entry from Sec Dev DB */
		bta_dm_remove_sec_dev_entry(bda);
		@@ -873,47 +871,30 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
		device->p_encrypt_cback = nullptr;
		}

		tBTA_STATUS bta_status = BTA_SUCCESS;
		switch (result) {
		case BTM_SUCCESS:
		LOG_WARN("Encrypted link peer:%s transport:%s status:%s callback:%c",
		LOG_DEBUG("Encrypted:%c, peer:%s transport:%s status:%s callback:%c",
		result == BTM_SUCCESS ? 'T' : 'F',
		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
		bt_transport_text(transport).c_str(),
		btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

		tBTA_STATUS bta_status = BTA_SUCCESS;
		switch (result) {
		case BTM_SUCCESS:
		break;
		case BTM_WRONG_MODE:
		LOG_WARN(
		"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
		bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
		(p_callback) ? 'T' : 'F');
		bta_status = BTA_WRONG_MODE;
		break;
		case BTM_NO_RESOURCES:
		LOG_WARN(
		"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
		bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
		(p_callback) ? 'T' : 'F');
		bta_status = BTA_NO_RESOURCES;
		break;
		case BTM_BUSY:
		LOG_WARN(
		"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
		bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
		(p_callback) ? 'T' : 'F');
		bta_status = BTA_BUSY;
		break;
		default:
		LOG_ERROR(
		"Failed to encrypt link peer:%s transport:%s status:%s callback:%c",
		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
		bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
		(p_callback) ? 'T' : 'F');
		bta_status = BTA_FAILURE;
		break;
		}

		if (p_callback) {
		(p_callback)(bd_addr, transport, bta_status);
		}
		@@ -924,7 +905,8 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTA_DM_ENCRYPT_CBACK* p_callback,
		tBTM_BLE_SEC_ACT sec_act) {
		if (p_callback == nullptr) {
		LOG_ERROR("bta_dm_set_encryption callback is not provided");
		LOG_ERROR("callback is not provided,addr:%s",
		ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
		return;
		}

system/stack/btm/btm_ble_sec.cc

+4 −4

Original line number	Diff line number	Diff line
		@@ -1599,8 +1599,8 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,
		* capability... */
		LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",
		btm_sec_cb.api.p_le_callback);
		(*btm_sec_cb.api.p_le_callback)(event, bd_addr,
		(tBTM_LE_EVT_DATA*)p_data);
		(*btm_sec_cb.api.p_le_callback)(static_cast<tBTM_LE_EVT>(event),
		bd_addr, (tBTM_LE_EVT_DATA*)p_data);
		}

		if (event == SMP_COMPLT_EVT) {
		@@ -1677,8 +1677,8 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,
		if (btm_sec_cb.api.p_le_callback) {
		LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",
		btm_sec_cb.api.p_le_callback);
		(*btm_sec_cb.api.p_le_callback)(event, bd_addr,
		(tBTM_LE_EVT_DATA*)p_data);
		(*btm_sec_cb.api.p_le_callback)(static_cast<tBTM_LE_EVT>(event),
		bd_addr, (tBTM_LE_EVT_DATA*)p_data);
		}
		break;

system/stack/btm/btm_sec.cc

+13 −13

Original line number	Diff line number	Diff line
		@@ -2675,8 +2675,8 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
		tBTM_SEC_DEV_REC* p_dev_rec;

		p_bda = bda;
		LOG_VERBOSE("BDA: %s, event: 0x%x, state: %s",
		ADDRESS_TO_LOGGABLE_CSTR(p_bda), event,
		LOG_DEBUG("BDA:%s, event:%s, state:%s", ADDRESS_TO_LOGGABLE_CSTR(p_bda),
		sp_evt_to_text(event).c_str(),
		tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state));

		p_dev_rec = btm_find_dev(p_bda);
		@@ -2696,8 +2696,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,

		/* The device record must be allocated in the "IO cap exchange" step */
		evt_data.cfm_req.num_val = value;
		LOG_VERBOSE("BTM_SP_CFM_REQ_EVT: num_val: %u",
		evt_data.cfm_req.num_val);
		LOG_VERBOSE("num_val:%u", evt_data.cfm_req.num_val);

		evt_data.cfm_req.just_works = true;

		@@ -2725,11 +2724,10 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
		}
		}

		LOG_VERBOSE(
		"btm_proc_sp_req_evt() just_works:%d, io loc:%d, rmt:%d, auth "
		"loc:%d, rmt:%d",
		LOG_VERBOSE("just_works:%d, io loc:%d, rmt:%d, auth loc:%d, rmt:%d",
		evt_data.cfm_req.just_works, btm_sec_cb.devcb.loc_io_caps,
		p_dev_rec->sec_rec.rmt_io_caps, btm_sec_cb.devcb.loc_auth_req,
		p_dev_rec->sec_rec.rmt_io_caps,
		btm_sec_cb.devcb.loc_auth_req,
		p_dev_rec->sec_rec.rmt_auth_req);

		evt_data.cfm_req.loc_auth_req = btm_sec_cb.devcb.loc_auth_req;
		@@ -2741,8 +2739,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
		case BTM_SP_KEY_NOTIF_EVT:
		/* Passkey notification (other side is a keyboard) */
		evt_data.key_notif.passkey = value;
		LOG_VERBOSE("BTM_SP_KEY_NOTIF_EVT: passkey: %u",
		evt_data.key_notif.passkey);
		LOG_VERBOSE("passkey:%u", evt_data.key_notif.passkey);

		btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);
		break;
		@@ -2753,6 +2750,9 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
		btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_KEY_ENTRY);
		}
		break;
		default:
		LOG_WARN("unhandled event:%s", sp_evt_to_text(event).c_str());
		break;
		}

		if (btm_sec_cb.api.p_sp_callback) {

system/stack/btu/btu_hcif.cc

+8 −6

Original line number	Diff line number	Diff line
		@@ -31,7 +31,6 @@

		#include <base/functional/bind.h>
		#include <base/location.h>
		#include <base/logging.h>

		#include <cstdint>

		@@ -1128,7 +1127,7 @@ static void btu_hcif_hdl_command_complete(uint16_t opcode, uint8_t* p,
		case HCI_BLE_CREATE_LL_CONN:
		case HCI_LE_EXTENDED_CREATE_CONNECTION:
		// No command complete event for those commands according to spec
		LOG(ERROR) << "No command complete expected, but received!";
		LOG_ERROR("No command complete expected, but received!");
		break;

		case HCI_BLE_TRANSMITTER_TEST:
		@@ -1459,6 +1458,9 @@ void btu_hcif_proc_sp_req_evt(tBTM_SP_EVT event, const uint8_t* p) {
		case BTM_SP_KEY_REQ_EVT:
		// No value needed.
		break;
		default:
		LOG_WARN("unexpected event:%s", sp_evt_to_text(event).c_str());
		break;
		}
		btm_proc_sp_req_evt(event, bda, value);
		}
		@@ -1466,7 +1468,7 @@ void btu_hcif_create_conn_cancel_complete(const uint8_t* p, uint16_t evt_len) {
		uint8_t status;

		if (evt_len < 1 + BD_ADDR_LEN) {
		LOG_ERROR("%s malformatted event packet, too short", __func__);
		LOG_ERROR("malformatted event packet, too short");
		return;
		}

		@@ -1496,7 +1498,7 @@ void btu_hcif_read_local_oob_complete(const uint8_t* p, uint16_t evt_len) {
		return;

		err_out:
		LOG_ERROR("%s: bogus event packet, too short", __func__);
		LOG_ERROR("bogus event packet, too short");
		}

		/*******************************************************************************
		@@ -1662,7 +1664,7 @@ static void btu_ble_data_length_change_evt(uint8_t* p, uint16_t evt_len) {
		uint16_t rx_data_len;

		if (!controller_get_interface()->SupportsBleDataPacketLengthExtension()) {
		LOG_WARN("%s, request not supported", __func__);
		LOG_WARN("request not supported");
		return;
		}

		@@ -1688,7 +1690,7 @@ static void btu_ble_rc_param_req_evt(uint8_t* p, uint8_t len) {
		uint16_t int_min, int_max, latency, timeout;

		if (len < 10) {
		LOG(ERROR) << __func__ << "bogus event packet, too short";
		LOG_ERROR("bogus event packet, too short");
		return;
		}

system/stack/include/btm_sec_api_types.h

+75 −32

Original line number	Diff line number	Diff line
		@@ -173,7 +173,7 @@ typedef uint8_t tBTM_LINK_KEY_TYPE;
		* trusted services
		******************************************************************************/

		enum {
		typedef enum : uint8_t {
		BTM_SP_IO_REQ_EVT, /* received IO_CAPABILITY_REQUEST event */
		BTM_SP_IO_RSP_EVT, /* received IO_CAPABILITY_RESPONSE event */
		BTM_SP_CFM_REQ_EVT, /* received USER_CONFIRMATION_REQUEST event */
		@@ -181,8 +181,21 @@ enum {
		BTM_SP_KEY_REQ_EVT, /* received USER_PASSKEY_REQUEST event */
		BTM_SP_LOC_OOB_EVT, /* received result for READ_LOCAL_OOB_DATA command */
		BTM_SP_RMT_OOB_EVT, /* received REMOTE_OOB_DATA_REQUEST event */
		};
		typedef uint8_t tBTM_SP_EVT;
		} tBTM_SP_EVT;

		inline std::string sp_evt_to_text(const tBTM_SP_EVT evt) {
		switch (evt) {
		CASE_RETURN_TEXT(BTM_SP_IO_REQ_EVT);
		CASE_RETURN_TEXT(BTM_SP_IO_RSP_EVT);
		CASE_RETURN_TEXT(BTM_SP_CFM_REQ_EVT);
		CASE_RETURN_TEXT(BTM_SP_KEY_NOTIF_EVT);
		CASE_RETURN_TEXT(BTM_SP_KEY_REQ_EVT);
		CASE_RETURN_TEXT(BTM_SP_LOC_OOB_EVT);
		CASE_RETURN_TEXT(BTM_SP_RMT_OOB_EVT);
		}

		return base::StringPrintf("UNKNOWN[%hhu]", evt);
		}

		enum : uint8_t {
		BTM_IO_CAP_OUT = 0, /* DisplayOnly */
		@@ -372,35 +385,65 @@ typedef tBTM_SEC_CALLBACK tBTM_SEC_CALLBACK;
		*/
		typedef void(tBTM_BOND_CANCEL_CMPL_CALLBACK)(tBTM_STATUS result);

		typedef enum : uint8_t {
		/* LE related event and data structure */
		/* received IO_CAPABILITY_REQUEST event */
		#define BTM_LE_IO_REQ_EVT SMP_IO_CAP_REQ_EVT
		BTM_LE_IO_REQ_EVT = SMP_IO_CAP_REQ_EVT,
		/* security request event */
		#define BTM_LE_SEC_REQUEST_EVT SMP_SEC_REQUEST_EVT
		BTM_LE_SEC_REQUEST_EVT = SMP_SEC_REQUEST_EVT,

		/* received USER_PASSKEY_NOTIFY event */
		#define BTM_LE_KEY_NOTIF_EVT SMP_PASSKEY_NOTIF_EVT
		BTM_LE_KEY_NOTIF_EVT = SMP_PASSKEY_NOTIF_EVT,

		/* received USER_PASSKEY_REQUEST event */
		#define BTM_LE_KEY_REQ_EVT SMP_PASSKEY_REQ_EVT
		BTM_LE_KEY_REQ_EVT = SMP_PASSKEY_REQ_EVT,

		/* OOB data request event */
		#define BTM_LE_OOB_REQ_EVT SMP_OOB_REQ_EVT
		BTM_LE_OOB_REQ_EVT = SMP_OOB_REQ_EVT,

		/* Numeric Comparison request event */
		#define BTM_LE_NC_REQ_EVT SMP_NC_REQ_EVT
		BTM_LE_NC_REQ_EVT = SMP_NC_REQ_EVT,

		/* Peer keypress notification recd event */
		#define BTM_LE_PR_KEYPR_NOT_EVT SMP_PEER_KEYPR_NOT_EVT
		BTM_LE_PR_KEYPR_NOT_EVT = SMP_PEER_KEYPR_NOT_EVT,

		/* SC OOB request event (both local and peer OOB data) can be expected in
		* response */
		#define BTM_LE_SC_OOB_REQ_EVT SMP_SC_OOB_REQ_EVT
		BTM_LE_SC_OOB_REQ_EVT = SMP_SC_OOB_REQ_EVT,

		/* SC OOB local data set is created (as result of SMP_CrLocScOobData(...)) */
		#define BTM_LE_SC_LOC_OOB_EVT SMP_SC_LOC_OOB_DATA_UP_EVT
		BTM_LE_SC_LOC_OOB_EVT = SMP_SC_LOC_OOB_DATA_UP_EVT,
		/* SMP complete event */
		#define BTM_LE_COMPLT_EVT SMP_COMPLT_EVT
		#define BTM_LE_LAST_FROM_SMP SMP_BR_KEYS_REQ_EVT
		BTM_LE_COMPLT_EVT = SMP_COMPLT_EVT,
		BTM_LE_LAST_FROM_SMP = SMP_BR_KEYS_REQ_EVT,
		/* KEY update event */
		#define BTM_LE_KEY_EVT (BTM_LE_LAST_FROM_SMP + 1)
		#define BTM_LE_CONSENT_REQ_EVT SMP_CONSENT_REQ_EVT
		BTM_LE_KEY_EVT = (BTM_LE_LAST_FROM_SMP + 1),
		BTM_LE_CONSENT_REQ_EVT = SMP_CONSENT_REQ_EVT,

		/* Identity address associate event */
		#define BTM_LE_ADDR_ASSOC_EVT SMP_LE_ADDR_ASSOC_EVT
		typedef uint8_t tBTM_LE_EVT;
		BTM_LE_ADDR_ASSOC_EVT = SMP_LE_ADDR_ASSOC_EVT,
		} tBTM_LE_EVT;

		inline std::string ble_evt_to_text(const tBTM_LE_EVT evt) {
		switch (evt) {
		CASE_RETURN_TEXT(BTM_LE_IO_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_SEC_REQUEST_EVT);
		CASE_RETURN_TEXT(BTM_LE_KEY_NOTIF_EVT);
		CASE_RETURN_TEXT(BTM_LE_KEY_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_OOB_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_NC_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_PR_KEYPR_NOT_EVT);
		CASE_RETURN_TEXT(BTM_LE_SC_OOB_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_SC_LOC_OOB_EVT);
		CASE_RETURN_TEXT(BTM_LE_COMPLT_EVT);
		CASE_RETURN_TEXT(BTM_LE_LAST_FROM_SMP);
		CASE_RETURN_TEXT(BTM_LE_KEY_EVT);
		CASE_RETURN_TEXT(BTM_LE_CONSENT_REQ_EVT);
		CASE_RETURN_TEXT(BTM_LE_ADDR_ASSOC_EVT);
		}

		return base::StringPrintf("UNKNOWN[%hhu]", evt);
		}

		enum : uint8_t {
		BTM_LE_KEY_NONE = 0,