From 25128d110211cbb6cbecbbe5ebbece6992bc6252 Mon Sep 17 00:00:00 2001 From: Ze Li Date: Tue, 30 Jan 2024 16:20:37 +0800 Subject: [PATCH 1/6] [Hide DCK devices] Hide DCK devices from settings app (saved devices page). Set preferences of DCK devices to be invisible in saved devices page. Test: atest: com.android.settings.bluetooth.SavedBluetoothDeviceUpdaterTest Bug: 322285078 Change-Id: I9bd38c1866f469f3c0395b77f935f7eb143ec70c --- ..._connecteddevice_flag_declarations.aconfig | 7 + .../SavedBluetoothDeviceUpdater.java | 24 ++- .../SavedBluetoothDeviceUpdaterTest.java | 143 +++++++++++++++++- 3 files changed, 166 insertions(+), 8 deletions(-) diff --git a/aconfig/settings_connecteddevice_flag_declarations.aconfig b/aconfig/settings_connecteddevice_flag_declarations.aconfig index 5ba21296a6d..0fc164e84a2 100644 --- a/aconfig/settings_connecteddevice_flag_declarations.aconfig +++ b/aconfig/settings_connecteddevice_flag_declarations.aconfig @@ -33,4 +33,11 @@ flag { namespace: "pixel_cross_device_control" description: "Order the saved bluetooth devices by most recently connected." bug: "306160434" +} + +flag { + name: "enable_hide_exclusively_managed_bluetooth_device" + namespace: "dck_framework" + description: "Hide exclusively managed Bluetooth devices in BT settings menu." + bug: "322285078" } \ No newline at end of file diff --git a/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdater.java b/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdater.java index bfd4221ea52..1db90fa6fef 100644 --- a/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdater.java +++ b/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdater.java @@ -25,6 +25,8 @@ import androidx.annotation.VisibleForTesting; import androidx.preference.Preference; import com.android.settings.connecteddevice.DevicePreferenceCallback; +import com.android.settings.flags.Flags; +import com.android.settingslib.bluetooth.BluetoothUtils; import com.android.settingslib.bluetooth.CachedBluetoothDevice; import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager; @@ -99,12 +101,22 @@ public class SavedBluetoothDeviceUpdater extends BluetoothDeviceUpdater @Override public boolean isFilterMatched(CachedBluetoothDevice cachedDevice) { final BluetoothDevice device = cachedDevice.getDevice(); - Log.d(TAG, "isFilterMatched() device name : " + cachedDevice.getName() + - ", is connected : " + device.isConnected() + ", is profile connected : " - + cachedDevice.isConnected()); - return device.getBondState() == BluetoothDevice.BOND_BONDED - && (mShowConnectedDevice || (!device.isConnected() && isDeviceInCachedDevicesList( - cachedDevice))); + boolean isExclusivelyManaged = BluetoothUtils.isExclusivelyManagedBluetoothDevice(mContext, + cachedDevice.getDevice()); + Log.d(TAG, "isFilterMatched() device name : " + cachedDevice.getName() + + ", is connected : " + device.isConnected() + ", is profile connected : " + + cachedDevice.isConnected() + ", is exclusively managed : " + + isExclusivelyManaged); + if (Flags.enableHideExclusivelyManagedBluetoothDevice()) { + return device.getBondState() == BluetoothDevice.BOND_BONDED + && (mShowConnectedDevice || (!device.isConnected() + && isDeviceInCachedDevicesList(cachedDevice))) + && !isExclusivelyManaged; + } else { + return device.getBondState() == BluetoothDevice.BOND_BONDED + && (mShowConnectedDevice || (!device.isConnected() + && isDeviceInCachedDevicesList(cachedDevice))); + } } @Override diff --git a/tests/robotests/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdaterTest.java b/tests/robotests/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdaterTest.java index c22944905a2..349391d43ba 100644 --- a/tests/robotests/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdaterTest.java +++ b/tests/robotests/src/com/android/settings/bluetooth/SavedBluetoothDeviceUpdaterTest.java @@ -18,6 +18,7 @@ package com.android.settings.bluetooth; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; @@ -28,17 +29,26 @@ import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothProfile; import android.content.Context; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; import android.graphics.drawable.Drawable; +import android.platform.test.annotations.RequiresFlagsDisabled; +import android.platform.test.annotations.RequiresFlagsEnabled; +import android.platform.test.flag.junit.CheckFlagsRule; +import android.platform.test.flag.junit.DeviceFlagsValueProvider; import android.util.Pair; import com.android.settings.connecteddevice.DevicePreferenceCallback; import com.android.settings.dashboard.DashboardFragment; +import com.android.settings.flags.Flags; import com.android.settings.testutils.shadow.ShadowBluetoothAdapter; +import com.android.settingslib.bluetooth.BluetoothUtils; import com.android.settingslib.bluetooth.CachedBluetoothDevice; import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager; import com.android.settingslib.bluetooth.LocalBluetoothManager; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -56,6 +66,10 @@ import java.util.List; public class SavedBluetoothDeviceUpdaterTest { private static final String MAC_ADDRESS = "04:52:C7:0B:D8:3C"; + private static final String FAKE_EXCLUSIVE_MANAGER_NAME = "com.fake.name"; + + @Rule + public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); @Mock private DashboardFragment mDashboardFragment; @@ -73,6 +87,8 @@ public class SavedBluetoothDeviceUpdaterTest { private LocalBluetoothManager mBluetoothManager; @Mock private Drawable mDrawable; + @Mock + private PackageManager mPackageManager; private Context mContext; private SavedBluetoothDeviceUpdater mBluetoothDeviceUpdater; @@ -84,12 +100,13 @@ public class SavedBluetoothDeviceUpdaterTest { MockitoAnnotations.initMocks(this); Pair pairs = new Pair<>(mDrawable, "fake_device"); - mContext = RuntimeEnvironment.application; + mContext = spy(RuntimeEnvironment.application); doReturn(mContext).when(mDashboardFragment).getContext(); when(mCachedBluetoothDevice.getDevice()).thenReturn(mBluetoothDevice); when(mCachedBluetoothDevice.getAddress()).thenReturn(MAC_ADDRESS); when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); when(mCachedBluetoothDevice.getDrawableWithDescription()).thenReturn(pairs); + when(mContext.getPackageManager()).thenReturn(mPackageManager); mBluetoothDeviceUpdater = spy(new SavedBluetoothDeviceUpdater(mContext, mDevicePreferenceCallback, false, /* metricsCategory= */ 0)); @@ -103,10 +120,10 @@ public class SavedBluetoothDeviceUpdaterTest { mCachedDevices.add(mCachedBluetoothDevice); when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); when(mDeviceManager.getCachedDevicesCopy()).thenReturn(mCachedDevices); - } @Test + @RequiresFlagsDisabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) public void update_filterMatch_addPreference() { doReturn(BluetoothDevice.BOND_BONDED).when(mBluetoothDevice).getBondState(); doReturn(false).when(mBluetoothDevice).isConnected(); @@ -118,6 +135,7 @@ public class SavedBluetoothDeviceUpdaterTest { } @Test + @RequiresFlagsDisabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) public void update_filterNotMatch_removePreference() { doReturn(BluetoothDevice.BOND_NONE).when(mBluetoothDevice).getBondState(); doReturn(true).when(mBluetoothDevice).isConnected(); @@ -298,4 +316,125 @@ public class SavedBluetoothDeviceUpdaterTest { verify(mBluetoothDeviceUpdater, never()).addPreference(mCachedBluetoothDevice, BluetoothDevicePreference.SortType.TYPE_NO_SORT); } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_notExclusivelyManagedDevice_addDevice() { + final Collection cachedDevices = new ArrayList<>(); + cachedDevices.add(mCachedBluetoothDevice); + + when(mBluetoothAdapter.isEnabled()).thenReturn(true); + when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); + when(mDeviceManager.getCachedDevicesCopy()).thenReturn(cachedDevices); + when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); + when(mBluetoothDevice.isConnected()).thenReturn(false); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + null); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice, + BluetoothDevicePreference.SortType.TYPE_NO_SORT); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_notAllowedExclusivelyManagedDevice_addDevice() { + final Collection cachedDevices = new ArrayList<>(); + cachedDevices.add(mCachedBluetoothDevice); + + when(mBluetoothAdapter.isEnabled()).thenReturn(true); + when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); + when(mDeviceManager.getCachedDevicesCopy()).thenReturn(cachedDevices); + when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); + when(mBluetoothDevice.isConnected()).thenReturn(false); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + FAKE_EXCLUSIVE_MANAGER_NAME.getBytes()); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice, + BluetoothDevicePreference.SortType.TYPE_NO_SORT); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_existingExclusivelyManagedDeviceWithPackageInstalled_removePreference() + throws Exception { + final Collection cachedDevices = new ArrayList<>(); + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + + when(mBluetoothAdapter.isEnabled()).thenReturn(true); + when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); + when(mDeviceManager.getCachedDevicesCopy()).thenReturn(cachedDevices); + when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); + when(mBluetoothDevice.isConnected()).thenReturn(false); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + + doReturn(new PackageInfo()).when(mPackageManager).getPackageInfo(exclusiveManagerName, 0); + mBluetoothDeviceUpdater.mPreferenceMap.put(mBluetoothDevice, mPreference); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).removePreference(mCachedBluetoothDevice); + verify(mBluetoothDeviceUpdater, never()).addPreference(mCachedBluetoothDevice, + BluetoothDevicePreference.SortType.TYPE_NO_SORT); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_newExclusivelyManagedDeviceWithPackageInstalled_doNotAddPreference() + throws Exception { + final Collection cachedDevices = new ArrayList<>(); + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + cachedDevices.add(mCachedBluetoothDevice); + + when(mBluetoothAdapter.isEnabled()).thenReturn(true); + when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); + when(mDeviceManager.getCachedDevicesCopy()).thenReturn(cachedDevices); + when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); + when(mBluetoothDevice.isConnected()).thenReturn(false); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + + doReturn(new PackageInfo()).when(mPackageManager).getPackageInfo(exclusiveManagerName, 0); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).removePreference(mCachedBluetoothDevice); + verify(mBluetoothDeviceUpdater, never()).addPreference(mCachedBluetoothDevice, + BluetoothDevicePreference.SortType.TYPE_NO_SORT); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_exclusivelyManagedDeviceWithoutPackageInstalled_addDevice() + throws Exception { + final Collection cachedDevices = new ArrayList<>(); + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + cachedDevices.add(mCachedBluetoothDevice); + + when(mBluetoothAdapter.isEnabled()).thenReturn(true); + when(mBluetoothManager.getCachedDeviceManager()).thenReturn(mDeviceManager); + when(mDeviceManager.getCachedDevicesCopy()).thenReturn(cachedDevices); + when(mBluetoothDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDED); + when(mBluetoothDevice.isConnected()).thenReturn(false); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + + doThrow(new PackageManager.NameNotFoundException()).when(mPackageManager).getPackageInfo( + exclusiveManagerName, 0); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice, + BluetoothDevicePreference.SortType.TYPE_NO_SORT); + } } From b68ccb0d79c87ee87a1e1e397d4badc874721778 Mon Sep 17 00:00:00 2001 From: Ze Li Date: Wed, 31 Jan 2024 13:50:16 +0800 Subject: [PATCH 2/6] [Hide DCK devices] Hide DCK devices from settings app (other devices section). Set preferences of DCK devices to be invisible in other devices section. Test: atest: com.android.settings.bluetooth.ConnectedBluetoothDeviceUpdaterTest Bug: 322285078 Change-Id: I13572250f6e1d6b1562a052a0c25e8af60eba9cd --- .../ConnectedBluetoothDeviceUpdater.java | 11 ++ .../ConnectedBluetoothDeviceUpdaterTest.java | 112 +++++++++++++++++- 2 files changed, 122 insertions(+), 1 deletion(-) diff --git a/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdater.java b/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdater.java index 489c0953fdd..012220cc453 100644 --- a/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdater.java +++ b/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdater.java @@ -24,6 +24,8 @@ import android.util.Log; import androidx.preference.Preference; import com.android.settings.connecteddevice.DevicePreferenceCallback; +import com.android.settings.flags.Flags; +import com.android.settingslib.bluetooth.BluetoothUtils; import com.android.settingslib.bluetooth.CachedBluetoothDevice; /** @@ -95,6 +97,15 @@ public class ConnectedBluetoothDeviceUpdater extends BluetoothDeviceUpdater { cachedDevice.getName() + ", isFilterMatched : " + isFilterMatched); } } + if (Flags.enableHideExclusivelyManagedBluetoothDevice()) { + if (BluetoothUtils.isExclusivelyManagedBluetoothDevice(mContext, + cachedDevice.getDevice())) { + if (DBG) { + Log.d(TAG, "isFilterMatched() hide BluetoothDevice with exclusive manager"); + } + return false; + } + } return isFilterMatched; } diff --git a/tests/robotests/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdaterTest.java b/tests/robotests/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdaterTest.java index 00115d7fcea..cd48bf11e75 100644 --- a/tests/robotests/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdaterTest.java +++ b/tests/robotests/src/com/android/settings/bluetooth/ConnectedBluetoothDeviceUpdaterTest.java @@ -20,6 +20,8 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -28,18 +30,26 @@ import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothProfile; import android.content.Context; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; import android.graphics.drawable.Drawable; import android.media.AudioManager; +import android.platform.test.annotations.RequiresFlagsEnabled; +import android.platform.test.flag.junit.CheckFlagsRule; +import android.platform.test.flag.junit.DeviceFlagsValueProvider; import android.util.Pair; import com.android.settings.connecteddevice.DevicePreferenceCallback; import com.android.settings.dashboard.DashboardFragment; +import com.android.settings.flags.Flags; import com.android.settings.testutils.shadow.ShadowAudioManager; import com.android.settings.testutils.shadow.ShadowBluetoothAdapter; import com.android.settings.testutils.shadow.ShadowCachedBluetoothDeviceManager; +import com.android.settingslib.bluetooth.BluetoothUtils; import com.android.settingslib.bluetooth.CachedBluetoothDevice; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -58,6 +68,10 @@ import java.util.Collection; public class ConnectedBluetoothDeviceUpdaterTest { private static final String MAC_ADDRESS = "04:52:C7:0B:D8:3C"; + private static final String FAKE_EXCLUSIVE_MANAGER_NAME = "com.fake.name"; + + @Rule + public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule(); @Mock private DashboardFragment mDashboardFragment; @@ -69,6 +83,8 @@ public class ConnectedBluetoothDeviceUpdaterTest { private BluetoothDevice mBluetoothDevice; @Mock private Drawable mDrawable; + @Mock + private PackageManager mPackageManager; private Context mContext; private ConnectedBluetoothDeviceUpdater mBluetoothDeviceUpdater; @@ -82,7 +98,7 @@ public class ConnectedBluetoothDeviceUpdaterTest { MockitoAnnotations.initMocks(this); Pair pairs = new Pair<>(mDrawable, "fake_device"); - mContext = RuntimeEnvironment.application; + mContext = spy(RuntimeEnvironment.application); mAudioManager = mContext.getSystemService(AudioManager.class); mShadowBluetoothAdapter = Shadow.extract(BluetoothAdapter.getDefaultAdapter()); mShadowBluetoothAdapter.setEnabled(true); @@ -92,6 +108,7 @@ public class ConnectedBluetoothDeviceUpdaterTest { mCachedDevices = new ArrayList<>(); mCachedDevices.add(mCachedBluetoothDevice); + when(mContext.getPackageManager()).thenReturn(mPackageManager); when(mCachedBluetoothDevice.getDevice()).thenReturn(mBluetoothDevice); when(mCachedBluetoothDevice.getAddress()).thenReturn(MAC_ADDRESS); when(mCachedBluetoothDevice.getDrawableWithDescription()).thenReturn(pairs); @@ -320,4 +337,97 @@ public class ConnectedBluetoothDeviceUpdaterTest { assertThat(btPreference.shouldHideSecondTarget()).isTrue(); } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_notExclusiveManagedDevice_addDevice() { + mAudioManager.setMode(AudioManager.MODE_NORMAL); + when(mBluetoothDeviceUpdater + .isDeviceConnected(any(CachedBluetoothDevice.class))).thenReturn(true); + when(mCachedBluetoothDevice.isConnectedHfpDevice()).thenReturn(true); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + null); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_notAllowedExclusiveManagedDevice_addDevice() { + mAudioManager.setMode(AudioManager.MODE_NORMAL); + when(mBluetoothDeviceUpdater + .isDeviceConnected(any(CachedBluetoothDevice.class))).thenReturn(true); + when(mCachedBluetoothDevice.isConnectedHfpDevice()).thenReturn(true); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + FAKE_EXCLUSIVE_MANAGER_NAME.getBytes()); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_existingExclusivelyManagedDeviceWithPackageInstalled_removePreference() + throws Exception { + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + mAudioManager.setMode(AudioManager.MODE_NORMAL); + when(mBluetoothDeviceUpdater + .isDeviceConnected(any(CachedBluetoothDevice.class))).thenReturn(true); + when(mCachedBluetoothDevice.isConnectedHfpDevice()).thenReturn(true); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + doReturn(new PackageInfo()).when(mPackageManager).getPackageInfo(exclusiveManagerName, 0); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).removePreference(mCachedBluetoothDevice); + verify(mBluetoothDeviceUpdater, never()).addPreference(mCachedBluetoothDevice); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_newExclusivelyManagedDeviceWithPackageInstalled_doNotAddPreference() + throws Exception { + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + mAudioManager.setMode(AudioManager.MODE_NORMAL); + when(mBluetoothDeviceUpdater + .isDeviceConnected(any(CachedBluetoothDevice.class))).thenReturn(true); + when(mCachedBluetoothDevice.isConnectedHfpDevice()).thenReturn(true); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + doReturn(new PackageInfo()).when(mPackageManager).getPackageInfo(exclusiveManagerName, 0); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).removePreference(mCachedBluetoothDevice); + verify(mBluetoothDeviceUpdater, never()).addPreference(mCachedBluetoothDevice); + } + + @Test + @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HIDE_EXCLUSIVELY_MANAGED_BLUETOOTH_DEVICE) + public void update_exclusivelyManagedDeviceWithoutPackageInstalled_addDevice() + throws Exception { + final String exclusiveManagerName = + BluetoothUtils.getExclusiveManagers().stream().findAny().orElse( + FAKE_EXCLUSIVE_MANAGER_NAME); + mAudioManager.setMode(AudioManager.MODE_NORMAL); + when(mBluetoothDeviceUpdater + .isDeviceConnected(any(CachedBluetoothDevice.class))).thenReturn(true); + when(mCachedBluetoothDevice.isConnectedHfpDevice()).thenReturn(true); + when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_EXCLUSIVE_MANAGER)).thenReturn( + exclusiveManagerName.getBytes()); + doThrow(new PackageManager.NameNotFoundException()).when(mPackageManager).getPackageInfo( + exclusiveManagerName, 0); + + mBluetoothDeviceUpdater.update(mCachedBluetoothDevice); + + verify(mBluetoothDeviceUpdater).addPreference(mCachedBluetoothDevice); + } } From 213c998557986698c54f4790bf735c2195473a6c Mon Sep 17 00:00:00 2001 From: Chaohui Wang Date: Fri, 2 Feb 2024 21:58:40 +0800 Subject: [PATCH 3/6] Use collectAsCallbackWithLifecycle Instead of observeAsCallback, since isAllowed is a flow now. Bug: 322916468 Test: manual - on Toggle Permission page and switch between apps Test: unit test Change-Id: Ic33a7d6cd7c71c7cf6cd4a6e353505fa12cf0046 --- .../spa/app/specialaccess/InstallUnknownApps.kt | 4 ++-- .../spa/app/specialaccess/PictureInPicture.kt | 4 ++-- .../settings/spa/app/WifiControlAppListModelTest.kt | 3 +-- .../spa/app/specialaccess/MediaRoutingControlTest.kt | 11 ++++------- 4 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/com/android/settings/spa/app/specialaccess/InstallUnknownApps.kt b/src/com/android/settings/spa/app/specialaccess/InstallUnknownApps.kt index dc983307197..3e9058f25ff 100644 --- a/src/com/android/settings/spa/app/specialaccess/InstallUnknownApps.kt +++ b/src/com/android/settings/spa/app/specialaccess/InstallUnknownApps.kt @@ -26,7 +26,7 @@ import android.content.pm.ApplicationInfo import android.os.UserManager import androidx.compose.runtime.Composable import com.android.settings.R -import com.android.settingslib.spa.livedata.observeAsCallback +import com.android.settingslib.spa.lifecycle.collectAsCallbackWithLifecycle import com.android.settingslib.spaprivileged.model.app.AppOpsController import com.android.settingslib.spaprivileged.model.app.AppRecord import com.android.settingslib.spaprivileged.model.app.userId @@ -81,7 +81,7 @@ class InstallUnknownAppsListModel(private val context: Context) : @Composable override fun isAllowed(record: InstallUnknownAppsRecord) = - record.appOpsController.isAllowed.observeAsCallback() + record.appOpsController.isAllowed.collectAsCallbackWithLifecycle() override fun isChangeable(record: InstallUnknownAppsRecord) = isChangeable(record, getPotentialPackageNames(record.app.userId)) diff --git a/src/com/android/settings/spa/app/specialaccess/PictureInPicture.kt b/src/com/android/settings/spa/app/specialaccess/PictureInPicture.kt index fe8f1031268..7885b869b83 100644 --- a/src/com/android/settings/spa/app/specialaccess/PictureInPicture.kt +++ b/src/com/android/settings/spa/app/specialaccess/PictureInPicture.kt @@ -27,7 +27,7 @@ import android.content.pm.PackageManager.PackageInfoFlags import android.util.Log import androidx.compose.runtime.Composable import com.android.settings.R -import com.android.settingslib.spa.livedata.observeAsCallback +import com.android.settingslib.spa.lifecycle.collectAsCallbackWithLifecycle import com.android.settingslib.spaprivileged.model.app.AppOpsController import com.android.settingslib.spaprivileged.model.app.AppRecord import com.android.settingslib.spaprivileged.model.app.installed @@ -92,7 +92,7 @@ class PictureInPictureListModel(private val context: Context) : @Composable override fun isAllowed(record: PictureInPictureRecord) = - record.appOpsController.isAllowed.observeAsCallback() + record.appOpsController.isAllowed.collectAsCallbackWithLifecycle() override fun isChangeable(record: PictureInPictureRecord) = record.isSupport diff --git a/tests/spa_unit/src/com/android/settings/spa/app/WifiControlAppListModelTest.kt b/tests/spa_unit/src/com/android/settings/spa/app/WifiControlAppListModelTest.kt index 74aa86175eb..537764afe7c 100644 --- a/tests/spa_unit/src/com/android/settings/spa/app/WifiControlAppListModelTest.kt +++ b/tests/spa_unit/src/com/android/settings/spa/app/WifiControlAppListModelTest.kt @@ -21,7 +21,6 @@ import android.app.AppOpsManager import android.content.Context import android.content.pm.ApplicationInfo import androidx.compose.ui.test.junit4.createComposeRule -import androidx.lifecycle.MutableLiveData import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 import com.android.settingslib.spa.testutils.firstWithTimeoutOrNull @@ -270,7 +269,7 @@ class WifiControlAppListModelTest { private class FakeAppOpsController(private val fakeMode: Int) : IAppOpsController { var setAllowedCalledWith: Boolean? = null - override val mode = MutableLiveData(fakeMode) + override val mode = flowOf(fakeMode) override fun setAllowed(allowed: Boolean) { setAllowedCalledWith = allowed diff --git a/tests/spa_unit/src/com/android/settings/spa/app/specialaccess/MediaRoutingControlTest.kt b/tests/spa_unit/src/com/android/settings/spa/app/specialaccess/MediaRoutingControlTest.kt index 2f4740e65d4..990ec5ce417 100644 --- a/tests/spa_unit/src/com/android/settings/spa/app/specialaccess/MediaRoutingControlTest.kt +++ b/tests/spa_unit/src/com/android/settings/spa/app/specialaccess/MediaRoutingControlTest.kt @@ -24,7 +24,6 @@ import android.companion.AssociationRequest import android.content.Context import android.content.pm.ApplicationInfo import android.platform.test.flag.junit.SetFlagsRule -import androidx.lifecycle.MutableLiveData import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 import com.android.media.flags.Flags @@ -33,6 +32,7 @@ import com.android.settings.testutils.FakeFeatureFactory import com.android.settingslib.spaprivileged.model.app.IAppOpsController import com.android.settingslib.spaprivileged.template.app.AppOpPermissionRecord import com.google.common.truth.Truth.assertThat +import kotlinx.coroutines.flow.MutableStateFlow import org.junit.Before import org.junit.Rule import org.junit.Test @@ -223,16 +223,13 @@ class MediaRoutingControlTest { private class FakeAppOpsController(fakeMode: Int) : IAppOpsController { - override val mode = MutableLiveData(fakeMode) + override val mode = MutableStateFlow(fakeMode) override fun setAllowed(allowed: Boolean) { - if (allowed) - mode.postValue(AppOpsManager.MODE_ALLOWED) - else - mode.postValue(AppOpsManager.MODE_ERRORED) + mode.value = if (allowed) AppOpsManager.MODE_ALLOWED else AppOpsManager.MODE_ERRORED } - override fun getMode(): Int = mode.value!! + override fun getMode(): Int = mode.value } companion object { From 4af6ae88a4298a337e441fccf5bf97a7dd3c0760 Mon Sep 17 00:00:00 2001 From: Pajace Chen Date: Sat, 3 Feb 2024 15:43:20 +0800 Subject: [PATCH 4/6] Fix failed test case for BatteryTip in Settings - Replace the deprecated mocktio rule with MockitoJUnit.rule - Fix the failed test cases - Update the testing convention Bug: 323627875 Test: atest SettingsRoboTests:com.android.settings.fuelgauge.batterytip Change-Id: I25a39c8e7ad07482352c1e2152d8e16555429ab1 --- .../BatteryTipPreferenceControllerTest.java | 32 +++++-------- .../tips/BatteryDefenderTipTest.java | 48 +++++++------------ .../batterytip/tips/BatteryTipTest.java | 22 ++++----- .../tips/IncompatibleChargerTipTest.java | 19 ++++---- 4 files changed, 49 insertions(+), 72 deletions(-) diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPreferenceControllerTest.java index eeedccc1faa..c05d9ed3140 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPreferenceControllerTest.java @@ -20,30 +20,29 @@ import static com.android.settings.fuelgauge.batterytip.tips.BatteryTip.TipType. import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.Context; import android.os.Bundle; -import android.text.format.DateUtils; import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.SettingsActivity; import com.android.settings.core.BasePreferenceController; import com.android.settings.core.InstrumentedPreferenceFragment; import com.android.settings.fuelgauge.batterytip.tips.BatteryTip; -import com.android.settings.testutils.FakeFeatureFactory; import com.android.settings.widget.CardPreference; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import java.util.ArrayList; import java.util.List; @@ -53,8 +52,8 @@ public class BatteryTipPreferenceControllerTest { private static final String KEY_PREF = "battery_tip"; private static final String KEY_TIP = "key_battery_tip"; - private static final long AVERAGE_TIME_MS = DateUtils.HOUR_IN_MILLIS; + @Rule public MockitoRule mMockitoRule = MockitoJUnit.rule(); @Mock private BatteryTipPreferenceController.BatteryTipListener mBatteryTipListener; @Mock private PreferenceScreen mPreferenceScreen; @Mock private BatteryTip mBatteryTip; @@ -64,21 +63,16 @@ public class BatteryTipPreferenceControllerTest { private Context mContext; private CardPreference mCardPreference; private BatteryTipPreferenceController mBatteryTipPreferenceController; - private List mOldBatteryTips; private List mNewBatteryTips; - private FakeFeatureFactory mFeatureFactory; @Before public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = RuntimeEnvironment.application; + mContext = ApplicationProvider.getApplicationContext(); - mCardPreference = spy(new CardPreference(mContext)); + mCardPreference = new CardPreference(mContext); when(mPreferenceScreen.getContext()).thenReturn(mContext); doReturn(mCardPreference).when(mPreferenceScreen).findPreference(KEY_PREF); - mFeatureFactory = FakeFeatureFactory.setupForTest(); - mOldBatteryTips = new ArrayList<>(); mNewBatteryTips = new ArrayList<>(); mBatteryTipPreferenceController = buildBatteryTipPreferenceController(); @@ -87,32 +81,32 @@ public class BatteryTipPreferenceControllerTest { } @Test - public void testDisplayPreference_isInvisible() { + public void displayPreference_isInvisible() { mBatteryTipPreferenceController.displayPreference(mPreferenceScreen); assertThat(mCardPreference.isVisible()).isFalse(); } @Test - public void testUpdateBatteryTips_tipsStateInvisible_isInvisible() { + public void updateBatteryTips_tipsStateInvisible_isInvisible() { mBatteryTipPreferenceController.updateBatteryTips(mNewBatteryTips); assertThat(mCardPreference.isVisible()).isFalse(); } @Test - public void testGetCurrentBatteryTip_noTips_isNull() { + public void getCurrentBatteryTip_noTips_isNull() { assertThat(mBatteryTipPreferenceController.getCurrentBatteryTip()).isNull(); } @Test - public void testGetCurrentBatteryTip_tipsInvisible_isNull() { + public void getCurrentBatteryTip_tipsInvisible_isNull() { mBatteryTipPreferenceController.updateBatteryTips(mNewBatteryTips); assertThat(mBatteryTipPreferenceController.getCurrentBatteryTip()).isNull(); } @Test - public void testRestoreFromNull_shouldNotCrash() { + public void restoreFromNull_shouldNotCrash() { final Bundle bundle = new Bundle(); // Battery tip list is null at this time mBatteryTipPreferenceController.saveInstanceState(bundle); @@ -124,7 +118,7 @@ public class BatteryTipPreferenceControllerTest { } @Test - public void testHandlePreferenceTreeClick_noDialog_invokeCallback() { + public void handlePreferenceTreeClick_noDialog_invokeCallback() { when(mBatteryTip.getType()).thenReturn(SMART_BATTERY_MANAGER); List batteryTips = new ArrayList<>(); batteryTips.add(mBatteryTip); diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryDefenderTipTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryDefenderTipTest.java index 3f89f9b1d7d..4efd8509fab 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryDefenderTipTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryDefenderTipTest.java @@ -17,8 +17,6 @@ package com.android.settings.fuelgauge.batterytip.tips; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -27,6 +25,7 @@ import android.content.Context; import android.util.Log; import androidx.preference.Preference; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; import com.android.settings.testutils.FakeFeatureFactory; @@ -34,12 +33,13 @@ import com.android.settings.widget.CardPreference; import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import org.robolectric.shadows.ShadowLog; @RunWith(RobolectricTestRunner.class) @@ -49,23 +49,22 @@ public class BatteryDefenderTipTest { private FakeFeatureFactory mFeatureFactory; private BatteryDefenderTip mBatteryDefenderTip; private MetricsFeatureProvider mMetricsFeatureProvider; + private CardPreference mCardPreference; + @Rule public MockitoRule mMockitoRule = MockitoJUnit.rule(); @Mock private BatteryTip mBatteryTip; @Mock private Preference mPreference; - @Mock private CardPreference mCardPreference; @Before public void setUp() { - MockitoAnnotations.initMocks(this); - + mContext = ApplicationProvider.getApplicationContext(); mFeatureFactory = FakeFeatureFactory.setupForTest(); mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider; - mContext = RuntimeEnvironment.application; mBatteryDefenderTip = - new BatteryDefenderTip(BatteryTip.StateType.NEW, false /* isPluggedIn */); + new BatteryDefenderTip(BatteryTip.StateType.NEW, /* isPluggedIn= */ false); + mCardPreference = new CardPreference(mContext); when(mPreference.getContext()).thenReturn(mContext); - when(mCardPreference.getContext()).thenReturn(mContext); } @Test @@ -87,7 +86,7 @@ public class BatteryDefenderTipTest { } @Test - public void testLog_logMetric() { + public void log_logMetric() { mBatteryDefenderTip.updateState(mBatteryTip); mBatteryDefenderTip.log(mContext, mMetricsFeatureProvider); @@ -108,7 +107,7 @@ public class BatteryDefenderTipTest { mBatteryDefenderTip.updatePreference(mCardPreference); - verify(mCardPreference).setPrimaryButtonText(expectedText); + assertThat(mCardPreference.getPrimaryButtonText()).isEqualTo(expectedText); } @Test @@ -117,46 +116,31 @@ public class BatteryDefenderTipTest { mBatteryDefenderTip.updatePreference(mCardPreference); - verify(mCardPreference).setSecondaryButtonText(expected); + assertThat(mCardPreference.getSecondaryButtonText()).isEqualTo(expected); } @Test public void updatePreference_shouldSetPrimaryButtonVisible() { mBatteryDefenderTip.updatePreference(mCardPreference); - verify(mCardPreference).setPrimaryButtonVisibility(true); + assertThat(mCardPreference.getPrimaryButtonVisibility()).isTrue(); } @Test public void updatePreference_whenCharging_setPrimaryButtonVisibleToBeTrue() { mBatteryDefenderTip = - new BatteryDefenderTip(BatteryTip.StateType.NEW, true /* isPluggedIn */); + new BatteryDefenderTip(BatteryTip.StateType.NEW, /* isPluggedIn= */ true); mBatteryDefenderTip.updatePreference(mCardPreference); - verify(mCardPreference).setPrimaryButtonVisibility(true); + assertThat(mCardPreference.getPrimaryButtonVisibility()).isTrue(); } @Test public void updatePreference_whenNotCharging_setSecondaryButtonVisibleToBeFalse() { mBatteryDefenderTip.updatePreference(mCardPreference); - verify(mCardPreference).setSecondaryButtonVisibility(false); - } - - @Test - public void updatePreference_whenGetChargingStatusFailed_setSecondaryButtonVisibleToBeFalse() { - fakeGetChargingStatusFailed(); - - mBatteryDefenderTip.updatePreference(mCardPreference); - - verify(mCardPreference).setSecondaryButtonVisibility(false); - } - - private void fakeGetChargingStatusFailed() { - Context mockContext = mock(Context.class); - when(mockContext.getString(anyInt())).thenReturn("fake_string"); - when(mCardPreference.getContext()).thenReturn(mockContext); + assertThat(mCardPreference.getSecondaryButtonVisibility()).isFalse(); } private String getLastErrorLog() { diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryTipTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryTipTest.java index ea72ff60898..097f48406d3 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryTipTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/BatteryTipTest.java @@ -20,11 +20,10 @@ import static com.google.common.truth.Truth.assertThat; import android.content.Context; import android.os.Parcel; import android.os.Parcelable; -import android.view.View; import androidx.annotation.DrawableRes; import androidx.preference.Preference; -import androidx.preference.PreferenceViewHolder; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; import com.android.settings.widget.CardPreference; @@ -32,10 +31,12 @@ import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import com.android.settingslib.testutils.DrawableTestHelper; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import java.util.ArrayList; import java.util.List; @@ -47,13 +48,15 @@ public class BatteryTipTest { private static final String SUMMARY = "summary"; @DrawableRes private static final int ICON_ID = R.drawable.ic_fingerprint; + @Rule public MockitoRule mMockitoRule = MockitoJUnit.rule(); + private Context mContext; private TestBatteryTip mBatteryTip; @Before public void setUp() { - mContext = RuntimeEnvironment.application; mBatteryTip = new TestBatteryTip(); + mContext = ApplicationProvider.getApplicationContext(); } @Test @@ -84,19 +87,14 @@ public class BatteryTipTest { @Test public void updatePreference_resetLayoutState() { - mContext.setTheme(R.style.Theme_Settings); - PreferenceViewHolder holder = - PreferenceViewHolder.createInstanceForTests( - View.inflate( - mContext, R.layout.card_preference_layout, /* parent= */ null)); CardPreference cardPreference = new CardPreference(mContext); - cardPreference.onBindViewHolder(holder); cardPreference.setPrimaryButtonVisibility(true); + cardPreference.setSecondaryButtonVisibility(true); mBatteryTip.updatePreference(cardPreference); - View view = holder.findViewById(R.id.card_preference_buttons); - assertThat(view.getVisibility()).isEqualTo(View.GONE); + assertThat(cardPreference.getPrimaryButtonVisibility()).isFalse(); + assertThat(cardPreference.getSecondaryButtonVisibility()).isFalse(); } @Test diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/IncompatibleChargerTipTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/IncompatibleChargerTipTest.java index c66cf374355..7a23332baf2 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/IncompatibleChargerTipTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/tips/IncompatibleChargerTipTest.java @@ -25,6 +25,7 @@ import android.content.Context; import android.util.Log; import androidx.preference.Preference; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; import com.android.settings.testutils.FakeFeatureFactory; @@ -32,12 +33,13 @@ import com.android.settings.widget.CardPreference; import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import org.robolectric.shadows.ShadowLog; @RunWith(RobolectricTestRunner.class) @@ -47,22 +49,21 @@ public final class IncompatibleChargerTipTest { private FakeFeatureFactory mFeatureFactory; private IncompatibleChargerTip mIncompatibleChargerTip; private MetricsFeatureProvider mMetricsFeatureProvider; + private CardPreference mCardPreference; + @Rule public MockitoRule mMockitoRule = MockitoJUnit.rule(); @Mock private BatteryTip mBatteryTip; @Mock private Preference mPreference; - @Mock private CardPreference mCardPreference; @Before public void setUp() { - MockitoAnnotations.initMocks(this); - mFeatureFactory = FakeFeatureFactory.setupForTest(); mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider; - mContext = RuntimeEnvironment.application; + mContext = ApplicationProvider.getApplicationContext(); mIncompatibleChargerTip = new IncompatibleChargerTip(BatteryTip.StateType.NEW); + mCardPreference = new CardPreference(mContext); when(mPreference.getContext()).thenReturn(mContext); - when(mCardPreference.getContext()).thenReturn(mContext); } @Test @@ -107,13 +108,13 @@ public final class IncompatibleChargerTipTest { mIncompatibleChargerTip.updatePreference(mCardPreference); - verify(mCardPreference).setPrimaryButtonText(expected); + assertThat(mCardPreference.getPrimaryButtonText()).isEqualTo(expected); } @Test public void updatePreference_shouldSetSecondaryButtonVisible() { mIncompatibleChargerTip.updatePreference(mCardPreference); - verify(mCardPreference).setPrimaryButtonVisibility(true); + assertThat(mCardPreference.getPrimaryButtonVisibility()).isTrue(); } private String getLastErrorLog() { From 4e0315d2a3ccb4ed7b46bf9efa224008959b4a1b Mon Sep 17 00:00:00 2001 From: Yiyi Shen Date: Sat, 3 Feb 2024 21:53:16 +0800 Subject: [PATCH 5/6] Fix CallsAndAlarmsPreferenceControllerTest Test: atest Fix: 323634491 Change-Id: I627a3b6926c86f5e90dcfb27ed794ffb09aa4cfa --- .../audiosharing/CallsAndAlarmsPreferenceControllerTest.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/CallsAndAlarmsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/CallsAndAlarmsPreferenceControllerTest.java index aa10517ffb7..4cdd36478f2 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/CallsAndAlarmsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/CallsAndAlarmsPreferenceControllerTest.java @@ -171,6 +171,7 @@ public class CallsAndAlarmsPreferenceControllerTest { mShadowBluetoothAdapter.setEnabled(false); mController.displayPreference(mScreen); mController.updateVisibility(); + shadowOf(Looper.getMainLooper()).idle(); assertThat(mPreference.isVisible()).isFalse(); } @@ -180,6 +181,7 @@ public class CallsAndAlarmsPreferenceControllerTest { mShadowBluetoothAdapter.setEnabled(false); mController.displayPreference(mScreen); mController.updateVisibility(); + shadowOf(Looper.getMainLooper()).idle(); assertThat(mPreference.isVisible()).isFalse(); } @@ -188,6 +190,7 @@ public class CallsAndAlarmsPreferenceControllerTest { when(mBroadcast.isEnabled(any())).thenReturn(false); mController.displayPreference(mScreen); mController.updateVisibility(); + shadowOf(Looper.getMainLooper()).idle(); assertThat(mPreference.isVisible()).isFalse(); } From 7a792e0b8f68bc4aeb939af703790fd76b51ccbd Mon Sep 17 00:00:00 2001 From: Lifu Tang Date: Fri, 2 Feb 2024 02:03:59 +0000 Subject: [PATCH 6/6] Restrict WifiScanModeActivity when user restriction applies Bug: 299633613 Change-Id: If8cfb7047c0131da451a7af0d2b5108080876b85 --- .../settings/wifi/WifiScanModeActivity.java | 54 +++++++++++-------- 1 file changed, 33 insertions(+), 21 deletions(-) diff --git a/src/com/android/settings/wifi/WifiScanModeActivity.java b/src/com/android/settings/wifi/WifiScanModeActivity.java index c10ee27fddb..446891a3c15 100644 --- a/src/com/android/settings/wifi/WifiScanModeActivity.java +++ b/src/com/android/settings/wifi/WifiScanModeActivity.java @@ -39,26 +39,24 @@ import com.android.settings.Utils; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; import com.android.settingslib.wifi.WifiPermissionChecker; -/** - * This activity requests users permission to allow scanning even when Wi-Fi is turned off - */ +/** This activity requests users permission to allow scanning even when Wi-Fi is turned off */ public class WifiScanModeActivity extends FragmentActivity { private static final String TAG = "WifiScanModeActivity"; private DialogFragment mDialog; - @VisibleForTesting - String mApp; - @VisibleForTesting - WifiPermissionChecker mWifiPermissionChecker; + @VisibleForTesting String mApp; + @VisibleForTesting WifiPermissionChecker mWifiPermissionChecker; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - getWindow().addSystemFlags( - WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); + getWindow() + .addSystemFlags( + WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); Intent intent = getIntent(); if (savedInstanceState == null) { - if (intent != null && WifiManager.ACTION_REQUEST_SCAN_ALWAYS_AVAILABLE - .equals(intent.getAction())) { + if (intent != null + && WifiManager.ACTION_REQUEST_SCAN_ALWAYS_AVAILABLE.equals( + intent.getAction())) { refreshAppLabel(); } else { finish(); @@ -92,6 +90,12 @@ public class WifiScanModeActivity extends FragmentActivity { return; } + if (!isWifiScanModeConfigAllowed(getApplicationContext())) { + Log.e(TAG, "This user is not allowed to configure Wi-Fi Scan Mode!"); + finish(); + return; + } + if (mDialog == null) { mDialog = AlertDialogFragment.newInstance(mApp); mDialog.show(getSupportFragmentManager(), "dialog"); @@ -140,6 +144,7 @@ public class WifiScanModeActivity extends FragmentActivity { } private final String mApp; + public AlertDialogFragment(String app) { super(); mApp = app; @@ -158,25 +163,27 @@ public class WifiScanModeActivity extends FragmentActivity { @Override public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) - .setMessage(TextUtils.isEmpty(mApp) ? - getString(R.string.wifi_scan_always_turn_on_message_unknown) : - getString(R.string.wifi_scan_always_turnon_message, mApp)) - .setPositiveButton(R.string.wifi_scan_always_confirm_allow, + .setMessage( + TextUtils.isEmpty(mApp) + ? getString(R.string.wifi_scan_always_turn_on_message_unknown) + : getString(R.string.wifi_scan_always_turnon_message, mApp)) + .setPositiveButton( + R.string.wifi_scan_always_confirm_allow, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int whichButton) { ((WifiScanModeActivity) getActivity()).doPositiveClick(); } - } - ) - .setNegativeButton(R.string.wifi_scan_always_confirm_deny, + }) + .setNegativeButton( + R.string.wifi_scan_always_confirm_deny, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int whichButton) { ((WifiScanModeActivity) getActivity()).doNegativeClick(); } - } - ) + }) .create(); } + @Override public void onCancel(DialogInterface dialog) { ((WifiScanModeActivity) getActivity()).doNegativeClick(); @@ -184,9 +191,14 @@ public class WifiScanModeActivity extends FragmentActivity { } private static boolean isGuestUser(Context context) { - if (context == null) return false; final UserManager userManager = context.getSystemService(UserManager.class); if (userManager == null) return false; return userManager.isGuestUser(); } + + private static boolean isWifiScanModeConfigAllowed(Context context) { + final UserManager userManager = context.getSystemService(UserManager.class); + if (userManager == null) return true; + return !userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_LOCATION); + } }