From e1b4b7fc7d0e8dacef4ab31e4a62586d44462204 Mon Sep 17 00:00:00 2001 From: SongFerngWang Date: Mon, 17 Jul 2023 15:23:35 +0800 Subject: [PATCH 1/3] Avoid the exception when UI shows the fragment Bug: 290145058 Test: build pass. Change-Id: Ic8d084cc98c3d0094d816e43fed57fb10446462d --- .../android/settings/sim/SimDialogActivity.java | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/com/android/settings/sim/SimDialogActivity.java b/src/com/android/settings/sim/SimDialogActivity.java index 7d399387191..e7b01857ded 100644 --- a/src/com/android/settings/sim/SimDialogActivity.java +++ b/src/com/android/settings/sim/SimDialogActivity.java @@ -280,8 +280,20 @@ public class SimDialogActivity extends FragmentActivity { public void showEnableAutoDataSwitchDialog() { final FragmentManager fragmentManager = getSupportFragmentManager(); SimDialogFragment fragment = createFragment(ENABLE_AUTO_DATA_SWITCH); - fragment.show(fragmentManager, Integer.toString(ENABLE_AUTO_DATA_SWITCH)); + if (fragmentManager.isStateSaved()) { + Log.w(TAG, "Failed to show EnableAutoDataSwitchDialog. The fragmentManager " + + "is StateSaved."); + forceClose(); + return; + } + try { + fragment.show(fragmentManager, Integer.toString(ENABLE_AUTO_DATA_SWITCH)); + } catch (Exception e) { + Log.e(TAG, "Failed to show EnableAutoDataSwitchDialog.", e); + forceClose(); + return; + } if (getResources().getBoolean( R.bool.config_auto_data_switch_enables_cross_sim_calling)) { // If auto data switch is already enabled on the non-DDS, the dialog for enabling it From 986fe4ebc17b9c08d5cd7431f4f1581f762aa6bd Mon Sep 17 00:00:00 2001 From: Vania Januar Date: Mon, 15 May 2023 11:20:32 +0100 Subject: [PATCH 2/3] USB firmware update for stylus in Stylus USI Device Details Bug: 288850921 Test: StylusUsbFirmwareControllerTest, UsbStylusBroadcastReceiverTest Change-Id: Ic7cb35799ff00f9998ca569eb4ae091f8010780a Merged-In: Ic7cb35799ff00f9998ca569eb4ae091f8010780a --- res/xml/stylus_usi_details_fragment.xml | 3 + .../stylus/StylusFeatureProvider.java | 47 +++++ .../stylus/StylusFeatureProviderImpl.java | 37 ++++ .../stylus/StylusUsbFirmwareController.java | 142 +++++++++++++++ .../stylus/StylusUsiDetailsFragment.java | 1 - .../stylus/UsbStylusBroadcastReceiver.java | 75 ++++++++ .../settings/overlay/FeatureFactory.java | 6 + .../settings/overlay/FeatureFactoryImpl.java | 11 ++ .../StylusUsbFirmwareControllerTest.java | 163 ++++++++++++++++++ .../UsbStylusBroadcastReceiverTest.java | 98 +++++++++++ .../testutils/FakeFeatureFactory.java | 8 + .../settings/testutils/FakeFeatureFactory.kt | 5 + .../testutils/FakeFeatureFactory.java | 8 + 13 files changed, 603 insertions(+), 1 deletion(-) create mode 100644 src/com/android/settings/connecteddevice/stylus/StylusFeatureProvider.java create mode 100644 src/com/android/settings/connecteddevice/stylus/StylusFeatureProviderImpl.java create mode 100644 src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareController.java create mode 100644 src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiver.java create mode 100644 tests/robotests/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareControllerTest.java create mode 100644 tests/robotests/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiverTest.java diff --git a/res/xml/stylus_usi_details_fragment.xml b/res/xml/stylus_usi_details_fragment.xml index 8a1d036c80e..639c2846792 100644 --- a/res/xml/stylus_usi_details_fragment.xml +++ b/res/xml/stylus_usi_details_fragment.xml @@ -30,4 +30,7 @@ + \ No newline at end of file diff --git a/src/com/android/settings/connecteddevice/stylus/StylusFeatureProvider.java b/src/com/android/settings/connecteddevice/stylus/StylusFeatureProvider.java new file mode 100644 index 00000000000..43337c85127 --- /dev/null +++ b/src/com/android/settings/connecteddevice/stylus/StylusFeatureProvider.java @@ -0,0 +1,47 @@ +/* + * 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.settings.connecteddevice.stylus; + +import android.content.Context; +import android.hardware.usb.UsbDevice; + +import androidx.preference.Preference; + +import java.util.List; + +import javax.annotation.Nullable; + +/** FeatureProvider for USB settings */ +public interface StylusFeatureProvider { + + /** + * Returns whether the current attached USB device allows firmware updates. + * + * @param usbDevice The USB device to check + */ + boolean isUsbFirmwareUpdateEnabled(UsbDevice usbDevice); + + /** + * Returns a list of preferences for the connected USB device if exists. If not, returns + * null. If an update is not available but firmware update feature is enabled for the device, + * the list will contain only the preference showing the current firmware version. + * + * @param context The context + */ + @Nullable + List getUsbFirmwareUpdatePreferences(Context context); +} diff --git a/src/com/android/settings/connecteddevice/stylus/StylusFeatureProviderImpl.java b/src/com/android/settings/connecteddevice/stylus/StylusFeatureProviderImpl.java new file mode 100644 index 00000000000..dba569b7959 --- /dev/null +++ b/src/com/android/settings/connecteddevice/stylus/StylusFeatureProviderImpl.java @@ -0,0 +1,37 @@ +/* + * 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.settings.connecteddevice.stylus; + +import android.content.Context; +import android.hardware.usb.UsbDevice; + +import androidx.preference.Preference; + +import java.util.List; + +/** Default implementation for StylusFeatureProvider */ +public class StylusFeatureProviderImpl implements StylusFeatureProvider { + @Override + public boolean isUsbFirmwareUpdateEnabled(UsbDevice usbDevice) { + return false; + } + + @Override + public List getUsbFirmwareUpdatePreferences(Context context) { + return null; + } +} diff --git a/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareController.java b/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareController.java new file mode 100644 index 00000000000..4a4dfa271a8 --- /dev/null +++ b/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareController.java @@ -0,0 +1,142 @@ +/* + * 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.settings.connecteddevice.stylus; + +import android.content.Context; +import android.hardware.usb.UsbDevice; +import android.hardware.usb.UsbManager; + +import androidx.annotation.Nullable; +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; + +import com.android.settings.core.BasePreferenceController; +import com.android.settings.overlay.FeatureFactory; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; + +import java.util.ArrayList; +import java.util.List; + +/** Preference controller for stylus firmware updates via USB */ +public class StylusUsbFirmwareController extends BasePreferenceController + implements LifecycleObserver, OnStart, OnStop { + private static final String TAG = StylusUsbFirmwareController.class.getSimpleName(); + @Nullable + private UsbDevice mStylusUsbDevice; + private final UsbStylusBroadcastReceiver mUsbStylusBroadcastReceiver; + + private PreferenceScreen mPreferenceScreen; + private PreferenceCategory mPreference; + + @VisibleForTesting + UsbStylusBroadcastReceiver.UsbStylusConnectionListener mUsbConnectionListener = + (stylusUsbDevice, attached) -> { + refresh(); + }; + + public StylusUsbFirmwareController(Context context, String key) { + super(context, key); + mUsbStylusBroadcastReceiver = new UsbStylusBroadcastReceiver(context, + mUsbConnectionListener); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + mPreferenceScreen = screen; + refresh(); + super.displayPreference(screen); + } + + @Override + public int getAvailabilityStatus() { + // always available, preferences will be added or + // removed according to the connected usb device + return AVAILABLE; + } + + private void refresh() { + if (mPreferenceScreen == null) return; + + UsbDevice device = getStylusUsbDevice(); + if (device == mStylusUsbDevice) { + return; + } + mStylusUsbDevice = device; + mPreference = mPreferenceScreen.findPreference(getPreferenceKey()); + if (mPreference != null) { + mPreferenceScreen.removePreference(mPreference); + } + if (hasUsbStylusFirmwareUpdateFeature(mStylusUsbDevice)) { + StylusFeatureProvider featureProvider = FeatureFactory.getFactory( + mContext).getStylusFeatureProvider(); + List preferences = + featureProvider.getUsbFirmwareUpdatePreferences(mContext); + + if (preferences != null) { + mPreference = new PreferenceCategory(mContext); + mPreference.setKey(getPreferenceKey()); + mPreferenceScreen.addPreference(mPreference); + + for (Preference preference : preferences) { + mPreference.addPreference(preference); + } + } + } + } + + @Override + public void onStart() { + mUsbStylusBroadcastReceiver.register(); + } + + @Override + public void onStop() { + mUsbStylusBroadcastReceiver.unregister(); + } + + private UsbDevice getStylusUsbDevice() { + UsbManager usbManager = mContext.getSystemService(UsbManager.class); + + if (usbManager == null) { + return null; + } + + List devices = new ArrayList<>(usbManager.getDeviceList().values()); + if (devices.isEmpty()) { + return null; + } + + UsbDevice usbDevice = devices.get(0); + if (hasUsbStylusFirmwareUpdateFeature(usbDevice)) { + return usbDevice; + } + return null; + } + + static boolean hasUsbStylusFirmwareUpdateFeature(UsbDevice usbDevice) { + if (usbDevice == null) return false; + + StylusFeatureProvider featureProvider = FeatureFactory.getFactory( + FeatureFactory.getAppContext()).getStylusFeatureProvider(); + + return featureProvider.isUsbFirmwareUpdateEnabled(usbDevice); + } +} diff --git a/src/com/android/settings/connecteddevice/stylus/StylusUsiDetailsFragment.java b/src/com/android/settings/connecteddevice/stylus/StylusUsiDetailsFragment.java index 5e68a537e5d..ea9781e3ce7 100644 --- a/src/com/android/settings/connecteddevice/stylus/StylusUsiDetailsFragment.java +++ b/src/com/android/settings/connecteddevice/stylus/StylusUsiDetailsFragment.java @@ -54,7 +54,6 @@ public class StylusUsiDetailsFragment extends DashboardFragment { } } - @Override public int getMetricsCategory() { return SettingsEnums.USI_DEVICE_DETAILS; diff --git a/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiver.java b/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiver.java new file mode 100644 index 00000000000..01662500443 --- /dev/null +++ b/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiver.java @@ -0,0 +1,75 @@ +/* + * 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.settings.connecteddevice.stylus; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.hardware.usb.UsbDevice; +import android.hardware.usb.UsbManager; + +/** Broadcast receiver for styluses connected via USB */ +public class UsbStylusBroadcastReceiver extends BroadcastReceiver { + private Context mContext; + private UsbStylusConnectionListener mUsbConnectionListener; + private boolean mListeningToUsbEvents; + + public UsbStylusBroadcastReceiver(Context context, + UsbStylusConnectionListener usbConnectionListener) { + mContext = context; + mUsbConnectionListener = usbConnectionListener; + } + + /** Registers the receiver. */ + public void register() { + if (!mListeningToUsbEvents) { + final IntentFilter intentFilter = new IntentFilter(); + intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED); + intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED); + final Intent intent = mContext.registerReceiver(this, intentFilter); + if (intent != null) { + onReceive(mContext, intent); + } + mListeningToUsbEvents = true; + } + } + + /** Unregisters the receiver. */ + public void unregister() { + if (mListeningToUsbEvents) { + mContext.unregisterReceiver(this); + mListeningToUsbEvents = false; + } + } + + @Override + public void onReceive(Context context, Intent intent) { + UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice.class); + if (StylusUsbFirmwareController.hasUsbStylusFirmwareUpdateFeature(usbDevice)) { + mUsbConnectionListener.onUsbStylusConnectionChanged(usbDevice, + intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)); + } + } + + /** + * Interface definition for a callback to be invoked when stylus usb connection is changed. + */ + interface UsbStylusConnectionListener { + void onUsbStylusConnectionChanged(UsbDevice device, boolean connected); + } +} diff --git a/src/com/android/settings/overlay/FeatureFactory.java b/src/com/android/settings/overlay/FeatureFactory.java index 249caa111fb..97fc343bdac 100644 --- a/src/com/android/settings/overlay/FeatureFactory.java +++ b/src/com/android/settings/overlay/FeatureFactory.java @@ -31,6 +31,7 @@ import com.android.settings.aware.AwareFeatureProvider; import com.android.settings.biometrics.face.FaceFeatureProvider; import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider; import com.android.settings.bluetooth.BluetoothFeatureProvider; +import com.android.settings.connecteddevice.stylus.StylusFeatureProvider; import com.android.settings.dashboard.DashboardFeatureProvider; import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider; import com.android.settings.deviceinfo.hardwareinfo.HardwareInfoFeatureProvider; @@ -209,6 +210,11 @@ public abstract class FeatureFactory { */ public abstract KeyboardSettingsFeatureProvider getKeyboardSettingsFeatureProvider(); + /** + * Retrieves implementation for stylus settings feature. + */ + public abstract StylusFeatureProvider getStylusFeatureProvider(); + public static final class FactoryNotFoundException extends RuntimeException { public FactoryNotFoundException(Throwable throwable) { super("Unable to create factory. Did you misconfigure Proguard?", throwable); diff --git a/src/com/android/settings/overlay/FeatureFactoryImpl.java b/src/com/android/settings/overlay/FeatureFactoryImpl.java index 60adf958545..8c92792e1e2 100644 --- a/src/com/android/settings/overlay/FeatureFactoryImpl.java +++ b/src/com/android/settings/overlay/FeatureFactoryImpl.java @@ -42,6 +42,8 @@ import com.android.settings.biometrics2.factory.BiometricsRepositoryProviderImpl import com.android.settings.bluetooth.BluetoothFeatureProvider; import com.android.settings.bluetooth.BluetoothFeatureProviderImpl; import com.android.settings.connecteddevice.dock.DockUpdaterFeatureProviderImpl; +import com.android.settings.connecteddevice.stylus.StylusFeatureProvider; +import com.android.settings.connecteddevice.stylus.StylusFeatureProviderImpl; import com.android.settings.core.instrumentation.SettingsMetricsFeatureProvider; import com.android.settings.dashboard.DashboardFeatureProvider; import com.android.settings.dashboard.DashboardFeatureProviderImpl; @@ -119,6 +121,7 @@ public class FeatureFactoryImpl extends FeatureFactory { private AdvancedVpnFeatureProvider mAdvancedVpnFeatureProvider; private WifiFeatureProvider mWifiFeatureProvider; private KeyboardSettingsFeatureProvider mKeyboardSettingsFeatureProvider; + private StylusFeatureProvider mStylusFeatureProvider; @Override public HardwareInfoFeatureProvider getHardwareInfoFeatureProvider() { @@ -383,4 +386,12 @@ public class FeatureFactoryImpl extends FeatureFactory { } return mKeyboardSettingsFeatureProvider; } + + @Override + public StylusFeatureProvider getStylusFeatureProvider() { + if (mStylusFeatureProvider == null) { + mStylusFeatureProvider = new StylusFeatureProviderImpl(); + } + return mStylusFeatureProvider; + } } diff --git a/tests/robotests/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareControllerTest.java b/tests/robotests/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareControllerTest.java new file mode 100644 index 00000000000..59220164a62 --- /dev/null +++ b/tests/robotests/src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareControllerTest.java @@ -0,0 +1,163 @@ +/* + * 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.settings.connecteddevice.stylus; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.hardware.usb.UsbDevice; +import android.hardware.usb.UsbManager; + +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceManager; +import androidx.preference.PreferenceScreen; + +import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +import java.util.Collections; +import java.util.HashMap; + +@RunWith(RobolectricTestRunner.class) +public class StylusUsbFirmwareControllerTest { + + private Context mContext; + private FakeFeatureFactory mFeatureFactory; + private Lifecycle mLifecycle; + private PreferenceScreen mScreen; + + private StylusUsbFirmwareController mController; + @Mock + private StylusUsiDetailsFragment mFragment; + @Mock + private UsbManager mUsbManager; + private PreferenceCategory mPreferenceCategory; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + mLifecycle = new Lifecycle(() -> mLifecycle); + + when(mFragment.getContext()).thenReturn(mContext); + + mFeatureFactory = FakeFeatureFactory.setupForTest(); + mController = new StylusUsbFirmwareController(mContext, "stylus_usb_firmware"); + + PreferenceManager preferenceManager = new PreferenceManager(mContext); + mScreen = preferenceManager.createPreferenceScreen(mContext); + + mPreferenceCategory = new PreferenceCategory(mContext); + mPreferenceCategory.setKey(mController.getPreferenceKey()); + } + + @Test + public void displayPreference_featurePresentUsbStylusAttached_preferenceAdded() { + attachUsbDevice(); + enableFullStylusFeature(); + + mController.displayPreference(mScreen); + + assertNotNull(mScreen.findPreference("stylus_usb_firmware")); + } + + @Test + public void displayPreference_featureAbsentUsbStylusAttached_preferenceNotAdded() { + attachUsbDevice(); + mController.mUsbConnectionListener.onUsbStylusConnectionChanged( + mock(UsbDevice.class), true); + + mController.displayPreference(mScreen); + + assertNull(mScreen.findPreference(mController.getPreferenceKey())); + } + + @Test + public void onUsbStylusConnectionChanged_featurePresentUsbStylusAttached_preferenceAdded() { + mController.displayPreference(mScreen); + + attachUsbDevice(); + enableFullStylusFeature(); + mController.mUsbConnectionListener.onUsbStylusConnectionChanged( + mock(UsbDevice.class), true); + + assertNotNull(mScreen.findPreference(mController.getPreferenceKey())); + } + + @Test + public void onUsbStylusConnectionChanged_featureAbsentUsbStylusAttached_preferenceRemoved() { + mController.displayPreference(mScreen); + + attachUsbDevice(); + mController.mUsbConnectionListener.onUsbStylusConnectionChanged( + mock(UsbDevice.class), true); + + assertNull(mScreen.findPreference(mController.getPreferenceKey())); + } + + @Test + public void hasUsbStylusFirmwareUpdateFeature_featurePresent_true() { + when(mFeatureFactory.getStylusFeatureProvider() + .isUsbFirmwareUpdateEnabled(any())).thenReturn(true); + attachUsbDevice(); + + assertTrue(StylusUsbFirmwareController + .hasUsbStylusFirmwareUpdateFeature(mock(UsbDevice.class))); + } + + @Test + public void hasUsbStylusFirmwareUpdateFeature_featureNotPresent_false() { + when(mFeatureFactory.getStylusFeatureProvider() + .isUsbFirmwareUpdateEnabled(any())).thenReturn(false); + attachUsbDevice(); + + assertFalse(StylusUsbFirmwareController + .hasUsbStylusFirmwareUpdateFeature(mock(UsbDevice.class))); + } + + private void attachUsbDevice() { + when(mContext.getSystemService(UsbManager.class)).thenReturn(mUsbManager); + HashMap deviceList = new HashMap<>(); + deviceList.put("0", mock(UsbDevice.class)); + when(mUsbManager.getDeviceList()).thenReturn(deviceList); + } + + private void enableFullStylusFeature() { + when(mFeatureFactory.getStylusFeatureProvider() + .isUsbFirmwareUpdateEnabled(any())).thenReturn(true); + when(mFeatureFactory.getStylusFeatureProvider() + .getUsbFirmwareUpdatePreferences(any())) + .thenReturn(Collections.singletonList(mock(Preference.class))); + } +} diff --git a/tests/robotests/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiverTest.java b/tests/robotests/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiverTest.java new file mode 100644 index 00000000000..ccaefb25523 --- /dev/null +++ b/tests/robotests/src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiverTest.java @@ -0,0 +1,98 @@ +/* + * 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.settings.connecteddevice.stylus; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.content.Intent; +import android.hardware.usb.UsbDevice; +import android.hardware.usb.UsbManager; + +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class UsbStylusBroadcastReceiverTest { + private Context mContext; + private UsbStylusBroadcastReceiver mReceiver; + private FakeFeatureFactory mFeatureFactory; + @Mock + private UsbStylusBroadcastReceiver.UsbStylusConnectionListener mListener; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = RuntimeEnvironment.application; + mReceiver = new UsbStylusBroadcastReceiver(mContext, mListener); + mFeatureFactory = FakeFeatureFactory.setupForTest(); + } + + @Test + public void onReceive_usbDeviceAttachedStylus_invokeCallback() { + when(mFeatureFactory.mStylusFeatureProvider.isUsbFirmwareUpdateEnabled(any())) + .thenReturn(true); + final UsbDevice usbDevice = mock(UsbDevice.class); + final Intent intent = new Intent(); + intent.setAction(UsbManager.ACTION_USB_DEVICE_ATTACHED); + intent.putExtra(UsbManager.EXTRA_DEVICE, usbDevice); + + mReceiver.onReceive(mContext, intent); + + verify(mListener).onUsbStylusConnectionChanged(usbDevice, true); + } + + @Test + public void onReceive_usbDeviceDetachedStylus_invokeCallback() { + when(mFeatureFactory.mStylusFeatureProvider.isUsbFirmwareUpdateEnabled(any())) + .thenReturn(true); + final UsbDevice usbDevice = mock(UsbDevice.class); + final Intent intent = new Intent(); + intent.setAction(UsbManager.ACTION_USB_DEVICE_DETACHED); + intent.putExtra(UsbManager.EXTRA_DEVICE, usbDevice); + + mReceiver.onReceive(mContext, intent); + + verify(mListener).onUsbStylusConnectionChanged(usbDevice, false); + } + + @Test + public void onReceive_usbDeviceAttachedNotStylus_doesNotInvokeCallback() { + when(mFeatureFactory.mStylusFeatureProvider.isUsbFirmwareUpdateEnabled(any())) + .thenReturn(false); + final UsbDevice usbDevice = mock(UsbDevice.class); + final Intent intent = new Intent(); + intent.setAction(UsbManager.ACTION_USB_DEVICE_ATTACHED); + intent.putExtra(UsbManager.EXTRA_DEVICE, usbDevice); + + mReceiver.onReceive(mContext, intent); + + verifyNoMoreInteractions(mListener); + } +} diff --git a/tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java b/tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java index fcb01b4649e..5891aa19255 100644 --- a/tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java +++ b/tests/robotests/src/com/android/settings/testutils/FakeFeatureFactory.java @@ -29,6 +29,7 @@ import com.android.settings.aware.AwareFeatureProvider; import com.android.settings.biometrics.face.FaceFeatureProvider; import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider; import com.android.settings.bluetooth.BluetoothFeatureProvider; +import com.android.settings.connecteddevice.stylus.StylusFeatureProvider; import com.android.settings.dashboard.DashboardFeatureProvider; import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider; import com.android.settings.deviceinfo.hardwareinfo.HardwareInfoFeatureProvider; @@ -97,6 +98,7 @@ public class FakeFeatureFactory extends FeatureFactory { public AdvancedVpnFeatureProvider mAdvancedVpnFeatureProvider; public WifiFeatureProvider mWifiFeatureProvider; public KeyboardSettingsFeatureProvider mKeyboardSettingsFeatureProvider; + public StylusFeatureProvider mStylusFeatureProvider; /** * Call this in {@code @Before} method of the test class to use fake factory. @@ -150,6 +152,7 @@ public class FakeFeatureFactory extends FeatureFactory { mAdvancedVpnFeatureProvider = mock(AdvancedVpnFeatureProvider.class); mWifiFeatureProvider = mock(WifiFeatureProvider.class); mKeyboardSettingsFeatureProvider = mock(KeyboardSettingsFeatureProvider.class); + mStylusFeatureProvider = mock(StylusFeatureProvider.class); } @Override @@ -311,4 +314,9 @@ public class FakeFeatureFactory extends FeatureFactory { public KeyboardSettingsFeatureProvider getKeyboardSettingsFeatureProvider() { return mKeyboardSettingsFeatureProvider; } + + @Override + public StylusFeatureProvider getStylusFeatureProvider() { + return mStylusFeatureProvider; + } } diff --git a/tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt b/tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt index 68078f8ba56..6320fc7074a 100644 --- a/tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt +++ b/tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt @@ -25,6 +25,7 @@ import com.android.settings.aware.AwareFeatureProvider import com.android.settings.biometrics.face.FaceFeatureProvider import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider import com.android.settings.bluetooth.BluetoothFeatureProvider +import com.android.settings.connecteddevice.stylus.StylusFeatureProvider import com.android.settings.dashboard.DashboardFeatureProvider import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider import com.android.settings.deviceinfo.hardwareinfo.HardwareInfoFeatureProvider @@ -190,4 +191,8 @@ class FakeFeatureFactory : FeatureFactory() { override fun getKeyboardSettingsFeatureProvider(): KeyboardSettingsFeatureProvider { TODO("Not yet implemented") } + + override fun getStylusFeatureProvider(): StylusFeatureProvider { + TODO("Not yet implemented") + } } diff --git a/tests/unit/src/com/android/settings/testutils/FakeFeatureFactory.java b/tests/unit/src/com/android/settings/testutils/FakeFeatureFactory.java index 7a498652a5d..49ce2cc761e 100644 --- a/tests/unit/src/com/android/settings/testutils/FakeFeatureFactory.java +++ b/tests/unit/src/com/android/settings/testutils/FakeFeatureFactory.java @@ -27,6 +27,7 @@ import com.android.settings.aware.AwareFeatureProvider; import com.android.settings.biometrics.face.FaceFeatureProvider; import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider; import com.android.settings.bluetooth.BluetoothFeatureProvider; +import com.android.settings.connecteddevice.stylus.StylusFeatureProvider; import com.android.settings.dashboard.DashboardFeatureProvider; import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider; import com.android.settings.deviceinfo.hardwareinfo.HardwareInfoFeatureProvider; @@ -92,6 +93,7 @@ public class FakeFeatureFactory extends FeatureFactory { public AdvancedVpnFeatureProvider mAdvancedVpnFeatureProvider; public WifiFeatureProvider mWifiFeatureProvider; public KeyboardSettingsFeatureProvider mKeyboardSettingsFeatureProvider; + public StylusFeatureProvider mStylusFeatureProvider; /** * Call this in {@code @Before} method of the test class to use fake factory. @@ -136,6 +138,7 @@ public class FakeFeatureFactory extends FeatureFactory { mAdvancedVpnFeatureProvider = mock(AdvancedVpnFeatureProvider.class); mWifiFeatureProvider = mock(WifiFeatureProvider.class); mKeyboardSettingsFeatureProvider = mock(KeyboardSettingsFeatureProvider.class); + mStylusFeatureProvider = mock(StylusFeatureProvider.class); } @Override @@ -297,4 +300,9 @@ public class FakeFeatureFactory extends FeatureFactory { public KeyboardSettingsFeatureProvider getKeyboardSettingsFeatureProvider() { return mKeyboardSettingsFeatureProvider; } + + @Override + public StylusFeatureProvider getStylusFeatureProvider() { + return mStylusFeatureProvider; + } } From b222b9640721ef2e7392255464ac5a66d81a7e62 Mon Sep 17 00:00:00 2001 From: Michael Mikhail Date: Fri, 7 Jul 2023 18:37:45 +0000 Subject: [PATCH 3/3] Override the state description of volume seekbar. This overrides the state description of seekbar in order to adjust the progress percentage. The percentage of seekbar is not matching with the percentage said by talkback feature when the volume changes. This CL rounds the percentage to match what is said by talkback. Bug: 285458191 Test: Enabled talkback and checked percentages of sliders of all sounds and vibrations volumes. Video attached in bug link. Test: atest VolumeSeekBarPreferenceTest. Change-Id: Iedcf3eccb13b7f8ee1a4ca521f0783c55d7a1902 --- .../notification/SeekBarVolumizerFactory.java | 44 +++++++++ .../notification/VolumeSeekBarPreference.java | 41 +++++++- .../VolumeSeekBarPreferenceTest.java | 95 +++++++++++++++++-- 3 files changed, 171 insertions(+), 9 deletions(-) create mode 100644 src/com/android/settings/notification/SeekBarVolumizerFactory.java diff --git a/src/com/android/settings/notification/SeekBarVolumizerFactory.java b/src/com/android/settings/notification/SeekBarVolumizerFactory.java new file mode 100644 index 00000000000..6fac2c13e00 --- /dev/null +++ b/src/com/android/settings/notification/SeekBarVolumizerFactory.java @@ -0,0 +1,44 @@ +/* + * 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.settings.notification; + +import android.content.Context; +import android.net.Uri; +import android.preference.SeekBarVolumizer; + +/** + * Testable wrapper around {@link SeekBarVolumizer} constructor. + */ +public class SeekBarVolumizerFactory { + private final Context mContext; + + public SeekBarVolumizerFactory(Context context) { + mContext = context; + } + + /** + * Creates a new SeekBarVolumizer. + * + * @param streamType of the audio manager. + * @param defaultUri of the volume. + * @param sbvc callback of the seekbar volumizer. + * @return a SeekBarVolumizer. + */ + public SeekBarVolumizer create(int streamType, Uri defaultUri, SeekBarVolumizer.Callback sbvc) { + return new SeekBarVolumizer(mContext, streamType, defaultUri, sbvc); + } +} diff --git a/src/com/android/settings/notification/VolumeSeekBarPreference.java b/src/com/android/settings/notification/VolumeSeekBarPreference.java index 0000eba2ba7..9f14b738a9d 100644 --- a/src/com/android/settings/notification/VolumeSeekBarPreference.java +++ b/src/com/android/settings/notification/VolumeSeekBarPreference.java @@ -37,6 +37,8 @@ import com.android.internal.jank.InteractionJankMonitor; import com.android.settings.R; import com.android.settings.widget.SeekBarPreference; +import java.text.NumberFormat; +import java.util.Locale; import java.util.Objects; /** A slider preference that directly controls an audio stream volume (no dialog) **/ @@ -47,8 +49,9 @@ public class VolumeSeekBarPreference extends SeekBarPreference { protected SeekBar mSeekBar; private int mStream; + private SeekBarVolumizer mVolumizer; @VisibleForTesting - SeekBarVolumizer mVolumizer; + SeekBarVolumizerFactory mSeekBarVolumizerFactory; private Callback mCallback; private Listener mListener; private ImageView mIconView; @@ -62,30 +65,36 @@ public class VolumeSeekBarPreference extends SeekBarPreference { private boolean mStopped; @VisibleForTesting AudioManager mAudioManager; + private Locale mLocale; + private NumberFormat mNumberFormat; public VolumeSeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { super(context, attrs, defStyleAttr, defStyleRes); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context, AttributeSet attrs) { super(context, attrs); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context) { super(context); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public void setStream(int stream) { @@ -143,6 +152,7 @@ public class VolumeSeekBarPreference extends SeekBarPreference { if (mCallback != null) { mCallback.onStreamValueChanged(mStream, progress); } + overrideSeekBarStateDescription(formatStateDescription(progress)); } @Override public void onMuted(boolean muted, boolean zenMuted) { @@ -170,7 +180,7 @@ public class VolumeSeekBarPreference extends SeekBarPreference { }; final Uri sampleUri = mStream == AudioManager.STREAM_MUSIC ? getMediaVolumeUri() : null; if (mVolumizer == null) { - mVolumizer = new SeekBarVolumizer(getContext(), mStream, sampleUri, sbvc); + mVolumizer = mSeekBarVolumizerFactory.create(mStream, sampleUri, sbvc); } mVolumizer.start(); mVolumizer.setSeekBar(mSeekBar); @@ -216,6 +226,33 @@ public class VolumeSeekBarPreference extends SeekBarPreference { + "/" + R.raw.media_volume); } + @VisibleForTesting + CharSequence formatStateDescription(int progress) { + // This code follows the same approach in ProgressBar.java, but it rounds down the percent + // to match it with what the talkback feature says after any progress change. (b/285458191) + // Cache the locale-appropriate NumberFormat. Configuration locale is guaranteed + // non-null, so the first time this is called we will always get the appropriate + // NumberFormat, then never regenerate it unless the locale changes on the fly. + Locale curLocale = getContext().getResources().getConfiguration().getLocales().get(0); + if (mLocale == null || !mLocale.equals(curLocale)) { + mLocale = curLocale; + mNumberFormat = NumberFormat.getPercentInstance(mLocale); + } + return mNumberFormat.format(getPercent(progress)); + } + + @VisibleForTesting + double getPercent(float progress) { + final float maxProgress = getMax(); + final float minProgress = getMin(); + final float diffProgress = maxProgress - minProgress; + if (diffProgress <= 0.0f) { + return 0.0f; + } + final float percent = (progress - minProgress) / diffProgress; + return Math.floor(Math.max(0.0f, Math.min(1.0f, percent)) * 100) / 100; + } + public void setSuppressionText(String text) { if (Objects.equals(text, mSuppressionText)) return; mSuppressionText = text; diff --git a/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java b/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java index 59f0bcb91b9..47bf99db4f3 100644 --- a/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java +++ b/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java @@ -17,62 +17,81 @@ package com.android.settings.notification; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doCallRealMethod; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.Context; +import android.content.res.Configuration; +import android.content.res.Resources; import android.media.AudioManager; +import android.os.LocaleList; import android.preference.SeekBarVolumizer; import android.widget.SeekBar; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; +import java.util.Locale; + @RunWith(RobolectricTestRunner.class) public class VolumeSeekBarPreferenceTest { private static final CharSequence CONTENT_DESCRIPTION = "TEST"; + private static final int STREAM = 5; @Mock private AudioManager mAudioManager; @Mock private VolumeSeekBarPreference mPreference; @Mock private Context mContext; + + @Mock + private Resources mRes; + @Mock + private Configuration mConfig; @Mock private SeekBar mSeekBar; + @Captor + private ArgumentCaptor mSbvc; @Mock private SeekBarVolumizer mVolumizer; + @Mock + private SeekBarVolumizerFactory mSeekBarVolumizerFactory; private VolumeSeekBarPreference.Listener mListener; @Before public void setUp() { MockitoAnnotations.initMocks(this); when(mContext.getSystemService(Context.AUDIO_SERVICE)).thenReturn(mAudioManager); + when(mSeekBarVolumizerFactory.create(eq(STREAM), eq(null), mSbvc.capture())) + .thenReturn(mVolumizer); + doCallRealMethod().when(mPreference).setStream(anyInt()); doCallRealMethod().when(mPreference).updateContentDescription(CONTENT_DESCRIPTION); mPreference.mSeekBar = mSeekBar; mPreference.mAudioManager = mAudioManager; - mPreference.mVolumizer = mVolumizer; + mPreference.mSeekBarVolumizerFactory = mSeekBarVolumizerFactory; mListener = () -> mPreference.updateContentDescription(CONTENT_DESCRIPTION); } @Test public void setStream_shouldSetMinMaxAndProgress() { - final int stream = 5; final int max = 17; final int min = 1; final int progress = 4; - when(mAudioManager.getStreamMaxVolume(stream)).thenReturn(max); - when(mAudioManager.getStreamMinVolumeInt(stream)).thenReturn(min); - when(mAudioManager.getStreamVolume(stream)).thenReturn(progress); - doCallRealMethod().when(mPreference).setStream(anyInt()); + when(mAudioManager.getStreamMaxVolume(STREAM)).thenReturn(max); + when(mAudioManager.getStreamMinVolumeInt(STREAM)).thenReturn(min); + when(mAudioManager.getStreamVolume(STREAM)).thenReturn(progress); - mPreference.setStream(stream); + mPreference.setStream(STREAM); verify(mPreference).setMax(max); verify(mPreference).setMin(min); @@ -84,6 +103,7 @@ public class VolumeSeekBarPreferenceTest { doCallRealMethod().when(mPreference).setListener(mListener); doCallRealMethod().when(mPreference).init(); + mPreference.setStream(STREAM); mPreference.setListener(mListener); mPreference.init(); @@ -94,8 +114,69 @@ public class VolumeSeekBarPreferenceTest { public void init_listenerNotSet_noException() { doCallRealMethod().when(mPreference).init(); + mPreference.setStream(STREAM); mPreference.init(); verify(mPreference, never()).updateContentDescription(CONTENT_DESCRIPTION); } + + @Test + public void init_changeProgress_overrideStateDescriptionCalled() { + final int progress = 4; + when(mPreference.formatStateDescription(progress)).thenReturn(CONTENT_DESCRIPTION); + doCallRealMethod().when(mPreference).init(); + + mPreference.setStream(STREAM); + mPreference.init(); + + verify(mSeekBarVolumizerFactory).create(eq(STREAM), eq(null), mSbvc.capture()); + + mSbvc.getValue().onProgressChanged(mSeekBar, 4, true); + + verify(mPreference).overrideSeekBarStateDescription(CONTENT_DESCRIPTION); + } + + @Test + public void init_changeProgress_stateDescriptionValueUpdated() { + final int max = 17; + final int min = 1; + int progress = 4; + when(mAudioManager.getStreamMaxVolume(STREAM)).thenReturn(max); + when(mAudioManager.getStreamMinVolumeInt(STREAM)).thenReturn(min); + when(mAudioManager.getStreamVolume(STREAM)).thenReturn(progress); + when(mPreference.getMin()).thenReturn(min); + when(mPreference.getMax()).thenReturn(max); + when(mPreference.getContext()).thenReturn(mContext); + when(mContext.getResources()).thenReturn(mRes); + when(mRes.getConfiguration()).thenReturn(mConfig); + when(mConfig.getLocales()).thenReturn(new LocaleList(Locale.US)); + doCallRealMethod().when(mPreference).init(); + + mPreference.setStream(STREAM); + mPreference.init(); + + // On progress change, Round down the percent to match it with what the talkback says. + // (b/285458191) + // when progress is 4, the percent is 0.187. The state description should be set to 18%. + testFormatStateDescription(progress, "18%"); + + progress = 6; + + // when progress is 6, the percent is 0.3125. The state description should be set to 31%. + testFormatStateDescription(progress, "31%"); + + progress = 7; + + // when progress is 7, the percent is 0.375. The state description should be set to 37%. + testFormatStateDescription(progress, "37%"); + } + + private void testFormatStateDescription(int progress, String expected) { + doCallRealMethod().when(mPreference).formatStateDescription(progress); + doCallRealMethod().when(mPreference).getPercent(progress); + + mSbvc.getValue().onProgressChanged(mSeekBar, progress, true); + + verify(mPreference).overrideSeekBarStateDescription(expected); + } }