Enum-ify stack::sdp::tSDP_FLAGS,tSDP_DISC_WAIT,tSDP_STATE am: 2d7274bf12 am:... (2f4cdab1) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_api.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -79,8 +79,6 @@ inline std::string bta_status_text(const tBTA_STATUS& status) {

		#undef CASE_RETURN_TEXT

		using tSDP_DISC_WAIT = int;

		/*
		* Service ID
		*/

system/stack/sdp/sdpint.h

+57 −18

Original line number	Diff line number	Diff line
		@@ -124,18 +124,65 @@ typedef struct {
		attributes in the responses */
		} tSDP_CONT_INFO;

		enum : uint8_t {
		SDP_STATE_IDLE = 0,
		SDP_STATE_CONN_SETUP = 1,
		SDP_STATE_CFG_SETUP = 2,
		SDP_STATE_CONNECTED = 3,
		SDP_STATE_CONN_PEND = 4,
		};
		typedef uint8_t tSDP_STATE;

		#ifndef CASE_RETURN_TEXT
		#define CASE_RETURN_TEXT(code) \
		case code: \
		return #code
		#endif

		inline std::string sdp_state_text(const tSDP_STATE& state) {
		switch (state) {
		CASE_RETURN_TEXT(SDP_STATE_IDLE);
		CASE_RETURN_TEXT(SDP_STATE_CONN_SETUP);
		CASE_RETURN_TEXT(SDP_STATE_CFG_SETUP);
		CASE_RETURN_TEXT(SDP_STATE_CONNECTED);
		CASE_RETURN_TEXT(SDP_STATE_CONN_PEND);
		default:
		return std::string("UNKNOWN[") + std::to_string(state) + std::string("]");
		}
		}

		enum : uint8_t {
		SDP_FLAGS_IS_ORIG = 0x01,
		SDP_FLAGS_HIS_CFG_DONE = 0x02,
		SDP_FLAGS_MY_CFG_DONE = 0x04,
		};
		typedef uint8_t tSDP_FLAGS;

		inline std::string sdp_flags_text(const tSDP_FLAGS& flags) {
		switch (flags) {
		CASE_RETURN_TEXT(SDP_FLAGS_IS_ORIG);
		CASE_RETURN_TEXT(SDP_FLAGS_HIS_CFG_DONE);
		CASE_RETURN_TEXT(SDP_FLAGS_MY_CFG_DONE);
		default:
		return std::string("UNKNOWN[") + std::to_string(flags) + std::string("]");
		}
		}

		#undef CASE_RETURN_TEXT

		enum : uint8_t {
		SDP_DISC_WAIT_CONN = 0,
		SDP_DISC_WAIT_HANDLES = 1,
		SDP_DISC_WAIT_ATTR = 2,
		SDP_DISC_WAIT_SEARCH_ATTR = 3,
		SDP_DISC_WAIT_UNUSED4 = 4,
		SDP_DISC_WAIT_CANCEL = 5,
		};
		typedef uint8_t tSDP_DISC_WAIT;

		/* Define the SDP Connection Control Block */
		struct tCONN_CB {
		#define SDP_STATE_IDLE 0
		#define SDP_STATE_CONN_SETUP 1
		#define SDP_STATE_CFG_SETUP 2
		#define SDP_STATE_CONNECTED 3
		#define SDP_STATE_CONN_PEND 4
		uint8_t con_state;

		#define SDP_FLAGS_IS_ORIG 0x01
		#define SDP_FLAGS_HIS_CFG_DONE 0x02
		#define SDP_FLAGS_MY_CFG_DONE 0x04
		uint8_t con_flags;

		RawAddress device_address;
		@@ -159,12 +206,6 @@ struct tCONN_CB {
		uint16_t transaction_id;
		uint16_t disconnect_reason; /* Disconnect reason */

		#define SDP_DISC_WAIT_CONN 0
		#define SDP_DISC_WAIT_HANDLES 1
		#define SDP_DISC_WAIT_ATTR 2
		#define SDP_DISC_WAIT_SEARCH_ATTR 3
		#define SDP_DISC_WAIT_CANCEL 5

		uint8_t disc_state;
		bool is_attr_search;

		@@ -183,9 +224,7 @@ struct tCONN_CB {
		return #code
		#endif

		using tSDP_DISC_WAIT = int;

		inline std::string discovery_state_text(const tSDP_DISC_WAIT& state) {
		inline std::string sdp_disc_wait_text(const tSDP_DISC_WAIT& state) {
		switch (state) {
		CASE_RETURN_TEXT(SDP_DISC_WAIT_CONN);
		CASE_RETURN_TEXT(SDP_DISC_WAIT_HANDLES);

system/stack/test/sdp/stack_sdp_test.cc

+41 −6

Original line number	Diff line number	Diff line
		@@ -173,7 +173,7 @@ TEST_F(StackSdpMainTest, sdp_service_search_request_queuing_race_condition) {
		sdp_disconnect(p_ccb2, SDP_SUCCESS);
		}

		TEST_F(StackSdpMainTest, discovery_state_text) {
		TEST_F(StackSdpMainTest, sdp_disc_wait_text) {
		std::vector<std::pair<tSDP_DISC_WAIT, std::string>> states = {
		std::make_pair(SDP_DISC_WAIT_CONN, "SDP_DISC_WAIT_CONN"),
		std::make_pair(SDP_DISC_WAIT_HANDLES, "SDP_DISC_WAIT_HANDLES"),
		@@ -182,13 +182,48 @@ TEST_F(StackSdpMainTest, discovery_state_text) {
		std::make_pair(SDP_DISC_WAIT_CANCEL, "SDP_DISC_WAIT_CANCEL"),
		};
		for (const auto& state : states) {
		ASSERT_STREQ(state.second.c_str(),
		discovery_state_text(state.first).c_str());
		ASSERT_STREQ(state.second.c_str(), sdp_disc_wait_text(state.first).c_str());
		}
		auto unknown =
		base::StringPrintf("UNKNOWN[%d]", std::numeric_limits<int>::max());
		base::StringPrintf("UNKNOWN[%d]", std::numeric_limits<uint8_t>::max());
		ASSERT_STREQ(unknown.c_str(),
		discovery_state_text(
		static_cast<tSDP_DISC_WAIT>(std::numeric_limits<int>::max()))
		sdp_disc_wait_text(static_cast<tSDP_DISC_WAIT>(
		std::numeric_limits<uint8_t>::max()))
		.c_str());
		}

		TEST_F(StackSdpMainTest, sdp_state_text) {
		std::vector<std::pair<tSDP_STATE, std::string>> states = {
		std::make_pair(SDP_STATE_IDLE, "SDP_STATE_IDLE"),
		std::make_pair(SDP_STATE_CONN_SETUP, "SDP_STATE_CONN_SETUP"),
		std::make_pair(SDP_STATE_CFG_SETUP, "SDP_STATE_CFG_SETUP"),
		std::make_pair(SDP_STATE_CONNECTED, "SDP_STATE_CONNECTED"),
		std::make_pair(SDP_STATE_CONN_PEND, "SDP_STATE_CONN_PEND"),
		};
		for (const auto& state : states) {
		ASSERT_STREQ(state.second.c_str(), sdp_state_text(state.first).c_str());
		}
		auto unknown = base::StringPrintf("UNKNOWN[%hhu]",
		std::numeric_limits<std::uint8_t>::max());
		ASSERT_STREQ(unknown.c_str(),
		sdp_state_text(static_cast<tSDP_STATE>(
		std::numeric_limits<std::uint8_t>::max()))
		.c_str());
		}

		TEST_F(StackSdpMainTest, sdp_flags_text) {
		std::vector<std::pair<tSDP_DISC_WAIT, std::string>> flags = {
		std::make_pair(SDP_FLAGS_IS_ORIG, "SDP_FLAGS_IS_ORIG"),
		std::make_pair(SDP_FLAGS_HIS_CFG_DONE, "SDP_FLAGS_HIS_CFG_DONE"),
		std::make_pair(SDP_FLAGS_MY_CFG_DONE, "SDP_FLAGS_MY_CFG_DONE"),
		};
		for (const auto& flag : flags) {
		ASSERT_STREQ(flag.second.c_str(), sdp_flags_text(flag.first).c_str());
		}
		auto unknown =
		base::StringPrintf("UNKNOWN[%hhu]", std::numeric_limits<uint8_t>::max());
		ASSERT_STREQ(unknown.c_str(),
		sdp_flags_text(static_cast<tSDP_DISC_WAIT>(
		std::numeric_limits<uint8_t>::max()))
		.c_str());
		}