Merge "Add TimeProvider."
diff --git a/nearby/service/Android.bp b/nearby/service/Android.bp
index 13dd6a9..b33d593 100644
--- a/nearby/service/Android.bp
+++ b/nearby/service/Android.bp
@@ -36,6 +36,11 @@
// pre-jarjar symbols are needed so that nearby-service can reference the original class
// names at compile time
"framework-nearby-pre-jarjar",
+ "error_prone_annotations",
+ ],
+ static_libs: [
+ "androidx.annotation_annotation",
+ "guava",
],
sdk_version: "system_server_current",
@@ -55,4 +60,4 @@
apex_available: [
"com.android.nearby",
],
-}
\ No newline at end of file
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddress.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddress.java
new file mode 100644
index 0000000..9bb5a86
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddress.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import static com.google.common.io.BaseEncoding.base16;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.provider.Settings;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.google.common.base.Ascii;
+import com.google.common.io.BaseEncoding;
+
+import java.util.Locale;
+
+/** Utils for dealing with Bluetooth addresses. */
+public final class BluetoothAddress {
+
+ private static final BaseEncoding ENCODING = base16().upperCase().withSeparator(":", 2);
+
+ @VisibleForTesting
+ static final String SECURE_SETTINGS_KEY_BLUETOOTH_ADDRESS = "bluetooth_address";
+
+ /**
+ * @return The string format used by e.g. {@link android.bluetooth.BluetoothDevice}. Upper case.
+ * Example: "AA:BB:CC:11:22:33"
+ */
+ public static String encode(byte[] address) {
+ return ENCODING.encode(address);
+ }
+
+ /**
+ * @param address The string format used by e.g. {@link android.bluetooth.BluetoothDevice}.
+ * Case-insensitive. Example: "AA:BB:CC:11:22:33"
+ */
+ public static byte[] decode(String address) {
+ return ENCODING.decode(address.toUpperCase(Locale.US));
+ }
+
+ /**
+ * Get public bluetooth address.
+ *
+ * @param context a valid {@link Context} instance.
+ */
+ public static @Nullable byte[] getPublicAddress(Context context) {
+ String publicAddress =
+ Settings.Secure.getString(
+ context.getContentResolver(), SECURE_SETTINGS_KEY_BLUETOOTH_ADDRESS);
+ return publicAddress != null && BluetoothAdapter.checkBluetoothAddress(publicAddress)
+ ? decode(publicAddress)
+ : null;
+ }
+
+ /**
+ * Hides partial information of Bluetooth address.
+ * ex1: input is null, output should be empty string
+ * ex2: input is String(AA:BB:CC), output should be AA:BB:CC
+ * ex3: input is String(AA:BB:CC:DD:EE:FF), output should be XX:XX:XX:XX:EE:FF
+ * ex4: input is String(Aa:Bb:Cc:Dd:Ee:Ff), output should be XX:XX:XX:XX:EE:FF
+ * ex5: input is BluetoothDevice(AA:BB:CC:DD:EE:FF), output should be XX:XX:XX:XX:EE:FF
+ */
+ public static String maskBluetoothAddress(@Nullable Object address) {
+ if (address == null) {
+ return "";
+ }
+
+ if (address instanceof String) {
+ String originalAddress = (String) address;
+ String upperCasedAddress = Ascii.toUpperCase(originalAddress);
+ if (!BluetoothAdapter.checkBluetoothAddress(upperCasedAddress)) {
+ return originalAddress;
+ }
+ return convert(upperCasedAddress);
+ } else if (address instanceof BluetoothDevice) {
+ return convert(((BluetoothDevice) address).getAddress());
+ }
+
+ // For others, returns toString().
+ return address.toString();
+ }
+
+ private static String convert(String address) {
+ return "XX:XX:XX:XX:" + address.substring(12);
+ }
+
+ private BluetoothAddress() {}
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Bytes.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Bytes.java
new file mode 100644
index 0000000..637cd03
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Bytes.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import androidx.annotation.Nullable;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+import java.util.Arrays;
+
+/** Represents a block of bytes, with hashCode and equals. */
+public abstract class Bytes {
+ private static final char[] sHexDigits = "0123456789abcdef".toCharArray();
+ private final byte[] mBytes;
+
+ /**
+ * A logical value consisting of one or more bytes in the given order (little-endian, i.e.
+ * LSO...MSO, or big-endian, i.e. MSO...LSO). E.g. the Fast Pair Model ID is a 3-byte value,
+ * and a Bluetooth device address is a 6-byte value.
+ */
+ public static class Value extends Bytes {
+ private final ByteOrder mByteOrder;
+
+ /**
+ * Constructor.
+ */
+ public Value(byte[] bytes, ByteOrder byteOrder) {
+ super(bytes);
+ this.mByteOrder = byteOrder;
+ }
+
+ /**
+ * Gets bytes.
+ */
+ public byte[] getBytes(ByteOrder byteOrder) {
+ return this.mByteOrder.equals(byteOrder) ? getBytes() : reverse(getBytes());
+ }
+
+ private static byte[] reverse(byte[] bytes) {
+ byte[] reversedBytes = new byte[bytes.length];
+ for (int i = 0; i < bytes.length; i++) {
+ reversedBytes[i] = bytes[bytes.length - i - 1];
+ }
+ return reversedBytes;
+ }
+ }
+
+ Bytes(byte[] bytes) {
+ mBytes = bytes;
+ }
+
+ private static String toHexString(byte[] bytes) {
+ StringBuilder sb = new StringBuilder(2 * bytes.length);
+ for (byte b : bytes) {
+ sb.append(sHexDigits[(b >> 4) & 0xf]).append(sHexDigits[b & 0xf]);
+ }
+ return sb.toString();
+ }
+
+ /** Returns 2-byte values in the same order, each using the given byte order. */
+ public static byte[] toBytes(ByteOrder byteOrder, short... shorts) {
+ ByteBuffer byteBuffer = ByteBuffer.allocate(shorts.length * 2).order(byteOrder);
+ for (short s : shorts) {
+ byteBuffer.putShort(s);
+ }
+ return byteBuffer.array();
+ }
+
+ /** Returns the shorts in the same order, each converted using the given byte order. */
+ static short[] toShorts(ByteOrder byteOrder, byte[] bytes) {
+ ShortBuffer shortBuffer = ByteBuffer.wrap(bytes).order(byteOrder).asShortBuffer();
+ short[] shorts = new short[shortBuffer.remaining()];
+ shortBuffer.get(shorts);
+ return shorts;
+ }
+
+ /** @return The bytes. */
+ public byte[] getBytes() {
+ return mBytes;
+ }
+
+ @Override
+ public boolean equals(@Nullable Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Bytes)) {
+ return false;
+ }
+ Bytes that = (Bytes) o;
+ return Arrays.equals(mBytes, that.mBytes);
+ }
+
+ @Override
+ public int hashCode() {
+ return Arrays.hashCode(mBytes);
+ }
+
+ @Override
+ public String toString() {
+ return toHexString(mBytes);
+ }
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Ltv.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Ltv.java
new file mode 100644
index 0000000..88c9484
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/Ltv.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import static com.google.common.io.BaseEncoding.base16;
+
+import com.google.common.primitives.Bytes;
+import com.google.errorprone.annotations.FormatMethod;
+import com.google.errorprone.annotations.FormatString;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * A length, type, value (LTV) data block.
+ */
+public class Ltv {
+
+ private static final int SIZE_OF_LEN_TYPE = 2;
+
+ final byte mType;
+ final byte[] mValue;
+
+ /**
+ * Thrown if there's an error during {@link #parse}.
+ */
+ public static class ParseException extends Exception {
+
+ @FormatMethod
+ private ParseException(@FormatString String format, Object... objects) {
+ super(String.format(format, objects));
+ }
+ }
+
+ /**
+ * Constructor.
+ */
+ public Ltv(byte type, byte... value) {
+ this.mType = type;
+ this.mValue = value;
+ }
+
+ /**
+ * Parses a list of LTV blocks out of the input byte block.
+ */
+ static List<Ltv> parse(byte[] bytes) throws ParseException {
+ List<Ltv> ltvs = new ArrayList<>();
+ // The "+ 2" is for the length and type bytes.
+ for (int valueLength, i = 0; i < bytes.length; i += SIZE_OF_LEN_TYPE + valueLength) {
+ // - 1 since the length in the packet includes the type byte.
+ valueLength = bytes[i] - 1;
+ if (valueLength < 0 || bytes.length < i + SIZE_OF_LEN_TYPE + valueLength) {
+ throw new ParseException(
+ "Wrong length=%d at index=%d in LTVs=%s", bytes[i], i,
+ base16().encode(bytes));
+ }
+ ltvs.add(new Ltv(bytes[i + 1], Arrays.copyOfRange(bytes, i + SIZE_OF_LEN_TYPE,
+ i + SIZE_OF_LEN_TYPE + valueLength)));
+ }
+ return ltvs;
+ }
+
+ /**
+ * Returns an LTV block, where length is mValue.length + 1 (for the type byte).
+ */
+ public byte[] getBytes() {
+ return Bytes.concat(new byte[]{(byte) (mValue.length + 1), mType}, mValue);
+ }
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingException.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingException.java
new file mode 100644
index 0000000..722dc85
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingException.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+/** Base class for pairing exceptions. */
+// TODO(b/200594968): convert exceptions into error codes to save memory.
+public class PairingException extends Exception {
+ PairingException(String format, Object... objects) {
+ super(String.format(format, objects));
+ }
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingProgressListener.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingProgressListener.java
new file mode 100644
index 0000000..8f8e498
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PairingProgressListener.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+/** Callback interface for pairing progress. */
+public interface PairingProgressListener {
+ /** Enum for pairing events. */
+ enum PairingEvent {
+ START,
+ SUCCESS,
+ FAILED,
+ UNKNOWN;
+
+ public static PairingEvent fromOrdinal(int ordinal) {
+ PairingEvent[] values = PairingEvent.values();
+ if (ordinal < 0 || ordinal >= values.length) {
+ return UNKNOWN;
+ }
+ return values[ordinal];
+ }
+ }
+
+ /** Callback function upon pairing progress update. */
+ void onPairingProgressUpdating(PairingEvent event, String message);
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PasskeyConfirmationHandler.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PasskeyConfirmationHandler.java
new file mode 100644
index 0000000..f5807a3
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/PasskeyConfirmationHandler.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import android.bluetooth.BluetoothDevice;
+
+/** Interface for getting the passkey confirmation request. */
+public interface PasskeyConfirmationHandler {
+ /** Called when getting the passkey confirmation request while pairing. */
+ void onPasskeyConfirmation(BluetoothDevice device, int passkey);
+}
diff --git a/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/ToggleBluetoothTask.java b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/ToggleBluetoothTask.java
new file mode 100644
index 0000000..41ac9f5
--- /dev/null
+++ b/nearby/service/java/com/android/server/nearby/common/bluetooth/fastpair/ToggleBluetoothTask.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+
+/** Task for toggling Bluetooth on and back off again. */
+interface ToggleBluetoothTask {
+
+ /**
+ * Toggles the bluetooth adapter off and back on again to help improve connection reliability.
+ *
+ * @throws InterruptedException when waiting for the bluetooth adapter's state to be set has
+ * been interrupted.
+ * @throws ExecutionException when waiting for the bluetooth adapter's state to be set has
+ * failed.
+ * @throws TimeoutException when the bluetooth adapter's state fails to be set on or off.
+ */
+ void toggleBluetooth() throws InterruptedException, ExecutionException, TimeoutException;
+}
diff --git a/nearby/tests/Android.bp b/nearby/tests/Android.bp
index 67a3b83..76b3683 100644
--- a/nearby/tests/Android.bp
+++ b/nearby/tests/Android.bp
@@ -35,6 +35,7 @@
"androidx.test.rules",
"framework-nearby-pre-jarjar",
"platform-test-annotations",
+ "service-nearby",
"truth-prebuilt",
],
test_suites: [
diff --git a/nearby/tests/src/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddressTest.java b/nearby/tests/src/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddressTest.java
new file mode 100644
index 0000000..36ebb7e
--- /dev/null
+++ b/nearby/tests/src/com/android/server/nearby/common/bluetooth/fastpair/BluetoothAddressTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package com.android.server.nearby.common.bluetooth.fastpair;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.bluetooth.BluetoothAdapter;
+import android.platform.test.annotations.Presubmit;
+
+import androidx.test.filters.SmallTest;
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link BluetoothAddress}. */
+@Presubmit
+@SmallTest
+@RunWith(AndroidJUnit4.class)
+public class BluetoothAddressTest {
+
+ @Test
+ public void maskBluetoothAddress_whenInputIsNull() {
+ assertThat(BluetoothAddress.maskBluetoothAddress(null)).isEqualTo("");
+ }
+
+ @Test
+ public void maskBluetoothAddress_whenInputStringNotMatchFormat() {
+ assertThat(BluetoothAddress.maskBluetoothAddress("AA:BB:CC")).isEqualTo("AA:BB:CC");
+ }
+
+ @Test
+ public void maskBluetoothAddress_whenInputStringMatchFormat() {
+ assertThat(BluetoothAddress.maskBluetoothAddress("AA:BB:CC:DD:EE:FF"))
+ .isEqualTo("XX:XX:XX:XX:EE:FF");
+ }
+
+ @Test
+ public void maskBluetoothAddress_whenInputStringContainLowerCaseMatchFormat() {
+ assertThat(BluetoothAddress.maskBluetoothAddress("Aa:Bb:cC:dD:eE:Ff"))
+ .isEqualTo("XX:XX:XX:XX:EE:FF");
+ }
+
+ @Test
+ public void maskBluetoothAddress_whenInputBluetoothDevice() {
+ assertThat(
+ BluetoothAddress.maskBluetoothAddress(
+ BluetoothAdapter.getDefaultAdapter().getRemoteDevice("FF:EE:DD:CC:BB:AA")))
+ .isEqualTo("XX:XX:XX:XX:BB:AA");
+ }
+}