Merge "Add unit test for Utils."
diff --git a/nearby/service/java/com/android/server/nearby/fastpair/Constant.java b/nearby/service/java/com/android/server/nearby/fastpair/Constant.java
index 1477d95..5958007 100644
--- a/nearby/service/java/com/android/server/nearby/fastpair/Constant.java
+++ b/nearby/service/java/com/android/server/nearby/fastpair/Constant.java
@@ -20,6 +20,17 @@
* String constant for half sheet.
*/
public class Constant {
+
+ /**
+ * Value represents true for {@link android.provider.Settings.Secure}
+ */
+ public static final int SETTINGS_TRUE_VALUE = 1;
+
+ /**
+ * Tag for Fast Pair service related logs.
+ */
+ public static final String TAG = "FastPairService";
+
public static final String EXTRA_BINDER = "com.android.server.nearby.fastpair.BINDER";
public static final String EXTRA_BUNDLE = "com.android.server.nearby.fastpair.BUNDLE_EXTRA";
public static final String SUCCESS_STATE = "SUCCESS";
diff --git a/nearby/service/java/com/android/server/nearby/fastpair/FastPairAdvHandler.java b/nearby/service/java/com/android/server/nearby/fastpair/FastPairAdvHandler.java
index 3f7ad2a..f8d5a62 100644
--- a/nearby/service/java/com/android/server/nearby/fastpair/FastPairAdvHandler.java
+++ b/nearby/service/java/com/android/server/nearby/fastpair/FastPairAdvHandler.java
@@ -86,12 +86,19 @@
} else {
// Start to process bloom filter
- List<Account> accountList =
- FastPairDataProvider.getInstance().loadFastPairEligibleAccounts();
- byte[] bloomFilterByteArray = FastPairDecoder.getBloomFilter(fastPairDevice.getData());
- byte[] bloomFilterSalt = FastPairDecoder.getBloomFilterSalt(fastPairDevice.getData());
- for (Account account : accountList) {
- try {
+ try {
+ List<Account> accountList =
+ FastPairDataProvider.getInstance().loadFastPairEligibleAccounts();
+ Log.d(TAG, "account list size" + accountList.size());
+ byte[] bloomFilterByteArray = FastPairDecoder
+ .getBloomFilter(fastPairDevice.getData());
+ byte[] bloomFilterSalt = FastPairDecoder
+ .getBloomFilterSalt(fastPairDevice.getData());
+ if (bloomFilterByteArray == null || bloomFilterByteArray.length == 0) {
+ Log.d(TAG, "bloom filter byte size is 0");
+ return;
+ }
+ for (Account account : accountList) {
List<Data.FastPairDeviceWithAccountKey> listDevices =
FastPairDataProvider.getInstance().loadFastPairDevicesWithAccountKey(
account);
@@ -100,14 +107,15 @@
new BloomFilter(bloomFilterByteArray,
new FastPairBloomFilterHasher()), bloomFilterSalt);
if (recognizedDevice != null) {
- Log.d(TAG, "find matched device show notification to remind user to pair");
+ Log.d(TAG, "find matched device show notification to remind"
+ + " user to pair");
return;
}
- } catch (IllegalStateException e) {
- Log.e(TAG, "OEM does not construct fast pair data proxy correctly");
}
-
+ } catch (IllegalStateException e) {
+ Log.e(TAG, "OEM does not construct fast pair data proxy correctly");
}
+
}
}
diff --git a/nearby/service/java/com/android/server/nearby/fastpair/FastPairController.java b/nearby/service/java/com/android/server/nearby/fastpair/FastPairController.java
index cf8cd62..793e126 100644
--- a/nearby/service/java/com/android/server/nearby/fastpair/FastPairController.java
+++ b/nearby/service/java/com/android/server/nearby/fastpair/FastPairController.java
@@ -125,10 +125,7 @@
@Override
public void run() {
DiscoveryItem item = null;
- if (itemId != null) {
- // api call to get Fast Pair related info
- item = mFastPairCacheManager.getDiscoveryItem(itemId);
- } else if (discoveryItem != null) {
+ if (discoveryItem != null) {
try {
item = new DiscoveryItem(mContext,
Cache.StoredDiscoveryItem.parseFrom(discoveryItem));
@@ -136,6 +133,7 @@
Log.w(TAG,
"Error parsing serialized discovery item with size "
+ discoveryItem.length);
+ return;
}
}
@@ -196,6 +194,7 @@
Log.d(TAG, "FastPair: fastpairing, skip pair request");
return;
}
+ mIsFastPairing = true;
Log.d(TAG, "FastPair: start pair");
// Hide all "tap to pair" notifications until after the flow completes.
@@ -213,7 +212,7 @@
companionApp,
mFootprintsDeviceManager,
pairingProgressHandlerBase);
- mIsFastPairing = true;
+ mIsFastPairing = false;
}
/** Fixes a companion app package name with extra spaces. */
@@ -247,26 +246,26 @@
FastPairManager.processBackgroundTask(() -> {
Cache.StoredDiscoveryItem storedDiscoveryItem =
prepareStoredDiscoveryItemForFootprints(discoveryItem);
- if (storedDiscoveryItem != null) {
- byte[] hashValue =
- Hashing.sha256()
- .hashBytes(
- concat(accountKey, BluetoothAddress.decode(publicAddress)))
- .asBytes();
- FastPairUploadInfo uploadInfo =
- new FastPairUploadInfo(storedDiscoveryItem, ByteString.copyFrom(accountKey),
- ByteString.copyFrom(hashValue));
- // account data place holder here
- try {
- FastPairDataProvider.getInstance().optIn(new Account("empty", "empty"));
+ byte[] hashValue =
+ Hashing.sha256()
+ .hashBytes(
+ concat(accountKey, BluetoothAddress.decode(publicAddress)))
+ .asBytes();
+ FastPairUploadInfo uploadInfo =
+ new FastPairUploadInfo(storedDiscoveryItem, ByteString.copyFrom(accountKey),
+ ByteString.copyFrom(hashValue));
+ // account data place holder here
+ try {
+ List<Account> accountList =
+ FastPairDataProvider.getInstance().loadFastPairEligibleAccounts();
+ if (accountList.size() > 0) {
+ FastPairDataProvider.getInstance().optIn(accountList.get(0));
FastPairDataProvider.getInstance().upload(
- new Account("empty", "empty"), uploadInfo);
- } catch (IllegalStateException e) {
- Log.e(TAG, "OEM does not construct fast pair data proxy correctly");
+ accountList.get(0), uploadInfo);
}
-
+ } catch (IllegalStateException e) {
+ Log.e(TAG, "OEM does not construct fast pair data proxy correctly");
}
-
});
}
diff --git a/nearby/service/java/com/android/server/nearby/fastpair/FastPairManager.java b/nearby/service/java/com/android/server/nearby/fastpair/FastPairManager.java
index 7e2151d..9e1a718 100644
--- a/nearby/service/java/com/android/server/nearby/fastpair/FastPairManager.java
+++ b/nearby/service/java/com/android/server/nearby/fastpair/FastPairManager.java
@@ -16,20 +16,27 @@
package com.android.server.nearby.fastpair;
+import static com.android.server.nearby.fastpair.Constant.SETTINGS_TRUE_VALUE;
+import static com.android.server.nearby.fastpair.Constant.TAG;
+
import android.annotation.Nullable;
import android.annotation.WorkerThread;
import android.app.KeyguardManager;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothManager;
import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
+import android.database.ContentObserver;
import android.nearby.FastPairDevice;
import android.nearby.NearbyDevice;
import android.nearby.NearbyManager;
import android.nearby.ScanCallback;
import android.nearby.ScanRequest;
+import android.net.Uri;
+import android.provider.Settings;
import android.util.Log;
import androidx.annotation.NonNull;
@@ -71,47 +78,32 @@
*/
public class FastPairManager {
+
private static final String ACTION_PREFIX = UserActionHandler.PREFIX;
private static final int WAIT_FOR_UNLOCK_MILLIS = 5000;
+
/** A notification ID which should be dismissed */
public static final String EXTRA_NOTIFICATION_ID = ACTION_PREFIX + "EXTRA_NOTIFICATION_ID";
public static final String ACTION_RESOURCES_APK = "android.nearby.SHOW_HALFSHEET";
private static Executor sFastPairExecutor;
+ private ContentObserver mFastPairScanChangeContentObserver = null;
+
final LocatorContextWrapper mLocatorContextWrapper;
final IntentFilter mIntentFilter;
final Locator mLocator;
- private boolean mAllowScan = false;
+ private boolean mScanEnabled = false;
private final BroadcastReceiver mScreenBroadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
- Log.d("FastPairService", " screen on");
- NearbyManager nearbyManager = (NearbyManager) mLocatorContextWrapper
- .getApplicationContext().getSystemService(Context.NEARBY_SERVICE);
-
- Log.d("FastPairService", " the nearby manager is " + nearbyManager);
-
- if (nearbyManager != null) {
- if (mAllowScan) {
- nearbyManager.startScan(
- new ScanRequest.Builder()
- .setScanType(ScanRequest.SCAN_TYPE_FAST_PAIR).build(),
- ForegroundThread.getExecutor(),
- mScanCallback);
- }
- } else {
- Log.d("FastPairService", " the nearby manager is null");
- }
-
- } else {
- Log.d("FastPairService", " screen off");
+ Log.d(TAG, "onReceive: ACTION_SCREEN_ON.");
+ invalidateScan();
}
}
};
-
public FastPairManager(LocatorContextWrapper contextWrapper) {
mLocatorContextWrapper = contextWrapper;
mIntentFilter = new IntentFilter();
@@ -131,16 +123,14 @@
public void onUpdated(@NonNull NearbyDevice device) {
FastPairDevice fastPairDevice = (FastPairDevice) device;
byte[] modelArray = FastPairDecoder.getModelId(fastPairDevice.getData());
- Log.d("FastPairService",
- "update model id" + Hex.bytesToStringLowercase(modelArray));
+ Log.d(TAG, "update model id" + Hex.bytesToStringLowercase(modelArray));
}
@Override
public void onLost(@NonNull NearbyDevice device) {
FastPairDevice fastPairDevice = (FastPairDevice) device;
byte[] modelArray = FastPairDecoder.getModelId(fastPairDevice.getData());
- Log.d("FastPairService",
- "lost model id" + Hex.bytesToStringLowercase(modelArray));
+ Log.d(TAG, "lost model id" + Hex.bytesToStringLowercase(modelArray));
}
};
@@ -155,6 +145,13 @@
.registerReceiver(mScreenBroadcastReceiver, mIntentFilter);
Locator.getFromContextWrapper(mLocatorContextWrapper, FastPairCacheManager.class);
+ try {
+ mScanEnabled = getScanEnabledFromSettings();
+ } catch (Settings.SettingNotFoundException e) {
+ Log.w(TAG,
+ "initiate: Failed to get initial scan enabled status from Settings.", e);
+ }
+ registerFastPairScanChangeContentObserver(mLocatorContextWrapper.getContentResolver());
}
/**
@@ -162,6 +159,10 @@
*/
public void cleanUp() {
mLocatorContextWrapper.getContext().unregisterReceiver(mScreenBroadcastReceiver);
+ if (mFastPairScanChangeContentObserver != null) {
+ mLocatorContextWrapper.getContentResolver().unregisterContentObserver(
+ mFastPairScanChangeContentObserver);
+ }
}
/**
@@ -212,18 +213,17 @@
boolean isBluetoothEnabled = bluetoothAdapter != null && bluetoothAdapter.isEnabled();
if (!isBluetoothEnabled) {
if (bluetoothAdapter == null || !bluetoothAdapter.enable()) {
- Log.d("FastPairManager", "FastPair: Failed to enable bluetooth");
+ Log.d(TAG, "FastPair: Failed to enable bluetooth");
return;
}
- Log.v("FastPairManager", "FastPair: Enabling bluetooth for fast pair");
+ Log.v(TAG, "FastPair: Enabling bluetooth for fast pair");
Locator.get(context, EventLoop.class)
.postRunnable(
new NamedRunnable("enableBluetoothToast") {
@Override
public void run() {
- Log.d("FastPairManager",
- "Enable bluetooth toast test");
+ Log.d(TAG, "Enable bluetooth toast test");
}
});
// Set up call back to call this function again once bluetooth has been
@@ -287,7 +287,7 @@
| ExecutionException
| PairingException
| GeneralSecurityException e) {
- Log.e("FastPairManager", "FastPair: Error");
+ Log.e(TAG, "FastPair: Error");
pairingProgressHandlerBase.onPairingFailed(e);
}
}
@@ -307,8 +307,7 @@
// pattern) So we use this method instead, which returns true when on the lock screen
// regardless.
if (keyguardManager.isKeyguardLocked()) {
- Log.v("FastPairManager",
- "FastPair: Screen is locked, waiting until unlocked "
+ Log.v(TAG, "FastPair: Screen is locked, waiting until unlocked "
+ "to show status notifications.");
try (SimpleBroadcastReceiver isUnlockedReceiver =
SimpleBroadcastReceiver.oneShotReceiver(
@@ -319,6 +318,28 @@
}
}
+ private void registerFastPairScanChangeContentObserver(ContentResolver resolver) {
+ mFastPairScanChangeContentObserver = new ContentObserver(ForegroundThread.getHandler()) {
+ @Override
+ public void onChange(boolean selfChange, Uri uri) {
+ super.onChange(selfChange, uri);
+ try {
+ setScanEnabled(getScanEnabledFromSettings());
+ } catch (Settings.SettingNotFoundException e) {
+ Log.e(TAG, "Failed to get scan switch updates in Settings page.", e);
+ }
+ }
+ };
+ try {
+ resolver.registerContentObserver(
+ Settings.Secure.getUriFor(Settings.Secure.FAST_PAIR_SCAN_ENABLED),
+ /* notifyForDescendants= */ false,
+ mFastPairScanChangeContentObserver);
+ } catch (SecurityException e) {
+ Log.e(TAG, "Failed to register content observer for fast pair scan.", e);
+ }
+ }
+
/**
* Processed task in a background thread
*/
@@ -339,6 +360,49 @@
}
/**
+ * Null when the Nearby Service is not available.
+ */
+ @Nullable
+ private NearbyManager getNearbyManager() {
+ return (NearbyManager) mLocatorContextWrapper
+ .getApplicationContext().getSystemService(Context.NEARBY_SERVICE);
+ }
+
+ private boolean getScanEnabledFromSettings() throws Settings.SettingNotFoundException {
+ return Settings.Secure.getInt(
+ mLocatorContextWrapper.getContext().getContentResolver(),
+ Settings.Secure.FAST_PAIR_SCAN_ENABLED) == SETTINGS_TRUE_VALUE;
+ }
+
+ private void setScanEnabled(boolean scanEnabled) {
+ if (mScanEnabled == scanEnabled) {
+ return;
+ }
+ mScanEnabled = scanEnabled;
+ invalidateScan();
+ }
+
+ /**
+ * Starts or stops scanning according to mAllowScan value.
+ */
+ private void invalidateScan() {
+ NearbyManager nearbyManager = getNearbyManager();
+ if (nearbyManager == null) {
+ Log.w(TAG, "invalidateScan: "
+ + "failed to start or stop scannning because NearbyManager is null.");
+ return;
+ }
+ if (mScanEnabled) {
+ nearbyManager.startScan(new ScanRequest.Builder()
+ .setScanType(ScanRequest.SCAN_TYPE_FAST_PAIR).build(),
+ ForegroundThread.getExecutor(),
+ mScanCallback);
+ } else {
+ nearbyManager.stopScan(mScanCallback);
+ }
+ }
+
+ /**
* Helper function to get bluetooth adapter.
*/
@Nullable
@@ -346,5 +410,4 @@
BluetoothManager manager = context.getSystemService(BluetoothManager.class);
return manager == null ? null : manager.getAdapter();
}
-
}
diff --git a/nearby/service/java/com/android/server/nearby/provider/FastPairDataProvider.java b/nearby/service/java/com/android/server/nearby/provider/FastPairDataProvider.java
index 010a3d4..40fefaf 100644
--- a/nearby/service/java/com/android/server/nearby/provider/FastPairDataProvider.java
+++ b/nearby/service/java/com/android/server/nearby/provider/FastPairDataProvider.java
@@ -109,6 +109,7 @@
requestParcel.account = account;
requestParcel.requestType = FastPairDataProviderBase.MANAGE_REQUEST_ADD;
mProxyFastPairDataProvider.manageFastPairAccount(requestParcel);
+ return;
}
throw new IllegalStateException("No ProxyFastPairDataProvider yet constructed");
}
@@ -127,6 +128,7 @@
requestParcel.accountKeyDeviceMetadata =
Utils.convertToFastPairAccountKeyDeviceMetadata(uploadInfo);
mProxyFastPairDataProvider.manageFastPairAccountDevice(requestParcel);
+ return;
}
throw new IllegalStateException("No ProxyFastPairDataProvider yet constructed");
}
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceBroadcastRequestTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceBroadcastRequestTest.java
index 0b3ff07..a37cc67 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceBroadcastRequestTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceBroadcastRequestTest.java
@@ -17,6 +17,7 @@
package android.nearby.cts;
import static android.nearby.BroadcastRequest.BROADCAST_TYPE_NEARBY_PRESENCE;
+import static android.nearby.BroadcastRequest.PRESENCE_VERSION_V0;
import static android.nearby.PresenceCredential.IDENTITY_TYPE_PRIVATE;
import static com.google.common.truth.Truth.assertThat;
@@ -34,6 +35,7 @@
import org.junit.Test;
import org.junit.runner.RunWith;
+import java.util.Arrays;
import java.util.Collections;
/**
@@ -43,6 +45,7 @@
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
public class PresenceBroadcastRequestTest {
+ private static final int VERSION = PRESENCE_VERSION_V0;
private static final int TX_POWER = 1;
private static final byte[] SALT = new byte[]{1, 2};
private static final int ACTION_ID = 123;
@@ -53,7 +56,6 @@
private static final int KEY = 1234;
private static final byte[] VALUE = new byte[]{1, 1, 1, 1};
-
private PresenceBroadcastRequest.Builder mBuilder;
@Before
@@ -65,6 +67,7 @@
DataElement element = new DataElement(KEY, VALUE);
mBuilder = new PresenceBroadcastRequest.Builder(Collections.singletonList(BLE_MEDIUM), SALT)
.setTxPower(TX_POWER)
+ .setVersion(VERSION)
.setCredential(credential)
.addAction(ACTION_ID)
.addExtendedProperty(element);
@@ -74,6 +77,8 @@
public void testBuilder() {
PresenceBroadcastRequest broadcastRequest = mBuilder.build();
+ assertThat(broadcastRequest.getVersion()).isEqualTo(VERSION);
+ assertThat(Arrays.equals(broadcastRequest.getSalt(), SALT)).isTrue();
assertThat(broadcastRequest.getTxPower()).isEqualTo(TX_POWER);
assertThat(broadcastRequest.getActions()).containsExactly(ACTION_ID);
assertThat(broadcastRequest.getExtendedProperties().get(0).getKey()).isEqualTo(
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceDeviceTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceDeviceTest.java
index e21bc80..a1b282d 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceDeviceTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceDeviceTest.java
@@ -46,6 +46,10 @@
private static final String DEVICE_NAME = "testDevice";
private static final int KEY = 1234;
private static final byte[] VALUE = new byte[]{1, 1, 1, 1};
+ private static final byte[] SALT = new byte[]{2, 3};
+ private static final byte[] SECRET_ID = new byte[]{11, 13};
+ private static final byte[] ENCRYPTED_IDENTITY = new byte[]{1, 3, 5, 61};
+ private static final long DISCOVERY_MILLIS = 100L;
@Test
public void testBuilder() {
@@ -57,6 +61,10 @@
.setRssi(RSSI)
.addMedium(MEDIUM)
.setName(DEVICE_NAME)
+ .setDiscoveryTimestampMillis(DISCOVERY_MILLIS)
+ .setSalt(SALT)
+ .setSecretId(SECRET_ID)
+ .setEncryptedIdentity(ENCRYPTED_IDENTITY)
.build();
assertThat(device.getDeviceType()).isEqualTo(DEVICE_TYPE);
@@ -68,6 +76,10 @@
assertThat(device.getRssi()).isEqualTo(RSSI);
assertThat(device.getMediums()).containsExactly(MEDIUM);
assertThat(device.getName()).isEqualTo(DEVICE_NAME);
+ assertThat(Arrays.equals(device.getSalt(), SALT)).isTrue();
+ assertThat(Arrays.equals(device.getSecretId(), SECRET_ID)).isTrue();
+ assertThat(Arrays.equals(device.getEncryptedIdentity(), ENCRYPTED_IDENTITY)).isTrue();
+ assertThat(device.getDiscoveryTimestampMillis()).isEqualTo(DISCOVERY_MILLIS);
}
@Test
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceScanFilterTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceScanFilterTest.java
index 8962499..308be9e 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceScanFilterTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/PresenceScanFilterTest.java
@@ -70,6 +70,8 @@
assertThat(filter.getCredentials().get(0).getIdentityType()).isEqualTo(
IDENTITY_TYPE_PRIVATE);
assertThat(filter.getPresenceActions()).containsExactly(ACTION);
+ assertThat(filter.getExtendedProperties().get(0).getKey()).isEqualTo(KEY);
+
}
@Test
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/PrivateCredentialTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/PrivateCredentialTest.java
index 3212307..5242999 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/PrivateCredentialTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/PrivateCredentialTest.java
@@ -41,6 +41,7 @@
@RunWith(AndroidJUnit4.class)
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
public class PrivateCredentialTest {
+ private static final String DEVICE_NAME = "myDevice";
private static final byte[] SECRETE_ID = new byte[]{1, 2, 3, 4};
private static final byte[] AUTHENTICITY_KEY = new byte[]{0, 1, 1, 1};
private static final String KEY = "SecreteId";
@@ -53,6 +54,7 @@
public void setUp() {
mBuilder = new PrivateCredential.Builder(SECRETE_ID, AUTHENTICITY_KEY)
.setIdentityType(IDENTITY_TYPE_PRIVATE)
+ .setDeviceName(DEVICE_NAME)
.setMetadataEncryptionKey(METADATA_ENCRYPTION_KEY)
.addCredentialElement(new CredentialElement(KEY, VALUE));
}
@@ -63,6 +65,7 @@
assertThat(credential.getType()).isEqualTo(CREDENTIAL_TYPE_PRIVATE);
assertThat(credential.getIdentityType()).isEqualTo(IDENTITY_TYPE_PRIVATE);
+ assertThat(credential.getDeviceName()).isEqualTo(DEVICE_NAME);
assertThat(Arrays.equals(credential.getSecretId(), SECRETE_ID)).isTrue();
assertThat(Arrays.equals(credential.getAuthenticityKey(), AUTHENTICITY_KEY)).isTrue();
assertThat(Arrays.equals(credential.getMetadataEncryptionKey(),
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/PublicCredentialTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/PublicCredentialTest.java
index 4a12416..f750951 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/PublicCredentialTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/PublicCredentialTest.java
@@ -21,6 +21,7 @@
import static com.google.common.truth.Truth.assertThat;
+import android.nearby.CredentialElement;
import android.nearby.PresenceCredential;
import android.nearby.PublicCredential;
import android.os.Build;
@@ -47,12 +48,15 @@
private static final byte[] PUBLIC_KEY = new byte[]{1, 1, 2, 2};
private static final byte[] ENCRYPTED_METADATA = new byte[]{1, 2, 3, 4, 5};
private static final byte[] METADATA_ENCRYPTION_KEY_TAG = new byte[]{1, 1, 3, 4, 5};
+ private static final String KEY = "KEY";
+ private static final byte[] VALUE = new byte[]{1, 2, 3, 4, 5};
private PublicCredential.Builder mBuilder;
@Before
public void setUp() {
mBuilder = new PublicCredential.Builder(SECRETE_ID, AUTHENTICITY_KEY)
+ .addCredentialElement(new CredentialElement(KEY, VALUE))
.setIdentityType(IDENTITY_TYPE_PRIVATE)
.setPublicKey(PUBLIC_KEY).setEncryptedMetadata(ENCRYPTED_METADATA)
.setEncryptedMetadataKeyTag(METADATA_ENCRYPTION_KEY_TAG);
@@ -64,6 +68,7 @@
assertThat(credential.getType()).isEqualTo(CREDENTIAL_TYPE_PUBLIC);
assertThat(credential.getIdentityType()).isEqualTo(IDENTITY_TYPE_PRIVATE);
+ assertThat(credential.getCredentialElements().get(0).getKey()).isEqualTo(KEY);
assertThat(Arrays.equals(credential.getSecretId(), SECRETE_ID)).isTrue();
assertThat(Arrays.equals(credential.getAuthenticityKey(), AUTHENTICITY_KEY)).isTrue();
assertThat(Arrays.equals(credential.getPublicKey(), PUBLIC_KEY)).isTrue();
diff --git a/nearby/tests/cts/fastpair/src/android/nearby/cts/ScanRequestTest.java b/nearby/tests/cts/fastpair/src/android/nearby/cts/ScanRequestTest.java
index 2d01e83..86e764c 100644
--- a/nearby/tests/cts/fastpair/src/android/nearby/cts/ScanRequestTest.java
+++ b/nearby/tests/cts/fastpair/src/android/nearby/cts/ScanRequestTest.java
@@ -48,6 +48,16 @@
private static final int UID = 1001;
private static final String APP_NAME = "android.nearby.tests";
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testScanType() {
+ ScanRequest request = new ScanRequest.Builder()
+ .setScanType(SCAN_TYPE_NEARBY_PRESENCE)
+ .build();
+
+ assertThat(request.getScanType()).isEqualTo(SCAN_TYPE_NEARBY_PRESENCE);
+ }
+
// Valid scan type must be set to one of ScanRequest#SCAN_TYPE_
@Test(expected = IllegalStateException.class)
@SdkSuppress(minSdkVersion = 32, codeName = "T")
diff --git a/nearby/tests/unit/src/com/android/server/nearby/common/bluetooth/fastpair/PreferencesTest.java b/nearby/tests/unit/src/com/android/server/nearby/common/bluetooth/fastpair/PreferencesTest.java
new file mode 100644
index 0000000..b40a5a5
--- /dev/null
+++ b/nearby/tests/unit/src/com/android/server/nearby/common/bluetooth/fastpair/PreferencesTest.java
@@ -0,0 +1,1277 @@
+/*
+ * 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.platform.test.annotations.Presubmit;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SdkSuppress;
+import androidx.test.filters.SmallTest;
+
+import com.google.common.collect.ImmutableSet;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Unit tests for {@link Preferences}.
+ */
+@Presubmit
+@SmallTest
+@RunWith(AndroidJUnit4.class)
+public class PreferencesTest {
+
+ private static final int FIRST_INT = 1505;
+ private static final int SECOND_INT = 1506;
+ private static final boolean FIRST_BOOL = true;
+ private static final boolean SECOND_BOOL = false;
+ private static final short FIRST_SHORT = 32;
+ private static final short SECOND_SHORT = 73;
+ private static final long FIRST_LONG = 9838L;
+ private static final long SECOND_LONG = 93935L;
+ private static final String FIRST_STRING = "FIRST_STRING";
+ private static final String SECOND_STRING = "SECOND_STRING";
+ private static final byte[] FIRST_BYTES = new byte[] {7, 9};
+ private static final byte[] SECOND_BYTES = new byte[] {2};
+ private static final ImmutableSet<Integer> FIRST_INT_SETS = ImmutableSet.of(6, 8);
+ private static final ImmutableSet<Integer> SECOND_INT_SETS = ImmutableSet.of(6, 8);
+ private static final Preferences.ExtraLoggingInformation FIRST_EXTRA_LOGGING_INFO =
+ Preferences.ExtraLoggingInformation.builder().setModelId("000006").build();
+ private static final Preferences.ExtraLoggingInformation SECOND_EXTRA_LOGGING_INFO =
+ Preferences.ExtraLoggingInformation.builder().setModelId("000007").build();
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattOperationTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setGattOperationTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getGattOperationTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getGattOperationTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattOperationTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getGattOperationTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectionTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectionTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getGattConnectionTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getGattConnectionTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectionTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getGattConnectionTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBluetoothToggleTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setBluetoothToggleTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getBluetoothToggleTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getBluetoothToggleTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBluetoothToggleTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getBluetoothToggleTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBluetoothToggleSleepSeconds() {
+ Preferences prefs =
+ Preferences.builder().setBluetoothToggleSleepSeconds(FIRST_INT).build();
+ assertThat(prefs.getBluetoothToggleSleepSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getBluetoothToggleSleepSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBluetoothToggleSleepSeconds(SECOND_INT).build();
+ assertThat(prefs2.getBluetoothToggleSleepSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testClassicDiscoveryTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setClassicDiscoveryTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getClassicDiscoveryTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getClassicDiscoveryTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setClassicDiscoveryTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getClassicDiscoveryTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumDiscoverAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumDiscoverAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumDiscoverAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumDiscoverAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumDiscoverAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumDiscoverAttempts()).isEqualTo(SECOND_INT);
+ }
+
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testDiscoveryRetrySleepSeconds() {
+ Preferences prefs =
+ Preferences.builder().setDiscoveryRetrySleepSeconds(FIRST_INT).build();
+ assertThat(prefs.getDiscoveryRetrySleepSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getDiscoveryRetrySleepSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setDiscoveryRetrySleepSeconds(SECOND_INT).build();
+ assertThat(prefs2.getDiscoveryRetrySleepSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSdpTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setSdpTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getSdpTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getSdpTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setSdpTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getSdpTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumSdpAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumSdpAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumSdpAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumSdpAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumSdpAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumSdpAttempts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumCreateBondAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumCreateBondAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumCreateBondAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumCreateBondAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumCreateBondAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumCreateBondAttempts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumConnectAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumConnectAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumConnectAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumConnectAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumConnectAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumConnectAttempts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumWriteAccountKeyAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumWriteAccountKeyAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumWriteAccountKeyAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumWriteAccountKeyAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumWriteAccountKeyAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumWriteAccountKeyAttempts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBluetoothStatePollingMillis() {
+ Preferences prefs =
+ Preferences.builder().setBluetoothStatePollingMillis(FIRST_INT).build();
+ assertThat(prefs.getBluetoothStatePollingMillis()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getBluetoothStatePollingMillis())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBluetoothStatePollingMillis(SECOND_INT).build();
+ assertThat(prefs2.getBluetoothStatePollingMillis()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumAttempts() {
+ Preferences prefs =
+ Preferences.builder().setNumAttempts(FIRST_INT).build();
+ assertThat(prefs.getNumAttempts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumAttempts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumAttempts(SECOND_INT).build();
+ assertThat(prefs2.getNumAttempts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRemoveBondTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setRemoveBondTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getRemoveBondTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getRemoveBondTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setRemoveBondTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getRemoveBondTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRemoveBondSleepMillis() {
+ Preferences prefs =
+ Preferences.builder().setRemoveBondSleepMillis(FIRST_INT).build();
+ assertThat(prefs.getRemoveBondSleepMillis()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getRemoveBondSleepMillis())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setRemoveBondSleepMillis(SECOND_INT).build();
+ assertThat(prefs2.getRemoveBondSleepMillis()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testCreateBondTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setCreateBondTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getCreateBondTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getCreateBondTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setCreateBondTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getCreateBondTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testHidCreateBondTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setHidCreateBondTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getHidCreateBondTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getHidCreateBondTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setHidCreateBondTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getHidCreateBondTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testProxyTimeoutSeconds() {
+ Preferences prefs =
+ Preferences.builder().setProxyTimeoutSeconds(FIRST_INT).build();
+ assertThat(prefs.getProxyTimeoutSeconds()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getProxyTimeoutSeconds())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setProxyTimeoutSeconds(SECOND_INT).build();
+ assertThat(prefs2.getProxyTimeoutSeconds()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testWriteAccountKeySleepMillis() {
+ Preferences prefs =
+ Preferences.builder().setWriteAccountKeySleepMillis(FIRST_INT).build();
+ assertThat(prefs.getWriteAccountKeySleepMillis()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getWriteAccountKeySleepMillis())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setWriteAccountKeySleepMillis(SECOND_INT).build();
+ assertThat(prefs2.getWriteAccountKeySleepMillis()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testPairFailureCounts() {
+ Preferences prefs =
+ Preferences.builder().setPairFailureCounts(FIRST_INT).build();
+ assertThat(prefs.getPairFailureCounts()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getPairFailureCounts())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setPairFailureCounts(SECOND_INT).build();
+ assertThat(prefs2.getPairFailureCounts()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testCreateBondTransportType() {
+ Preferences prefs =
+ Preferences.builder().setCreateBondTransportType(FIRST_INT).build();
+ assertThat(prefs.getCreateBondTransportType()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getCreateBondTransportType())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setCreateBondTransportType(SECOND_INT).build();
+ assertThat(prefs2.getCreateBondTransportType()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectRetryTimeoutMillis() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectRetryTimeoutMillis(FIRST_INT).build();
+ assertThat(prefs.getGattConnectRetryTimeoutMillis()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getGattConnectRetryTimeoutMillis())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectRetryTimeoutMillis(SECOND_INT).build();
+ assertThat(prefs2.getGattConnectRetryTimeoutMillis()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testNumSdpAttemptsAfterBonded() {
+ Preferences prefs =
+ Preferences.builder().setNumSdpAttemptsAfterBonded(FIRST_INT).build();
+ assertThat(prefs.getNumSdpAttemptsAfterBonded()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getNumSdpAttemptsAfterBonded())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setNumSdpAttemptsAfterBonded(SECOND_INT).build();
+ assertThat(prefs2.getNumSdpAttemptsAfterBonded()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSameModelIdPairedDeviceCount() {
+ Preferences prefs =
+ Preferences.builder().setSameModelIdPairedDeviceCount(FIRST_INT).build();
+ assertThat(prefs.getSameModelIdPairedDeviceCount()).isEqualTo(FIRST_INT);
+ assertThat(prefs.toBuilder().build().getSameModelIdPairedDeviceCount())
+ .isEqualTo(FIRST_INT);
+
+ Preferences prefs2 =
+ Preferences.builder().setSameModelIdPairedDeviceCount(SECOND_INT).build();
+ assertThat(prefs2.getSameModelIdPairedDeviceCount()).isEqualTo(SECOND_INT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testIgnoreDiscoveryError() {
+ Preferences prefs =
+ Preferences.builder().setIgnoreDiscoveryError(FIRST_BOOL).build();
+ assertThat(prefs.getIgnoreDiscoveryError()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getIgnoreDiscoveryError())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setIgnoreDiscoveryError(SECOND_BOOL).build();
+ assertThat(prefs2.getIgnoreDiscoveryError()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testToggleBluetoothOnFailure() {
+ Preferences prefs =
+ Preferences.builder().setToggleBluetoothOnFailure(FIRST_BOOL).build();
+ assertThat(prefs.getToggleBluetoothOnFailure()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getToggleBluetoothOnFailure())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setToggleBluetoothOnFailure(SECOND_BOOL).build();
+ assertThat(prefs2.getToggleBluetoothOnFailure()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBluetoothStateUsesPolling() {
+ Preferences prefs =
+ Preferences.builder().setBluetoothStateUsesPolling(FIRST_BOOL).build();
+ assertThat(prefs.getBluetoothStateUsesPolling()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getBluetoothStateUsesPolling())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setBluetoothStateUsesPolling(SECOND_BOOL).build();
+ assertThat(prefs2.getBluetoothStateUsesPolling()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnableBrEdrHandover() {
+ Preferences prefs =
+ Preferences.builder().setEnableBrEdrHandover(FIRST_BOOL).build();
+ assertThat(prefs.getEnableBrEdrHandover()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnableBrEdrHandover())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnableBrEdrHandover(SECOND_BOOL).build();
+ assertThat(prefs2.getEnableBrEdrHandover()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testWaitForUuidsAfterBonding() {
+ Preferences prefs =
+ Preferences.builder().setWaitForUuidsAfterBonding(FIRST_BOOL).build();
+ assertThat(prefs.getWaitForUuidsAfterBonding()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getWaitForUuidsAfterBonding())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setWaitForUuidsAfterBonding(SECOND_BOOL).build();
+ assertThat(prefs2.getWaitForUuidsAfterBonding()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testReceiveUuidsAndBondedEventBeforeClose() {
+ Preferences prefs =
+ Preferences.builder().setReceiveUuidsAndBondedEventBeforeClose(FIRST_BOOL).build();
+ assertThat(prefs.getReceiveUuidsAndBondedEventBeforeClose()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getReceiveUuidsAndBondedEventBeforeClose())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setReceiveUuidsAndBondedEventBeforeClose(SECOND_BOOL).build();
+ assertThat(prefs2.getReceiveUuidsAndBondedEventBeforeClose()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRejectPhonebookAccess() {
+ Preferences prefs =
+ Preferences.builder().setRejectPhonebookAccess(FIRST_BOOL).build();
+ assertThat(prefs.getRejectPhonebookAccess()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getRejectPhonebookAccess())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setRejectPhonebookAccess(SECOND_BOOL).build();
+ assertThat(prefs2.getRejectPhonebookAccess()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRejectMessageAccess() {
+ Preferences prefs =
+ Preferences.builder().setRejectMessageAccess(FIRST_BOOL).build();
+ assertThat(prefs.getRejectMessageAccess()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getRejectMessageAccess())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setRejectMessageAccess(SECOND_BOOL).build();
+ assertThat(prefs2.getRejectMessageAccess()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRejectSimAccess() {
+ Preferences prefs =
+ Preferences.builder().setRejectSimAccess(FIRST_BOOL).build();
+ assertThat(prefs.getRejectSimAccess()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getRejectSimAccess())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setRejectSimAccess(SECOND_BOOL).build();
+ assertThat(prefs2.getRejectSimAccess()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSkipDisconnectingGattBeforeWritingAccountKey() {
+ Preferences prefs =
+ Preferences.builder().setSkipDisconnectingGattBeforeWritingAccountKey(FIRST_BOOL)
+ .build();
+ assertThat(prefs.getSkipDisconnectingGattBeforeWritingAccountKey()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getSkipDisconnectingGattBeforeWritingAccountKey())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setSkipDisconnectingGattBeforeWritingAccountKey(SECOND_BOOL)
+ .build();
+ assertThat(prefs2.getSkipDisconnectingGattBeforeWritingAccountKey()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testMoreEventLogForQuality() {
+ Preferences prefs =
+ Preferences.builder().setMoreEventLogForQuality(FIRST_BOOL).build();
+ assertThat(prefs.getMoreEventLogForQuality()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getMoreEventLogForQuality())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setMoreEventLogForQuality(SECOND_BOOL).build();
+ assertThat(prefs2.getMoreEventLogForQuality()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRetryGattConnectionAndSecretHandshake() {
+ Preferences prefs =
+ Preferences.builder().setRetryGattConnectionAndSecretHandshake(FIRST_BOOL).build();
+ assertThat(prefs.getRetryGattConnectionAndSecretHandshake()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getRetryGattConnectionAndSecretHandshake())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setRetryGattConnectionAndSecretHandshake(SECOND_BOOL).build();
+ assertThat(prefs2.getRetryGattConnectionAndSecretHandshake()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testRetrySecretHandshakeTimeout() {
+ Preferences prefs =
+ Preferences.builder().setRetrySecretHandshakeTimeout(FIRST_BOOL).build();
+ assertThat(prefs.getRetrySecretHandshakeTimeout()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getRetrySecretHandshakeTimeout())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setRetrySecretHandshakeTimeout(SECOND_BOOL).build();
+ assertThat(prefs2.getRetrySecretHandshakeTimeout()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testLogUserManualRetry() {
+ Preferences prefs =
+ Preferences.builder().setLogUserManualRetry(FIRST_BOOL).build();
+ assertThat(prefs.getLogUserManualRetry()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getLogUserManualRetry())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setLogUserManualRetry(SECOND_BOOL).build();
+ assertThat(prefs2.getLogUserManualRetry()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testIsDeviceFinishCheckAddressFromCache() {
+ Preferences prefs =
+ Preferences.builder().setIsDeviceFinishCheckAddressFromCache(FIRST_BOOL).build();
+ assertThat(prefs.getIsDeviceFinishCheckAddressFromCache()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getIsDeviceFinishCheckAddressFromCache())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setIsDeviceFinishCheckAddressFromCache(SECOND_BOOL).build();
+ assertThat(prefs2.getIsDeviceFinishCheckAddressFromCache()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testLogPairWithCachedModelId() {
+ Preferences prefs =
+ Preferences.builder().setLogPairWithCachedModelId(FIRST_BOOL).build();
+ assertThat(prefs.getLogPairWithCachedModelId()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getLogPairWithCachedModelId())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setLogPairWithCachedModelId(SECOND_BOOL).build();
+ assertThat(prefs2.getLogPairWithCachedModelId()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testDirectConnectProfileIfModelIdInCache() {
+ Preferences prefs =
+ Preferences.builder().setDirectConnectProfileIfModelIdInCache(FIRST_BOOL).build();
+ assertThat(prefs.getDirectConnectProfileIfModelIdInCache()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getDirectConnectProfileIfModelIdInCache())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setDirectConnectProfileIfModelIdInCache(SECOND_BOOL).build();
+ assertThat(prefs2.getDirectConnectProfileIfModelIdInCache()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testAcceptPasskey() {
+ Preferences prefs =
+ Preferences.builder().setAcceptPasskey(FIRST_BOOL).build();
+ assertThat(prefs.getAcceptPasskey()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getAcceptPasskey())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setAcceptPasskey(SECOND_BOOL).build();
+ assertThat(prefs2.getAcceptPasskey()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testProviderInitiatesBondingIfSupported() {
+ Preferences prefs =
+ Preferences.builder().setProviderInitiatesBondingIfSupported(FIRST_BOOL).build();
+ assertThat(prefs.getProviderInitiatesBondingIfSupported()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getProviderInitiatesBondingIfSupported())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setProviderInitiatesBondingIfSupported(SECOND_BOOL).build();
+ assertThat(prefs2.getProviderInitiatesBondingIfSupported()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testAttemptDirectConnectionWhenPreviouslyBonded() {
+ Preferences prefs =
+ Preferences.builder()
+ .setAttemptDirectConnectionWhenPreviouslyBonded(FIRST_BOOL).build();
+ assertThat(prefs.getAttemptDirectConnectionWhenPreviouslyBonded()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getAttemptDirectConnectionWhenPreviouslyBonded())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder()
+ .setAttemptDirectConnectionWhenPreviouslyBonded(SECOND_BOOL).build();
+ assertThat(prefs2.getAttemptDirectConnectionWhenPreviouslyBonded()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testAutomaticallyReconnectGattWhenNeeded() {
+ Preferences prefs =
+ Preferences.builder().setAutomaticallyReconnectGattWhenNeeded(FIRST_BOOL).build();
+ assertThat(prefs.getAutomaticallyReconnectGattWhenNeeded()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getAutomaticallyReconnectGattWhenNeeded())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setAutomaticallyReconnectGattWhenNeeded(SECOND_BOOL).build();
+ assertThat(prefs2.getAutomaticallyReconnectGattWhenNeeded()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSkipConnectingProfiles() {
+ Preferences prefs =
+ Preferences.builder().setSkipConnectingProfiles(FIRST_BOOL).build();
+ assertThat(prefs.getSkipConnectingProfiles()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getSkipConnectingProfiles())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setSkipConnectingProfiles(SECOND_BOOL).build();
+ assertThat(prefs2.getSkipConnectingProfiles()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testIgnoreUuidTimeoutAfterBonded() {
+ Preferences prefs =
+ Preferences.builder().setIgnoreUuidTimeoutAfterBonded(FIRST_BOOL).build();
+ assertThat(prefs.getIgnoreUuidTimeoutAfterBonded()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getIgnoreUuidTimeoutAfterBonded())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setIgnoreUuidTimeoutAfterBonded(SECOND_BOOL).build();
+ assertThat(prefs2.getIgnoreUuidTimeoutAfterBonded()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSpecifyCreateBondTransportType() {
+ Preferences prefs =
+ Preferences.builder().setSpecifyCreateBondTransportType(FIRST_BOOL).build();
+ assertThat(prefs.getSpecifyCreateBondTransportType()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getSpecifyCreateBondTransportType())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setSpecifyCreateBondTransportType(SECOND_BOOL).build();
+ assertThat(prefs2.getSpecifyCreateBondTransportType()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testIncreaseIntentFilterPriority() {
+ Preferences prefs =
+ Preferences.builder().setIncreaseIntentFilterPriority(FIRST_BOOL).build();
+ assertThat(prefs.getIncreaseIntentFilterPriority()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getIncreaseIntentFilterPriority())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setIncreaseIntentFilterPriority(SECOND_BOOL).build();
+ assertThat(prefs2.getIncreaseIntentFilterPriority()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEvaluatePerformance() {
+ Preferences prefs =
+ Preferences.builder().setEvaluatePerformance(FIRST_BOOL).build();
+ assertThat(prefs.getEvaluatePerformance()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEvaluatePerformance())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEvaluatePerformance(SECOND_BOOL).build();
+ assertThat(prefs2.getEvaluatePerformance()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnableNamingCharacteristic() {
+ Preferences prefs =
+ Preferences.builder().setEnableNamingCharacteristic(FIRST_BOOL).build();
+ assertThat(prefs.getEnableNamingCharacteristic()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnableNamingCharacteristic())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnableNamingCharacteristic(SECOND_BOOL).build();
+ assertThat(prefs2.getEnableNamingCharacteristic()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnableFirmwareVersionCharacteristic() {
+ Preferences prefs =
+ Preferences.builder().setEnableFirmwareVersionCharacteristic(FIRST_BOOL).build();
+ assertThat(prefs.getEnableFirmwareVersionCharacteristic()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnableFirmwareVersionCharacteristic())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnableFirmwareVersionCharacteristic(SECOND_BOOL).build();
+ assertThat(prefs2.getEnableFirmwareVersionCharacteristic()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testKeepSameAccountKeyWrite() {
+ Preferences prefs =
+ Preferences.builder().setKeepSameAccountKeyWrite(FIRST_BOOL).build();
+ assertThat(prefs.getKeepSameAccountKeyWrite()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getKeepSameAccountKeyWrite())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setKeepSameAccountKeyWrite(SECOND_BOOL).build();
+ assertThat(prefs2.getKeepSameAccountKeyWrite()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testIsRetroactivePairing() {
+ Preferences prefs =
+ Preferences.builder().setIsRetroactivePairing(FIRST_BOOL).build();
+ assertThat(prefs.getIsRetroactivePairing()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getIsRetroactivePairing())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setIsRetroactivePairing(SECOND_BOOL).build();
+ assertThat(prefs2.getIsRetroactivePairing()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSupportHidDevice() {
+ Preferences prefs =
+ Preferences.builder().setSupportHidDevice(FIRST_BOOL).build();
+ assertThat(prefs.getSupportHidDevice()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getSupportHidDevice())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setSupportHidDevice(SECOND_BOOL).build();
+ assertThat(prefs2.getSupportHidDevice()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnablePairingWhileDirectlyConnecting() {
+ Preferences prefs =
+ Preferences.builder().setEnablePairingWhileDirectlyConnecting(FIRST_BOOL).build();
+ assertThat(prefs.getEnablePairingWhileDirectlyConnecting()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnablePairingWhileDirectlyConnecting())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnablePairingWhileDirectlyConnecting(SECOND_BOOL).build();
+ assertThat(prefs2.getEnablePairingWhileDirectlyConnecting()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testAcceptConsentForFastPairOne() {
+ Preferences prefs =
+ Preferences.builder().setAcceptConsentForFastPairOne(FIRST_BOOL).build();
+ assertThat(prefs.getAcceptConsentForFastPairOne()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getAcceptConsentForFastPairOne())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setAcceptConsentForFastPairOne(SECOND_BOOL).build();
+ assertThat(prefs2.getAcceptConsentForFastPairOne()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnable128BitCustomGattCharacteristicsId() {
+ Preferences prefs =
+ Preferences.builder().setEnable128BitCustomGattCharacteristicsId(FIRST_BOOL)
+ .build();
+ assertThat(prefs.getEnable128BitCustomGattCharacteristicsId()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnable128BitCustomGattCharacteristicsId())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnable128BitCustomGattCharacteristicsId(SECOND_BOOL)
+ .build();
+ assertThat(prefs2.getEnable128BitCustomGattCharacteristicsId()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnableSendExceptionStepToValidator() {
+ Preferences prefs =
+ Preferences.builder().setEnableSendExceptionStepToValidator(FIRST_BOOL).build();
+ assertThat(prefs.getEnableSendExceptionStepToValidator()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnableSendExceptionStepToValidator())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnableSendExceptionStepToValidator(SECOND_BOOL).build();
+ assertThat(prefs2.getEnableSendExceptionStepToValidator()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnableAdditionalDataTypeWhenActionOverBle() {
+ Preferences prefs =
+ Preferences.builder().setEnableAdditionalDataTypeWhenActionOverBle(FIRST_BOOL)
+ .build();
+ assertThat(prefs.getEnableAdditionalDataTypeWhenActionOverBle()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnableAdditionalDataTypeWhenActionOverBle())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnableAdditionalDataTypeWhenActionOverBle(SECOND_BOOL)
+ .build();
+ assertThat(prefs2.getEnableAdditionalDataTypeWhenActionOverBle()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testCheckBondStateWhenSkipConnectingProfiles() {
+ Preferences prefs =
+ Preferences.builder().setCheckBondStateWhenSkipConnectingProfiles(FIRST_BOOL)
+ .build();
+ assertThat(prefs.getCheckBondStateWhenSkipConnectingProfiles()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getCheckBondStateWhenSkipConnectingProfiles())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setCheckBondStateWhenSkipConnectingProfiles(SECOND_BOOL)
+ .build();
+ assertThat(prefs2.getCheckBondStateWhenSkipConnectingProfiles()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testHandlePasskeyConfirmationByUi() {
+ Preferences prefs =
+ Preferences.builder().setHandlePasskeyConfirmationByUi(FIRST_BOOL).build();
+ assertThat(prefs.getHandlePasskeyConfirmationByUi()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getHandlePasskeyConfirmationByUi())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setHandlePasskeyConfirmationByUi(SECOND_BOOL).build();
+ assertThat(prefs2.getHandlePasskeyConfirmationByUi()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testEnablePairFlowShowUiWithoutProfileConnection() {
+ Preferences prefs =
+ Preferences.builder().setEnablePairFlowShowUiWithoutProfileConnection(FIRST_BOOL)
+ .build();
+ assertThat(prefs.getEnablePairFlowShowUiWithoutProfileConnection()).isEqualTo(FIRST_BOOL);
+ assertThat(prefs.toBuilder().build().getEnablePairFlowShowUiWithoutProfileConnection())
+ .isEqualTo(FIRST_BOOL);
+
+ Preferences prefs2 =
+ Preferences.builder().setEnablePairFlowShowUiWithoutProfileConnection(SECOND_BOOL)
+ .build();
+ assertThat(prefs2.getEnablePairFlowShowUiWithoutProfileConnection()).isEqualTo(SECOND_BOOL);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBrHandoverDataCharacteristicId() {
+ Preferences prefs =
+ Preferences.builder().setBrHandoverDataCharacteristicId(FIRST_SHORT).build();
+ assertThat(prefs.getBrHandoverDataCharacteristicId()).isEqualTo(FIRST_SHORT);
+ assertThat(prefs.toBuilder().build().getBrHandoverDataCharacteristicId())
+ .isEqualTo(FIRST_SHORT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBrHandoverDataCharacteristicId(SECOND_SHORT).build();
+ assertThat(prefs2.getBrHandoverDataCharacteristicId()).isEqualTo(SECOND_SHORT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBluetoothSigDataCharacteristicId() {
+ Preferences prefs =
+ Preferences.builder().setBluetoothSigDataCharacteristicId(FIRST_SHORT).build();
+ assertThat(prefs.getBluetoothSigDataCharacteristicId()).isEqualTo(FIRST_SHORT);
+ assertThat(prefs.toBuilder().build().getBluetoothSigDataCharacteristicId())
+ .isEqualTo(FIRST_SHORT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBluetoothSigDataCharacteristicId(SECOND_SHORT).build();
+ assertThat(prefs2.getBluetoothSigDataCharacteristicId()).isEqualTo(SECOND_SHORT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testFirmwareVersionCharacteristicId() {
+ Preferences prefs =
+ Preferences.builder().setFirmwareVersionCharacteristicId(FIRST_SHORT).build();
+ assertThat(prefs.getFirmwareVersionCharacteristicId()).isEqualTo(FIRST_SHORT);
+ assertThat(prefs.toBuilder().build().getFirmwareVersionCharacteristicId())
+ .isEqualTo(FIRST_SHORT);
+
+ Preferences prefs2 =
+ Preferences.builder().setFirmwareVersionCharacteristicId(SECOND_SHORT).build();
+ assertThat(prefs2.getFirmwareVersionCharacteristicId()).isEqualTo(SECOND_SHORT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testBrTransportBlockDataDescriptorId() {
+ Preferences prefs =
+ Preferences.builder().setBrTransportBlockDataDescriptorId(FIRST_SHORT).build();
+ assertThat(prefs.getBrTransportBlockDataDescriptorId()).isEqualTo(FIRST_SHORT);
+ assertThat(prefs.toBuilder().build().getBrTransportBlockDataDescriptorId())
+ .isEqualTo(FIRST_SHORT);
+
+ Preferences prefs2 =
+ Preferences.builder().setBrTransportBlockDataDescriptorId(SECOND_SHORT).build();
+ assertThat(prefs2.getBrTransportBlockDataDescriptorId()).isEqualTo(SECOND_SHORT);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectShortTimeoutMs() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectShortTimeoutMs(FIRST_LONG).build();
+ assertThat(prefs.getGattConnectShortTimeoutMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getGattConnectShortTimeoutMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectShortTimeoutMs(SECOND_LONG).build();
+ assertThat(prefs2.getGattConnectShortTimeoutMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectLongTimeoutMs() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectLongTimeoutMs(FIRST_LONG).build();
+ assertThat(prefs.getGattConnectLongTimeoutMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getGattConnectLongTimeoutMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectLongTimeoutMs(SECOND_LONG).build();
+ assertThat(prefs2.getGattConnectLongTimeoutMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectShortTimeoutRetryMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectShortTimeoutRetryMaxSpentTimeMs(FIRST_LONG)
+ .build();
+ assertThat(prefs.getGattConnectShortTimeoutRetryMaxSpentTimeMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getGattConnectShortTimeoutRetryMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectShortTimeoutRetryMaxSpentTimeMs(SECOND_LONG)
+ .build();
+ assertThat(prefs2.getGattConnectShortTimeoutRetryMaxSpentTimeMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testAddressRotateRetryMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder().setAddressRotateRetryMaxSpentTimeMs(FIRST_LONG).build();
+ assertThat(prefs.getAddressRotateRetryMaxSpentTimeMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getAddressRotateRetryMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setAddressRotateRetryMaxSpentTimeMs(SECOND_LONG).build();
+ assertThat(prefs2.getAddressRotateRetryMaxSpentTimeMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testPairingRetryDelayMs() {
+ Preferences prefs =
+ Preferences.builder().setPairingRetryDelayMs(FIRST_LONG).build();
+ assertThat(prefs.getPairingRetryDelayMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getPairingRetryDelayMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setPairingRetryDelayMs(SECOND_LONG).build();
+ assertThat(prefs2.getPairingRetryDelayMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeShortTimeoutMs() {
+ Preferences prefs =
+ Preferences.builder().setSecretHandshakeShortTimeoutMs(FIRST_LONG).build();
+ assertThat(prefs.getSecretHandshakeShortTimeoutMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeShortTimeoutMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeShortTimeoutMs(SECOND_LONG).build();
+ assertThat(prefs2.getSecretHandshakeShortTimeoutMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeLongTimeoutMs() {
+ Preferences prefs =
+ Preferences.builder().setSecretHandshakeLongTimeoutMs(FIRST_LONG).build();
+ assertThat(prefs.getSecretHandshakeLongTimeoutMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeLongTimeoutMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeLongTimeoutMs(SECOND_LONG).build();
+ assertThat(prefs2.getSecretHandshakeLongTimeoutMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeShortTimeoutRetryMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder().setSecretHandshakeShortTimeoutRetryMaxSpentTimeMs(FIRST_LONG)
+ .build();
+ assertThat(prefs.getSecretHandshakeShortTimeoutRetryMaxSpentTimeMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeShortTimeoutRetryMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeShortTimeoutRetryMaxSpentTimeMs(SECOND_LONG)
+ .build();
+ assertThat(prefs2.getSecretHandshakeShortTimeoutRetryMaxSpentTimeMs())
+ .isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeLongTimeoutRetryMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder().setSecretHandshakeLongTimeoutRetryMaxSpentTimeMs(FIRST_LONG)
+ .build();
+ assertThat(prefs.getSecretHandshakeLongTimeoutRetryMaxSpentTimeMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeLongTimeoutRetryMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeLongTimeoutRetryMaxSpentTimeMs(SECOND_LONG)
+ .build();
+ assertThat(prefs2.getSecretHandshakeLongTimeoutRetryMaxSpentTimeMs())
+ .isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeRetryAttempts() {
+ Preferences prefs =
+ Preferences.builder().setSecretHandshakeRetryAttempts(FIRST_LONG).build();
+ assertThat(prefs.getSecretHandshakeRetryAttempts()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeRetryAttempts())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeRetryAttempts(SECOND_LONG).build();
+ assertThat(prefs2.getSecretHandshakeRetryAttempts()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSecretHandshakeRetryGattConnectionMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder()
+ .setSecretHandshakeRetryGattConnectionMaxSpentTimeMs(FIRST_LONG).build();
+ assertThat(prefs.getSecretHandshakeRetryGattConnectionMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSecretHandshakeRetryGattConnectionMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSecretHandshakeRetryGattConnectionMaxSpentTimeMs(
+ SECOND_LONG).build();
+ assertThat(prefs2.getSecretHandshakeRetryGattConnectionMaxSpentTimeMs())
+ .isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSignalLostRetryMaxSpentTimeMs() {
+ Preferences prefs =
+ Preferences.builder().setSignalLostRetryMaxSpentTimeMs(FIRST_LONG).build();
+ assertThat(prefs.getSignalLostRetryMaxSpentTimeMs()).isEqualTo(FIRST_LONG);
+ assertThat(prefs.toBuilder().build().getSignalLostRetryMaxSpentTimeMs())
+ .isEqualTo(FIRST_LONG);
+
+ Preferences prefs2 =
+ Preferences.builder().setSignalLostRetryMaxSpentTimeMs(SECOND_LONG).build();
+ assertThat(prefs2.getSignalLostRetryMaxSpentTimeMs()).isEqualTo(SECOND_LONG);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testCachedDeviceAddress() {
+ Preferences prefs =
+ Preferences.builder().setCachedDeviceAddress(FIRST_STRING).build();
+ assertThat(prefs.getCachedDeviceAddress()).isEqualTo(FIRST_STRING);
+ assertThat(prefs.toBuilder().build().getCachedDeviceAddress())
+ .isEqualTo(FIRST_STRING);
+
+ Preferences prefs2 =
+ Preferences.builder().setCachedDeviceAddress(SECOND_STRING).build();
+ assertThat(prefs2.getCachedDeviceAddress()).isEqualTo(SECOND_STRING);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testPossibleCachedDeviceAddress() {
+ Preferences prefs =
+ Preferences.builder().setPossibleCachedDeviceAddress(FIRST_STRING).build();
+ assertThat(prefs.getPossibleCachedDeviceAddress()).isEqualTo(FIRST_STRING);
+ assertThat(prefs.toBuilder().build().getPossibleCachedDeviceAddress())
+ .isEqualTo(FIRST_STRING);
+
+ Preferences prefs2 =
+ Preferences.builder().setPossibleCachedDeviceAddress(SECOND_STRING).build();
+ assertThat(prefs2.getPossibleCachedDeviceAddress()).isEqualTo(SECOND_STRING);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testSupportedProfileUuids() {
+ Preferences prefs =
+ Preferences.builder().setSupportedProfileUuids(FIRST_BYTES).build();
+ assertThat(prefs.getSupportedProfileUuids()).isEqualTo(FIRST_BYTES);
+ assertThat(prefs.toBuilder().build().getSupportedProfileUuids())
+ .isEqualTo(FIRST_BYTES);
+
+ Preferences prefs2 =
+ Preferences.builder().setSupportedProfileUuids(SECOND_BYTES).build();
+ assertThat(prefs2.getSupportedProfileUuids()).isEqualTo(SECOND_BYTES);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testGattConnectionAndSecretHandshakeNoRetryGattError() {
+ Preferences prefs =
+ Preferences.builder().setGattConnectionAndSecretHandshakeNoRetryGattError(
+ FIRST_INT_SETS).build();
+ assertThat(prefs.getGattConnectionAndSecretHandshakeNoRetryGattError())
+ .isEqualTo(FIRST_INT_SETS);
+ assertThat(prefs.toBuilder().build().getGattConnectionAndSecretHandshakeNoRetryGattError())
+ .isEqualTo(FIRST_INT_SETS);
+
+ Preferences prefs2 =
+ Preferences.builder().setGattConnectionAndSecretHandshakeNoRetryGattError(
+ SECOND_INT_SETS).build();
+ assertThat(prefs2.getGattConnectionAndSecretHandshakeNoRetryGattError())
+ .isEqualTo(SECOND_INT_SETS);
+ }
+
+ @Test
+ @SdkSuppress(minSdkVersion = 32, codeName = "T")
+ public void testExtraLoggingInformation() {
+ Preferences prefs =
+ Preferences.builder().setExtraLoggingInformation(FIRST_EXTRA_LOGGING_INFO).build();
+ assertThat(prefs.getExtraLoggingInformation()).isEqualTo(FIRST_EXTRA_LOGGING_INFO);
+ assertThat(prefs.toBuilder().build().getExtraLoggingInformation())
+ .isEqualTo(FIRST_EXTRA_LOGGING_INFO);
+
+ Preferences prefs2 =
+ Preferences.builder().setExtraLoggingInformation(SECOND_EXTRA_LOGGING_INFO).build();
+ assertThat(prefs2.getExtraLoggingInformation()).isEqualTo(SECOND_EXTRA_LOGGING_INFO);
+ }
+}
diff --git a/nearby/tests/unit/src/com/android/server/nearby/fastpair/FastPairManagerTest.java b/nearby/tests/unit/src/com/android/server/nearby/fastpair/FastPairManagerTest.java
index f061115..26d1847 100644
--- a/nearby/tests/unit/src/com/android/server/nearby/fastpair/FastPairManagerTest.java
+++ b/nearby/tests/unit/src/com/android/server/nearby/fastpair/FastPairManagerTest.java
@@ -19,10 +19,12 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import android.content.Context;
import androidx.test.filters.SdkSuppress;
+import androidx.test.platform.app.InstrumentationRegistry;
import com.android.server.nearby.common.locator.LocatorContextWrapper;
@@ -40,8 +42,11 @@
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
+
mLocatorContextWrapper = new LocatorContextWrapper(mContext);
mFastPairManager = new FastPairManager(mLocatorContextWrapper);
+ when(mContext.getContentResolver()).thenReturn(
+ InstrumentationRegistry.getInstrumentation().getContext().getContentResolver());
}
@Test