bluetooth: Find the device's Bluetooth address
Test: bluetooth_hidl_hal_test
Change-Id: I5353aaef3f8c5db75e424a8e1b242b08d5a96c6e
diff --git a/bluetooth/1.0/default/test/bluetooth_address_test.cc b/bluetooth/1.0/default/test/bluetooth_address_test.cc
new file mode 100644
index 0000000..9f80ec2
--- /dev/null
+++ b/bluetooth/1.0/default/test/bluetooth_address_test.cc
@@ -0,0 +1,246 @@
+//
+// Copyright 2016 The Android Open Source Project
+//
+// 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 <cutils/properties.h>
+#include <fcntl.h>
+#include <gtest/gtest.h>
+
+#include <string>
+#include <vector>
+using std::vector;
+
+#include "bluetooth_address.h"
+
+namespace android {
+namespace hardware {
+namespace bluetooth {
+namespace V1_0 {
+namespace implementation {
+
+constexpr char kTestAddr1[BluetoothAddress::kStringLength + 1] =
+ "12:34:56:78:9a:bc";
+constexpr uint8_t kTestAddr1_bytes[BluetoothAddress::kBytes] = {
+ 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc};
+constexpr char kZeros[BluetoothAddress::kStringLength + 1] =
+ "00:00:00:00:00:00";
+constexpr uint8_t kZeros_bytes[BluetoothAddress::kBytes] = {0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00};
+constexpr char kTestAddrBad1[BluetoothAddress::kStringLength + 1] =
+ "bb:aa:dd:00:00:01";
+constexpr uint8_t kTestAddrBad1_bytes[BluetoothAddress::kBytes] = {
+ 0xbb, 0xaa, 0xdd, 0x00, 0x00, 0x01};
+
+constexpr char kAddrPath[] = "/tmp/my_address_in_a_file.txt";
+
+class BluetoothAddressTest : public ::testing::Test {
+ public:
+ BluetoothAddressTest() {}
+ ~BluetoothAddressTest() {}
+
+ void FileWriteString(const char* path, const char* string);
+};
+
+void BluetoothAddressTest::FileWriteString(const char* path,
+ const char* string) {
+ int fd = open(path, O_CREAT | O_RDWR);
+ EXPECT_TRUE(fd > 0) << "err = " << strerror(errno);
+
+ size_t length = strlen(string);
+ size_t bytes_written = write(fd, string, length);
+
+ EXPECT_EQ(length, bytes_written) << strerror(errno);
+
+ close(fd);
+}
+
+TEST_F(BluetoothAddressTest, string_to_bytes) {
+ uint8_t addr[BluetoothAddress::kBytes];
+
+ // Malformed addresses
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("000000000000", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:0000", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0;", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("aB:cD:eF:Gh:iJ:Kl", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:000:00:00:0;", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:12;", addr));
+ EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:123", addr));
+
+ // Reasonable addresses
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes("00:00:00:00:00:00", addr));
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes("a5:a5:a5:a5:a5:a5", addr));
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes("5A:5A:5A:5A:5A:5A", addr));
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes("AA:BB:CC:DD:EE:FF", addr));
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes("aa:bb:cc:dd:ee:ff", addr));
+
+ // Compare the output to known bytes
+ uint8_t addrA[BluetoothAddress::kBytes];
+ uint8_t addrB[BluetoothAddress::kBytes];
+
+ // kTestAddr1
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes(kTestAddr1, addrA));
+ EXPECT_TRUE(memcmp(addrA, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
+
+ // kZeros
+ EXPECT_TRUE(BluetoothAddress::string_to_bytes(kZeros, addrB));
+ EXPECT_TRUE(memcmp(addrB, kZeros_bytes, BluetoothAddress::kBytes) == 0);
+
+ // kTestAddr1 != kZeros
+ EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kBytes) == 0);
+}
+
+TEST_F(BluetoothAddressTest, bytes_to_string) {
+ char addrA[BluetoothAddress::kStringLength + 1] = "";
+ char addrB[BluetoothAddress::kStringLength + 1] = "";
+
+ // kTestAddr1
+ BluetoothAddress::bytes_to_string(kTestAddr1_bytes, addrA);
+ EXPECT_TRUE(memcmp(addrA, kTestAddr1, BluetoothAddress::kStringLength) == 0);
+
+ // kZeros
+ BluetoothAddress::bytes_to_string(kZeros_bytes, addrB);
+ EXPECT_TRUE(memcmp(addrB, kZeros, BluetoothAddress::kStringLength) == 0);
+
+ // kTestAddr1 != kZeros
+ EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kStringLength) == 0);
+}
+
+TEST_F(BluetoothAddressTest, property_set) {
+ // Set the properties to empty strings.
+ property_set(PERSIST_BDADDR_PROPERTY, "");
+ property_set(PROPERTY_BT_BDADDR_PATH, "");
+ property_set(FACTORY_BDADDR_PROPERTY, "");
+
+ // Get returns 0.
+ char prop[PROP_VALUE_MAX] = "";
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0);
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0);
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0);
+
+ // Set the properties to known strings.
+ property_set(PERSIST_BDADDR_PROPERTY, "1");
+ property_set(PROPERTY_BT_BDADDR_PATH, "22");
+ property_set(FACTORY_BDADDR_PROPERTY, "333");
+
+ // Get returns the correct length.
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 1);
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 2);
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 3);
+
+ // Set the properties to empty strings again.
+ property_set(PERSIST_BDADDR_PROPERTY, "");
+ property_set(PROPERTY_BT_BDADDR_PATH, "");
+ property_set(FACTORY_BDADDR_PROPERTY, "");
+
+ // Get returns 0.
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0);
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0);
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0);
+}
+
+TEST_F(BluetoothAddressTest, property_get) {
+ // Set the properties to known strings.
+ property_set(PERSIST_BDADDR_PROPERTY, PERSIST_BDADDR_PROPERTY);
+ property_set(PROPERTY_BT_BDADDR_PATH, PROPERTY_BT_BDADDR_PATH);
+ property_set(FACTORY_BDADDR_PROPERTY, FACTORY_BDADDR_PROPERTY);
+
+ // Get returns the same strings.
+ char prop[PROP_VALUE_MAX] = "";
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(PERSIST_BDADDR_PROPERTY, prop) == 0);
+
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0);
+
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
+
+ // Set a property to a different known string.
+ char prop2[PROP_VALUE_MAX] = "Erased";
+ property_set(PERSIST_BDADDR_PROPERTY, prop2);
+
+ // Get returns the correct strings.
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0);
+
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
+
+ // Set another property to prop2.
+ property_set(PROPERTY_BT_BDADDR_PATH, prop2);
+
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
+
+ // Set the third property to prop2.
+ property_set(FACTORY_BDADDR_PROPERTY, prop2);
+
+ EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+
+ EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+
+ EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
+ EXPECT_TRUE(strcmp(prop2, prop) == 0);
+}
+
+TEST_F(BluetoothAddressTest, get_local_address) {
+ EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, "") == 0);
+ EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0);
+ uint8_t address[BluetoothAddress::kBytes];
+
+ // File contains a non-zero Address.
+ FileWriteString(kAddrPath, kTestAddr1);
+ EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0);
+ EXPECT_TRUE(BluetoothAddress::get_local_address(address));
+ EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
+
+ // File contains a zero address.
+ FileWriteString(kAddrPath, kZeros);
+ EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0);
+ EXPECT_FALSE(BluetoothAddress::get_local_address(address));
+
+ // Factory property contains an address.
+ EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddrBad1) == 0);
+ EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, kTestAddr1) == 0);
+ EXPECT_TRUE(BluetoothAddress::get_local_address(address));
+ EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
+
+ // Persistent property contains an address.
+ memcpy(address, kTestAddrBad1_bytes, BluetoothAddress::kBytes);
+ EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddr1) == 0);
+ EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0);
+ EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, "") == 0);
+ EXPECT_TRUE(BluetoothAddress::get_local_address(address));
+ EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace bluetooth
+} // namespace hardware
+} // namespace android
diff --git a/bluetooth/1.0/default/test/properties.cc b/bluetooth/1.0/default/test/properties.cc
new file mode 100644
index 0000000..ad5c194
--- /dev/null
+++ b/bluetooth/1.0/default/test/properties.cc
@@ -0,0 +1,79 @@
+//
+// Copyright 2016 The Android Open Source Project
+//
+// 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.
+//
+
+#define LOG_TAG "properties"
+
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <cutils/properties.h>
+#include <utils/Log.h>
+
+static const int MAX_PROPERTIES = 5;
+
+struct property {
+ char key[PROP_KEY_MAX + 2];
+ char value[PROP_VALUE_MAX + 2];
+};
+
+int num_properties = 0;
+struct property properties[MAX_PROPERTIES];
+
+// Find the correct entry.
+static int property_find(const char *key) {
+ for (int i = 0; i < num_properties; i++) {
+ if (strncmp(properties[i].key, key, PROP_KEY_MAX) == 0) {
+ return i;
+ }
+ }
+ return MAX_PROPERTIES;
+}
+
+int property_set(const char *key, const char *value) {
+ if (strnlen(value, PROP_VALUE_MAX) > PROP_VALUE_MAX) return -1;
+
+ // Check to see if the property exists.
+ int prop_index = property_find(key);
+
+ if (prop_index == MAX_PROPERTIES) {
+ if (num_properties >= MAX_PROPERTIES) return -1;
+ prop_index = num_properties;
+ num_properties += 1;
+ }
+
+ // This is test code. Be nice and don't push the boundary cases!
+ strncpy(properties[prop_index].key, key, PROP_KEY_MAX + 1);
+ strncpy(properties[prop_index].value, value, PROP_VALUE_MAX + 1);
+ return 0;
+}
+
+int property_get(const char *key, char *value, const char *default_value) {
+ // This doesn't mock the behavior of default value
+ if (default_value != NULL) ALOGE("%s: default_value is ignored!", __func__);
+
+ // Check to see if the property exists.
+ int prop_index = property_find(key);
+
+ if (prop_index == MAX_PROPERTIES) return 0;
+
+ int len = strlen(properties[prop_index].value);
+ memcpy(value, properties[prop_index].value, len);
+ value[len] = '\0';
+ return len;
+}
diff --git a/bluetooth/1.0/default/test/sys/system_properties.h b/bluetooth/1.0/default/test/sys/system_properties.h
new file mode 100644
index 0000000..b477a6b
--- /dev/null
+++ b/bluetooth/1.0/default/test/sys/system_properties.h
@@ -0,0 +1,20 @@
+//
+// Copyright 2016 The Android Open Source Project
+//
+// 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.
+//
+
+// Mock sys/system_properties.h for testing
+
+#define PROP_VALUE_MAX 50
+#define PROP_KEY_MAX 50