Device class implementation (fe9f8e88) · Commits · e / os / android_packages_modules_Bluetooth

system/btcore/Android.mk

+3 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@ LOCAL_C_INCLUDES := \
		LOCAL_SRC_FILES := \
		src/bdaddr.c \
		src/counter.c \
		src/device_class.c \
		src/module.c \
		src/property.c \
		src/uuid.c
		@@ -51,11 +52,13 @@ LOCAL_C_INCLUDES := \
		LOCAL_SRC_FILES := \
		./test/bdaddr_test.cpp \
		./test/counter_test.cpp \
		./test/device_class_test.cpp \
		./test/uuid_test.cpp \
		../osi/test/AllocationTestHarness.cpp

		LOCAL_CFLAGS := -Wall -Werror -Werror=unused-variable
		LOCAL_MODULE := net_test_btcore

		LOCAL_MODULE_TAGS := tests
		LOCAL_SHARED_LIBRARIES := liblog
		LOCAL_STATIC_LIBRARIES := libbtcore libosi

system/btcore/include/device_class.h

0 → 100644

+92 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright (C) 2014 Google, Inc.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*
		******************************************************************************/

		#pragma once

		#include <stdbool.h>
		#include <stdint.h>

		// Provides Class Of Device primitive as specified in the bluetooth spec.
		// [Class Of Device](https://www.bluetooth.org/en-us/specification/assigned-numbers/baseband)

		// Device class may be defined in other structures.
		// Only use defined methods to manipulate internals.
		typedef struct bt_device_class_t {
		uint8_t _[3]; // Do not access directly; use methods below.
		} bt_device_class_t;

		// Copies the \|data\| class of device stream into device class \|dc\|. \|dc\|
		// and \|data\| must not be NULL.
		void device_class_from_stream(bt_device_class_t dc, const uint8_t data);

		// Serializes the device class \|dc\| to pointer argument \|data\| in big endian
		// format. \|len\| must contain the buffer size of \|data\|. Returns the actual
		// number of bytes copied into \|data\|. \|dc\| and \|data\| must not be NULL.
		int device_class_to_stream(const bt_device_class_t dc, uint8_t data, size_t len);

		// Copies the \|data\| class of device integer into device class \|dc\|. \|dc\|
		// must not be NULL.
		void device_class_from_int(bt_device_class_t *dc, int data);

		// Returns the device class \|dc\| in integer format. \|dc\| must not be NULL.
		int device_class_to_int(const bt_device_class_t *dc);

		// Compares and returns \|true\| if two device classes \|p1\| and \|p2\| are equal.
		// False otherwise.
		bool device_class_equals(const bt_device_class_t p1, const bt_device_class_t p2);

		// Copies and returns \|true\| if the device class was successfully copied from
		// \|p2\| into \|p1\|. False otherwise.
		bool device_class_copy(bt_device_class_t dest, const bt_device_class_t src);

		// Query, getters and setters for the major device class. \|dc\| must not be NULL.
		int device_class_get_major_device(const bt_device_class_t *dc);
		void device_class_set_major_device(bt_device_class_t *dc, int val);

		// Query, getters and setters for the minor device class. \|dc\| must not be NULL.
		int device_class_get_minor_device(const bt_device_class_t *dc);
		void device_class_set_minor_device(bt_device_class_t *dc, int val);

		// Query, getters and setters for the various major service class features.
		// \|dc\| must not be NULL.
		bool device_class_get_limited(const bt_device_class_t *dc);
		void device_class_set_limited(bt_device_class_t *dc, bool set);

		bool device_class_get_positioning(const bt_device_class_t *dc);
		void device_class_set_positioning(bt_device_class_t *dc, bool set);

		bool device_class_get_networking(const bt_device_class_t *dc);
		void device_class_set_networking(bt_device_class_t *dc, bool set);

		bool device_class_get_rendering(const bt_device_class_t *dc);
		void device_class_set_rendering(bt_device_class_t *dc, bool set);

		bool device_class_get_capturing(const bt_device_class_t *dc);
		void device_class_set_capturing(bt_device_class_t *dc, bool set);

		bool device_class_get_object_transfer(const bt_device_class_t *dc);
		void device_class_set_object_transfer(bt_device_class_t *dc, bool set);

		bool device_class_get_audio(const bt_device_class_t *dc);
		void device_class_set_audio(bt_device_class_t *dc, bool set);

		bool device_class_get_telephony(const bt_device_class_t *dc);
		void device_class_set_telephony(bt_device_class_t *dc, bool set);

		bool device_class_get_information(const bt_device_class_t *dc);
		void device_class_set_information(bt_device_class_t *dc, bool set);

system/btcore/src/device_class.c

0 → 100644

+158 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright (C) 2014 Google, Inc.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*
		******************************************************************************/

		#include <arpa/inet.h>
		#include <assert.h>
		#include <string.h>

		#include "btcore/include/device_class.h"
		#include "osi/include/osi.h"

		typedef struct _bt_device_class_t {
		uint32_t unused : 2; // LSBs
		uint32_t minor_device : 6;
		uint32_t major_device : 5;
		uint32_t major_service : 11; // MSBs
		} __attribute__ ((__packed__)) _bt_device_class_t;

		// Convenience to interpret raw device class bytes.
		#define DC(x) ((_bt_device_class_t *)x)

		// Ensure the internal device class implementation and public one
		// have equal size.
		COMPILE_ASSERT(sizeof(_bt_device_class_t) == sizeof(bt_device_class_t));

		// [Major Service Classes](https://www.bluetooth.org/en-us/specification/assigned-numbers/baseband)
		enum {
		DC_LIMITED_DISCOVERABLE_MODE = 0x0001,
		DC_RESERVED14 = 0x0002,
		DC_RESERVED15 = 0x0004,
		DC_POSITIONING = 0x0008,
		DC_NETWORKING = 0x0010,
		DC_RENDERING = 0x0020,
		DC_CAPTURING = 0x0040,
		DC_OBJECT_TRANSFER = 0x0080,
		DC_AUDIO = 0x0100,
		DC_TELEPHONY = 0x0200,
		DC_INFORMATION = 0x0400,
		};

		static bool device_class_get_major_service_(const bt_device_class_t *dc, int bitmask);
		static void device_class_clr_major_service_(bt_device_class_t *dc, int bitmask);
		static void device_class_set_major_service_(bt_device_class_t *dc, int bitmask);

		void device_class_from_stream(bt_device_class_t dc, const uint8_t data) {
		assert(dc != NULL);
		assert(data != NULL);
		dc = (bt_device_class_t *)data;
		}

		int device_class_to_stream(const bt_device_class_t dc, uint8_t data, size_t len) {
		assert(dc != NULL);
		assert(data != NULL);
		assert(len >= sizeof(bt_device_class_t));
		for (size_t i = 0; i < sizeof(bt_device_class_t); ++i) {
		data[i] = dc->_[i];
		}
		return sizeof(bt_device_class_t);
		}

		void device_class_from_int(bt_device_class_t *dc, int data) {
		assert(dc != NULL);
		assert(data != 0);
		// Careful with endianess.
		dc->_[0] = data & 0xff;
		dc->_[1] = (data >> 8) & 0xff;
		dc->_[2] = (data >> 16) & 0xff;
		}

		int device_class_to_int(const bt_device_class_t *dc) {
		assert(dc != NULL);
		// Careful with endianess.
		return (int)(le32toh((int)dc) & 0xffffff);
		}

		bool device_class_equals(const bt_device_class_t p1, const bt_device_class_t p2) {
		assert(p1 != NULL);
		assert(p2 != NULL);
		return (memcmp(p1, p2, sizeof(bt_device_class_t)) == 0);
		}

		bool device_class_copy(bt_device_class_t dest, const bt_device_class_t src) {
		assert(dest != NULL);
		assert(src != NULL);
		return (memcpy(dest, src, sizeof(bt_device_class_t)) == dest);
		}

		int device_class_get_major_device(const bt_device_class_t *dc) {
		assert(dc != NULL);
		return DC(dc)->major_device;
		}

		void device_class_set_major_device(bt_device_class_t *dc, int val) {
		assert(dc != NULL);
		DC(dc)->major_device = val;
		}

		int device_class_get_minor_device(const bt_device_class_t *dc) {
		assert(dc != NULL);
		return DC(dc)->minor_device;
		}

		void device_class_set_minor_device(bt_device_class_t *dc, int val) {
		assert(dc != NULL);
		DC(dc)->minor_device = val;
		}

		bool device_class_get_information(const bt_device_class_t *dc) {
		assert(dc != NULL);
		return device_class_get_major_service_(dc, DC_INFORMATION);
		}

		void device_class_set_information(bt_device_class_t *dc, bool set) {
		assert(dc != NULL);
		if (set)
		device_class_set_major_service_(dc, DC_INFORMATION);
		else
		device_class_clr_major_service_(dc, DC_INFORMATION);
		}

		bool device_class_get_limited(const bt_device_class_t *dc) {
		assert(dc != NULL);
		return device_class_get_major_service_(dc, DC_LIMITED_DISCOVERABLE_MODE);
		}

		void device_class_set_limited(bt_device_class_t *dc, bool set) {
		assert(dc != NULL);
		if (set)
		device_class_set_major_service_(dc, DC_LIMITED_DISCOVERABLE_MODE);
		else
		device_class_clr_major_service_(dc, DC_LIMITED_DISCOVERABLE_MODE);
		}

		static bool device_class_get_major_service_(const bt_device_class_t *dc, int bitmask) {
		return (DC(dc)->major_service & bitmask);
		}

		static void device_class_clr_major_service_(bt_device_class_t *dc, int bitmask) {
		DC(dc)->major_service &= ~bitmask;
		}

		static void device_class_set_major_service_(bt_device_class_t *dc, int bitmask) {
		DC(dc)->major_service \|= bitmask;
		}

system/btcore/test/device_class_test.cpp

0 → 100644

+220 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright (C) 2014 Google, Inc.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*
		******************************************************************************/

		#include <arpa/inet.h>
		#include <gtest/gtest.h>
		#include "osi/test/AllocationTestHarness.h"

		extern "C" {
		#include "btcore/include/device_class.h"
		} // "C"

		// Device Class is 3 bytes.
		static const int DC_MASK = 0xffffff;

		::testing::AssertionResult check_bitfield(const char *m_expr,
		const char *n_expr, int m, int n) {
		if (m == n)
		return ::testing::AssertionSuccess();

		std::stringstream ss;

		ss.str("");
		ss << std::showbase << std::hex << std::setw(8) << std::setfill('0') << m;
		std::string expected_str = ss.str();

		ss.str("");
		ss << std::showbase << std::hex << std::setw(8) << std::setfill('0') << n;
		std::string actual_str = ss.str();

		return ::testing::AssertionFailure() << m_expr << " and " << n_expr
		<< " ( " << expected_str << " vs " << actual_str << " )";
		}

		class DeviceClassTest : public AllocationTestHarness {};

		TEST_F(DeviceClassTest, cod_sizeof) {
		uint8_t dc_stream[] = { 0x00, 0x00, 0x00, 0x00};
		bt_device_class_t dc0;
		device_class_from_stream(&dc0, dc_stream);
		EXPECT_EQ((size_t)3, sizeof(dc0));
		}

		TEST_F(DeviceClassTest, simple) {
		uint8_t dc_stream[][sizeof(bt_device_class_t)] = {
		{ 0x00, 0x00, 0x00 },
		{ 0xff, 0xff, 0xff },
		{ 0xaa, 0x55, 0xaa },
		{ 0x01, 0x23, 0x45 },
		{ 0x20, 0x07, 0x14 },
		};

		for (size_t i = 0; i < sizeof(dc_stream)/sizeof(bt_device_class_t); i++) {
		bt_device_class_t dc;
		device_class_from_stream(&dc, (uint8_t*)&dc_stream[i]);

		uint8_t to_stream = (uint8_t )&dc;
		EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][0], to_stream[0]);
		EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][1], to_stream[1]);
		EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][2], to_stream[2]);
		}
		}

		TEST_F(DeviceClassTest, to_stream) {
		{
		bt_device_class_t dc;

		uint8_t dc_stream0[] = { 0x00, 0x00, 0x00, 0xaa };
		device_class_from_stream(&dc, dc_stream0);

		uint8_t dc_stream1[] = { 0x00, 0x00, 0x00, 0x00 };
		int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
		EXPECT_EQ(3, rc);

		uint32_t val = (uint32_t )&dc;
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, *val & 0xffffff);

		EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[0]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[1]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[2]);
		}

		{
		uint8_t dc_stream0[] = { 0xaa, 0x55, 0xaa, 0x55 };
		uint8_t dc_stream1[] = { 0x00, 0x00, 0x00, 0x00 };

		bt_device_class_t dc;
		device_class_from_stream(&dc, dc_stream0);

		int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
		EXPECT_EQ(3, rc);
		uint32_t val = (uint32_t )&dc;
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00aa55aa, *val & 0xffffff);

		EXPECT_PRED_FORMAT2(check_bitfield, 0xaa, dc_stream1[0]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x55, dc_stream1[1]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0xaa, dc_stream1[2]);
		}

		{
		uint8_t dc_stream0[] = { 0x01, 0x23, 0x45, 0x67 };
		uint8_t dc_stream1[] = { 0x00, 0x00, 0x00, 0x00 };

		bt_device_class_t dc;
		device_class_from_stream(&dc, dc_stream0);

		int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
		EXPECT_EQ(3, rc);
		uint32_t val = (uint32_t )&dc;
		EXPECT_PRED_FORMAT2(check_bitfield, 0x452301, *val & 0xffffff);

		EXPECT_PRED_FORMAT2(check_bitfield, 0x01, dc_stream1[0]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x23, dc_stream1[1]);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x45, dc_stream1[2]);
		}
		}

		TEST_F(DeviceClassTest, limited_discoverable_mode) {
		uint8_t dc_stream[] = { 0x00, 0x00, 0x00 };
		bt_device_class_t dc;
		device_class_from_stream(&dc, dc_stream);
		uint32_t test = (uint32_t )&dc;

		EXPECT_FALSE(device_class_get_limited(&dc));
		EXPECT_EQ((unsigned)0x00000000, *test & DC_MASK);

		device_class_set_limited(&dc, true);
		EXPECT_TRUE(device_class_get_limited(&dc));
		EXPECT_EQ((unsigned)0x00002000, *test & DC_MASK);

		device_class_set_limited(&dc, false);
		EXPECT_FALSE(device_class_get_limited(&dc));
		EXPECT_EQ((unsigned)0x00000000, *test & DC_MASK);

		device_class_set_limited(&dc, true);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00002000, *test & DC_MASK);

		device_class_set_limited(&dc, false);
		EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, *test & DC_MASK);
		}

		TEST_F(DeviceClassTest, equals) {
		uint8_t dc_stream0[] = { 0x00, 0x01, 0x02 };
		uint8_t dc_stream1[] = { 0x00, 0x02, 0x03 };

		bt_device_class_t dc0;
		device_class_from_stream(&dc0, dc_stream0);
		bt_device_class_t dc1;
		device_class_from_stream(&dc1, dc_stream1);
		EXPECT_FALSE(device_class_equals(&dc0, &dc1));
		}

		TEST_F(DeviceClassTest, copy) {
		uint8_t dc_stream0[] = { 0xaa, 0x55, 0x33 };
		bt_device_class_t dc0;
		device_class_from_stream(&dc0, dc_stream0);
		bt_device_class_t dc1;
		EXPECT_TRUE(device_class_copy(&dc1, &dc0));
		EXPECT_TRUE(device_class_equals(&dc0, &dc1));
		}

		TEST_F(DeviceClassTest, from_int) {
		bt_device_class_t dc1;
		int cod1 = 0x5a020c; // 5898764
		device_class_from_int(&dc1, cod1);

		uint8_t dc_stream[] = { 0x0c, 0x02, 0x5a };
		bt_device_class_t dc2;
		device_class_from_stream(&dc2, dc_stream);
		EXPECT_TRUE(device_class_equals(&dc1, &dc2));
		}

		TEST_F(DeviceClassTest, to_int) {
		bt_device_class_t dc1 = {{ 0x0c, 0x02, 0x5a }};
		int cod1 = device_class_to_int(&dc1);

		EXPECT_EQ(dc1._[0], 0x0c);
		EXPECT_EQ(dc1._[1], 0x02);
		EXPECT_EQ(dc1._[2], 0x5a);

		bt_device_class_t dc2;
		uint8_t dc_stream[] = { 0x0c, 0x02, 0x5a };
		device_class_from_stream(&dc2, dc_stream);

		EXPECT_EQ(dc2._[0], 0x0c);
		EXPECT_EQ(dc2._[1], 0x02);
		EXPECT_EQ(dc2._[2], 0x5a);

		int cod2 = device_class_to_int(&dc2);
		EXPECT_EQ(cod1, cod2);
		EXPECT_EQ(cod1, 0x5a020c); // 5898764
		}

		TEST_F(DeviceClassTest, endian) {
		bt_device_class_t dc;
		int cod1 = 0x200714; // 2098964
		device_class_from_int(&dc, cod1);

		EXPECT_EQ(dc._[0], 0x14);
		EXPECT_EQ(dc._[1], 0x07);
		EXPECT_EQ(dc._[2], 0x20);

		int cod2 = device_class_to_int(&dc);
		EXPECT_EQ(cod1, cod2);
		EXPECT_EQ(cod2, 0x200714); // 2098964
		}