RemoteAuth discovery implementation
Ignore-AOSP-First: Dependent changes in CDM are not available in
aosp-main.
Bug: 290264664
Test: atest RemoteAuthUnitTest
Change-Id: I4e33178313d2add09436bf01ce127b3df152974e
diff --git a/remoteauth/tests/unit/Android.bp b/remoteauth/tests/unit/Android.bp
index 629d360..ccfa20e 100644
--- a/remoteauth/tests/unit/Android.bp
+++ b/remoteauth/tests/unit/Android.bp
@@ -29,17 +29,20 @@
"android.test.base",
"android.test.mock",
"android.test.runner",
+ "framework-annotations-lib",
],
compile_multilib: "both",
static_libs: [
"androidx.test.ext.junit",
+ "androidx.test.ext.truth",
"androidx.test.rules",
"com.uwb.support.generic",
"framework-remoteauth-static",
"junit",
"libprotobuf-java-lite",
"mockito-target-extended-minus-junit4",
+ "mockito-target-minus-junit4",
"platform-test-annotations",
"service-remoteauth-pre-jarjar",
"truth-prebuilt",
diff --git a/remoteauth/tests/unit/AndroidManifest.xml b/remoteauth/tests/unit/AndroidManifest.xml
index 0449409..a5294c8 100644
--- a/remoteauth/tests/unit/AndroidManifest.xml
+++ b/remoteauth/tests/unit/AndroidManifest.xml
@@ -31,5 +31,6 @@
<instrumentation
android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.remoteauth.test"
- android:label="RemoteAuth Mainline Module Tests" />
+ android:label="RemoteAuth Mainline Module Tests"
+ android:directBootAware="true"/>
</manifest>
diff --git a/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/CdmConnectivityManagerTest.java b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/CdmConnectivityManagerTest.java
new file mode 100644
index 0000000..824344a
--- /dev/null
+++ b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/CdmConnectivityManagerTest.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2023 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.remoteauth.connectivity;
+
+import static com.google.common.truth.Truth.assertThat;
+
+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.companion.AssociationInfo;
+import android.companion.AssociationRequest;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.google.common.util.concurrent.SettableFuture;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/** Unit tests for {@link CdmConnectivityManager}. */
+@RunWith(AndroidJUnit4.class)
+public class CdmConnectivityManagerTest {
+ @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+ @Mock CompanionDeviceManagerWrapper mCompanionDeviceManagerWrapper;
+
+ private CdmConnectivityManager mCdmConnectivityManager;
+ private ExecutorService mTestExecutor = Executors.newSingleThreadExecutor();
+
+ @Before
+ public void setUp() {
+ mCdmConnectivityManager =
+ new CdmConnectivityManager(mTestExecutor, mCompanionDeviceManagerWrapper);
+ }
+
+ @After
+ public void tearDown() {
+ mTestExecutor.shutdown();
+ }
+
+ @Test
+ public void testStartDiscovery_callsGetAllAssociationsOnce() throws InterruptedException {
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), Utils.getFakeDiscoveredDeviceReceiver());
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(1)).getAllAssociations();
+ }
+
+ @Test
+ public void testStartDiscovery_fetchesNoAssociations() {
+ SettableFuture<Boolean> future = SettableFuture.create();
+
+ when(mCompanionDeviceManagerWrapper.getAllAssociations())
+ .thenReturn(Utils.getFakeAssociationInfoList(0));
+
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future.set(true);
+ }
+
+ @Override
+ public void onLost(DiscoveredDevice unused) {
+ future.set(true);
+ }
+ };
+
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver);
+
+ assertThat(future.isDone()).isFalse();
+ }
+
+ @Test
+ public void testStartDiscovery_DoesNotReturnNonWatchAssociations() throws InterruptedException {
+ SettableFuture<Boolean> future = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future.set(true);
+ }
+
+ @Override
+ public void onLost(DiscoveredDevice unused) {
+ future.set(true);
+ }
+ };
+
+ when(mCompanionDeviceManagerWrapper.getDeviceProfile(any(AssociationInfo.class)))
+ .thenReturn(Utils.FAKE_DEVICE_PROFILE);
+
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver);
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(1)).getAllAssociations();
+ verify(mCompanionDeviceManagerWrapper, times(0))
+ .getDeviceProfile(any(AssociationInfo.class));
+ assertThat(future.isDone()).isFalse();
+ }
+
+ @Test
+ public void testStartDiscovery_returnsOneWatchAssociation() throws InterruptedException {
+ SettableFuture<Boolean> future = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future.set(true);
+ }
+ };
+
+ when(mCompanionDeviceManagerWrapper.getAllAssociations())
+ .thenReturn(Utils.getFakeAssociationInfoList(1));
+ when(mCompanionDeviceManagerWrapper.getDeviceProfile(any(AssociationInfo.class)))
+ .thenReturn(AssociationRequest.DEVICE_PROFILE_WATCH);
+
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver);
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(1)).getAllAssociations();
+ verify(mCompanionDeviceManagerWrapper, times(1))
+ .getDeviceProfile(any(AssociationInfo.class));
+ assertThat(future.isDone()).isTrue();
+ }
+
+ @Test
+ public void testStartDiscovery_returnsMultipleWatchAssociations() throws InterruptedException {
+ int numAssociations = 3;
+ SettableFuture<Boolean> future = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ int mNumCallbacks = 0;
+
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ ++mNumCallbacks;
+ if (mNumCallbacks == numAssociations) {
+ future.set(true);
+ }
+ }
+ };
+
+ when(mCompanionDeviceManagerWrapper.getAllAssociations())
+ .thenReturn(Utils.getFakeAssociationInfoList(numAssociations));
+ when(mCompanionDeviceManagerWrapper.getDeviceProfile(any(AssociationInfo.class)))
+ .thenReturn(AssociationRequest.DEVICE_PROFILE_WATCH);
+
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver);
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(1)).getAllAssociations();
+ verify(mCompanionDeviceManagerWrapper, times(numAssociations))
+ .getDeviceProfile(any(AssociationInfo.class));
+ assertThat(future.isDone()).isTrue();
+ }
+
+ @Test
+ public void testMultipleStartDiscovery_runsAllCallbacks() throws InterruptedException {
+ SettableFuture<Boolean> future1 = SettableFuture.create();
+ SettableFuture<Boolean> future2 = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver1 =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future1.set(true);
+ }
+ };
+ DiscoveredDeviceReceiver discoveredDeviceReceiver2 =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future2.set(true);
+ }
+ };
+
+ when(mCompanionDeviceManagerWrapper.getAllAssociations())
+ .thenReturn(Utils.getFakeAssociationInfoList(1));
+ when(mCompanionDeviceManagerWrapper.getDeviceProfile(any(AssociationInfo.class)))
+ .thenReturn(AssociationRequest.DEVICE_PROFILE_WATCH);
+
+ // Start discovery twice with different callbacks.
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver1);
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver2);
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(2)).getAllAssociations();
+ verify(mCompanionDeviceManagerWrapper, times(2))
+ .getDeviceProfile(any(AssociationInfo.class));
+ assertThat(future1.isDone()).isTrue();
+ assertThat(future2.isDone()).isTrue();
+ }
+
+ @Test
+ public void testStartDiscovery_returnsExpectedDiscoveredDevice() throws InterruptedException {
+ SettableFuture<Boolean> future = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice device) {
+ assertThat(device.getConnectionInfo() instanceof CdmConnectionInfo)
+ .isTrue();
+
+ CdmConnectionInfo connectionInfo =
+ (CdmConnectionInfo) device.getConnectionInfo();
+ if (connectionInfo.getConnectionParams().getDeviceMacAddress().toString()
+ .equals(Utils.FAKE_PEER_ADDRESS)
+ && connectionInfo.getConnectionId() == Utils.FAKE_CONNECTION_ID) {
+ future.set(true);
+ }
+ }
+ };
+
+ when(mCompanionDeviceManagerWrapper.getAllAssociations())
+ .thenReturn(Utils.getFakeAssociationInfoList(1));
+ when(mCompanionDeviceManagerWrapper.getDeviceProfile(any(AssociationInfo.class)))
+ .thenReturn(AssociationRequest.DEVICE_PROFILE_WATCH);
+
+ mCdmConnectivityManager.startDiscovery(
+ Utils.getFakeDiscoveryFilter(), discoveredDeviceReceiver);
+
+ mTestExecutor.awaitTermination(1, TimeUnit.SECONDS);
+
+ verify(mCompanionDeviceManagerWrapper, times(1)).getAllAssociations();
+ verify(mCompanionDeviceManagerWrapper, times(1))
+ .getDeviceProfile(any(AssociationInfo.class));
+ assertThat(future.isDone()).isTrue();
+ }
+
+ @Test
+ public void testStopDiscovery_removesCallback() {
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {}
+ };
+
+ DiscoveryFilter discoveryFilter = Utils.getFakeDiscoveryFilter();
+ mCdmConnectivityManager.startDiscovery(discoveryFilter, discoveredDeviceReceiver);
+
+ assertThat(mCdmConnectivityManager.hasPendingCallbacks(discoveredDeviceReceiver)).isTrue();
+
+ mCdmConnectivityManager.stopDiscovery(discoveryFilter, discoveredDeviceReceiver);
+
+ assertThat(mCdmConnectivityManager.hasPendingCallbacks(discoveredDeviceReceiver)).isFalse();
+ }
+
+ @Test
+ public void testStopDiscovery_DoesNotRunCallback() {
+ SettableFuture future = SettableFuture.create();
+ DiscoveredDeviceReceiver discoveredDeviceReceiver =
+ new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {
+ future.set(true);
+ }
+ };
+
+ DiscoveryFilter discoveryFilter = Utils.getFakeDiscoveryFilter();
+ mCdmConnectivityManager.startDiscovery(discoveryFilter, discoveredDeviceReceiver);
+ mCdmConnectivityManager.stopDiscovery(discoveryFilter, discoveredDeviceReceiver);
+
+ assertThat(future.isDone()).isFalse();
+ }
+}
+
diff --git a/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/ConnectivityManagerFactoryTest.java b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/ConnectivityManagerFactoryTest.java
new file mode 100644
index 0000000..42eff90
--- /dev/null
+++ b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/ConnectivityManagerFactoryTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 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.remoteauth.connectivity;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Unit tests for {@link CdmConnectivityManager}. */
+@RunWith(AndroidJUnit4.class)
+public class ConnectivityManagerFactoryTest {
+
+ @Before
+ public void setUp() {}
+
+ @Test
+ public void testFactory_returnsConnectivityManager() {
+ final Context context = InstrumentationRegistry.getInstrumentation().getContext();
+ ConnectivityManager connectivityManager =
+ ConnectivityManagerFactory.getConnectivityManager(context);
+
+ assertThat(connectivityManager).isNotNull();
+ }
+}
diff --git a/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/Utils.java b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/Utils.java
new file mode 100644
index 0000000..a5c992a
--- /dev/null
+++ b/remoteauth/tests/unit/src/com/android/server/remoteauth/connectivity/Utils.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2023 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.remoteauth.connectivity;
+
+import android.companion.AssociationInfo;
+import android.companion.AssociationRequest;
+import android.content.pm.PackageManager;
+import android.net.MacAddress;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Utils {
+ public static final int FAKE_CONNECTION_ID = 1;
+ public static final int FAKE_USER_ID = 0;
+ public static final String FAKE_DISPLAY_NAME = "FAKE-DISPLAY-NAME";
+ public static final String FAKE_PEER_ADDRESS = "ff:ff:ff:ff:ff:ff";
+ public static final String FAKE_DEVICE_PROFILE = "FAKE-DEVICE-PROFILE";
+ public static final String FAKE_PACKAGE_NAME = "FAKE-PACKAGE-NAME";
+
+ public static DiscoveryFilter getFakeDiscoveryFilter() {
+ return DiscoveryFilter.Builder.builder()
+ .setDeviceName(FAKE_DISPLAY_NAME)
+ .setPeerAddress("FAKE-PEER-ADDRESS")
+ .setDeviceType(DiscoveryFilter.WATCH)
+ .build();
+ }
+
+ public static DiscoveredDeviceReceiver getFakeDiscoveredDeviceReceiver() {
+ return new DiscoveredDeviceReceiver() {
+ @Override
+ public void onDiscovered(DiscoveredDevice unused) {}
+
+ @Override
+ public void onLost(DiscoveredDevice unused) {}
+ };
+ }
+
+ /**
+ * Returns a fake CDM connection info.
+ *
+ * @return connection info.
+ */
+ public static CdmConnectionInfo getFakeCdmConnectionInfo()
+ throws PackageManager.NameNotFoundException {
+ return new CdmConnectionInfo(FAKE_CONNECTION_ID, getFakeAssociationInfoList(1).get(0));
+ }
+
+ /**
+ * Returns a fake discovered device.
+ *
+ * @return discovered device.
+ */
+ public static DiscoveredDevice getFakeCdmDiscoveredDevice()
+ throws PackageManager.NameNotFoundException {
+ return new DiscoveredDevice(getFakeCdmConnectionInfo(), FAKE_DISPLAY_NAME);
+ }
+
+ /**
+ * Returns fake association info array.
+ *
+ * <p> Creates an AssociationInfo object with fake values.
+ *
+ * @param associationsSize number of fake association info entries to return.
+ * @return list of {@link AssociationInfo} or null.
+ */
+ public static List<AssociationInfo> getFakeAssociationInfoList(int associationsSize) {
+ if (associationsSize > 0) {
+ List<AssociationInfo> associations = new ArrayList<>();
+ // Association id starts from 1.
+ for (int i = 1; i <= associationsSize; ++i) {
+ associations.add(
+ (new AssociationInfo.Builder(i, FAKE_USER_ID, FAKE_PACKAGE_NAME))
+ .setDeviceProfile(AssociationRequest.DEVICE_PROFILE_WATCH)
+ .setDisplayName(FAKE_DISPLAY_NAME)
+ .setDeviceMacAddress(MacAddress.fromString(FAKE_PEER_ADDRESS))
+ .build());
+ }
+ return associations;
+ }
+ return new ArrayList<>();
+ }
+
+ private Utils() {}
+}