From 4f87dd4b568d39e4d77d0601b360bbbb1a0c5829 Mon Sep 17 00:00:00 2001 From: Behnam Heydarshahi Date: Thu, 15 Dec 2022 21:51:13 +0000 Subject: [PATCH 1/9] Implement a separate controller for ring volume When ring volume is separated from notification, a new xml preferece and controller is needed for it, so that the settings search can show/hide the slice correctly. 1. Use a separate preference and controller for ring volume (vs ring & notification combined) 2. Notification slice in settings no longer grays out when ringer mode is set to mute or vibrate. 3. Introduce an abstract RingerModeAffected preference controller class to factor out duplicate code among ring, notification, and separate-ring controller classes. Bug: b/259084354 Test: make ROBOTEST_FILTER=RingVolumePreferenceControllerTest RunSettingsRoboTests -j40 make ROBOTEST_FILTER=SeparateRingVolumePreferenceControllerTest RunSettingsRoboTests -j40 make ROBOTEST_FILTER=NotificationVolumePreferenceControllerTest RunSettingsRoboTests -j40 make ROBOTEST_FILTER=VolumePanelTest RunSettingsRoboTests -j40 make ROBOTEST_FILTER=RingerModeAffectedVolumePreferenceControllerTest -j40 Known Issue: 1. When streams are separate and ring volume set to mute/vibrate, notification is set to zero, but not disabled. So it can be turned on by user (and in settings the icon will stay mute/vibrate instead of changing to the normal notification icon). 2. In the above scenario after notification is unmuted in settings, the notification icon continues to stay vibrate/mute -- should change to the normal notification icon. Note: This feature is controlled using a boolean DeviceConfig flag: systemui/"volume_separate_ring". The default value is 'false', which is meant to keep the experience the same as before. It will be set to 'true' for teamfood and dogfood. Eventually the flag will be removed and the code in the 'true' branch will prevail. Change-Id: Ibec871eafeef4081e96c5e0dd04535565d50a077 --- res/xml/sound_settings.xml | 10 +- ...otificationVolumePreferenceController.java | 108 ++-------- .../RingVolumePreferenceController.java | 184 ++---------------- ...odeAffectedVolumePreferenceController.java | 168 ++++++++++++++++ ...eparateRingVolumePreferenceController.java | 180 +++++++++++++++++ .../settings/notification/SoundSettings.java | 1 + .../settings/panel/PanelSlicesAdapter.java | 2 +- .../android/settings/panel/VolumePanel.java | 10 +- .../settings/slices/CustomSliceRegistry.java | 12 +- .../RingVolumePreferenceControllerTest.java | 70 ++++--- ...ffectedVolumePreferenceControllerTest.java | 49 +++++ ...ateRingVolumePreferenceControllerTest.java | 107 ++++++++++ .../settings/panel/VolumePanelTest.java | 2 + 13 files changed, 615 insertions(+), 288 deletions(-) create mode 100644 src/com/android/settings/notification/RingerModeAffectedVolumePreferenceController.java create mode 100644 src/com/android/settings/notification/SeparateRingVolumePreferenceController.java create mode 100644 tests/robotests/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceControllerTest.java create mode 100644 tests/robotests/src/com/android/settings/notification/SeparateRingVolumePreferenceControllerTest.java diff --git a/res/xml/sound_settings.xml b/res/xml/sound_settings.xml index 914ce72428d..a84b0aefcd2 100644 --- a/res/xml/sound_settings.xml +++ b/res/xml/sound_settings.xml @@ -72,6 +72,14 @@ android:order="-160" settings:controller="com.android.settings.notification.RingVolumePreferenceController"/> + + + -x + changeSet = properties.getKeyset(); if (changeSet.contains(SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION)) { - boolean newVal = properties.getBoolean( - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, CONFIG_DEFAULT_VAL); + boolean newVal = isSeparateNotificationConfigEnabled(); if (newVal != mSeparateNotification) { mSeparateNotification = newVal; // manually hiding the preference because being unavailable does not do the job @@ -143,8 +124,7 @@ public class NotificationVolumePreferenceController extends VolumeSeekBarPrefere @Override public int getAvailabilityStatus() { - boolean separateNotification = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, false); + boolean separateNotification = isSeparateNotificationConfigEnabled(); return mContext.getResources().getBoolean(R.bool.config_show_notification_volume) && !mHelper.isSingleVolume() @@ -152,72 +132,18 @@ public class NotificationVolumePreferenceController extends VolumeSeekBarPrefere ? AVAILABLE : UNSUPPORTED_ON_DEVICE; } - @Override - public boolean isSliceable() { - return TextUtils.equals(getPreferenceKey(), KEY_NOTIFICATION_VOLUME); - } - - @Override - public boolean isPublicSlice() { - return true; - } - @Override public String getPreferenceKey() { return KEY_NOTIFICATION_VOLUME; } - @Override - public boolean useDynamicSliceSummary() { - return true; - } - @Override public int getAudioStream() { return AudioManager.STREAM_NOTIFICATION; } @Override - public int getMuteIcon() { - return mMuteIcon; - } - - private void updateRingerMode() { - final int ringerMode = mHelper.getRingerModeInternal(); - if (mRingerMode == ringerMode) return; - mRingerMode = ringerMode; - updatePreferenceIconAndSliderState(); - } - - private void updateEffectsSuppressor() { - final ComponentName suppressor = NotificationManager.from(mContext).getEffectsSuppressor(); - if (Objects.equals(suppressor, mSuppressor)) return; - - if (mNoMan == null) { - mNoMan = INotificationManager.Stub.asInterface( - ServiceManager.getService(Context.NOTIFICATION_SERVICE)); - } - - final int hints; - try { - hints = mNoMan.getHintsFromListenerNoToken(); - } catch (android.os.RemoteException exception) { - Log.w(TAG, "updateEffectsSuppressor: " + exception.getLocalizedMessage()); - return; - } - - if (hintsMatch(hints)) { - - mSuppressor = suppressor; - if (mPreference != null) { - final String text = SuppressorHelper.getSuppressionText(mContext, suppressor); - mPreference.setSuppressionText(text); - } - } - } - - @VisibleForTesting - boolean hintsMatch(int hints) { + protected boolean hintsMatch(int hints) { boolean allEffectsDisabled = (hints & NotificationListenerService.HINT_HOST_DISABLE_EFFECTS) != 0; boolean notificationEffectsDisabled = @@ -226,20 +152,18 @@ public class NotificationVolumePreferenceController extends VolumeSeekBarPrefere return allEffectsDisabled || notificationEffectsDisabled; } - private void updatePreferenceIconAndSliderState() { + @Override + protected void selectPreferenceIconState() { if (mPreference != null) { if (mVibrator != null && mRingerMode == AudioManager.RINGER_MODE_VIBRATE) { mMuteIcon = mVibrateIconId; mPreference.showIcon(mVibrateIconId); - mPreference.setEnabled(false); } else if (mRingerMode == AudioManager.RINGER_MODE_SILENT || mVibrator == null && mRingerMode == AudioManager.RINGER_MODE_VIBRATE) { mMuteIcon = mSilentIconId; mPreference.showIcon(mSilentIconId); - mPreference.setEnabled(false); } else { // ringmode normal: could be that we are still silent - mPreference.setEnabled(true); if (mHelper.getStreamVolume(AudioManager.STREAM_NOTIFICATION) == 0) { // ring is in normal, but notification is in silent mMuteIcon = mSilentIconId; @@ -270,7 +194,7 @@ public class NotificationVolumePreferenceController extends VolumeSeekBarPrefere updateRingerMode(); break; case NOTIFICATION_VOLUME_CHANGED: - updatePreferenceIconAndSliderState(); + selectPreferenceIconState(); break; } } diff --git a/src/com/android/settings/notification/RingVolumePreferenceController.java b/src/com/android/settings/notification/RingVolumePreferenceController.java index 7fdb1e16141..1399e717749 100644 --- a/src/com/android/settings/notification/RingVolumePreferenceController.java +++ b/src/com/android/settings/notification/RingVolumePreferenceController.java @@ -17,10 +17,8 @@ package com.android.settings.notification; import android.app.ActivityThread; -import android.app.INotificationManager; import android.app.NotificationManager; import android.content.BroadcastReceiver; -import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; @@ -28,118 +26,59 @@ import android.media.AudioManager; import android.os.Handler; import android.os.Looper; import android.os.Message; -import android.os.ServiceManager; -import android.os.Vibrator; import android.provider.DeviceConfig; import android.service.notification.NotificationListenerService; -import android.text.TextUtils; -import android.util.Log; import androidx.lifecycle.OnLifecycleEvent; -import com.android.internal.annotations.VisibleForTesting; import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; import com.android.settings.R; import com.android.settings.Utils; import com.android.settingslib.core.lifecycle.Lifecycle; -import java.util.Objects; import java.util.Set; /** - * This slider can represent both ring and notification, if the corresponding streams are aliased, - * and only ring if the streams are not aliased. + * This slider represents both ring and notification */ -public class RingVolumePreferenceController extends VolumeSeekBarPreferenceController { +public class RingVolumePreferenceController extends + RingerModeAffectedVolumePreferenceController { - private static final String TAG = "RingVolumePreferenceController"; private static final String KEY_RING_VOLUME = "ring_volume"; + private static final String TAG = "RingVolumePreferenceController"; - private Vibrator mVibrator; - private int mRingerMode = AudioManager.RINGER_MODE_NORMAL; - private ComponentName mSuppressor; private final RingReceiver mReceiver = new RingReceiver(); private final H mHandler = new H(); - private int mMuteIcon; - - private int mNormalIconId; - @VisibleForTesting - int mVibrateIconId; - @VisibleForTesting - int mSilentIconId; - - @VisibleForTesting - int mTitleId; - - private boolean mSeparateNotification; - - private INotificationManager mNoMan; - - private static final boolean CONFIG_DEFAULT_VAL = false; - public RingVolumePreferenceController(Context context) { this(context, KEY_RING_VOLUME); } public RingVolumePreferenceController(Context context, String key) { - super(context, key); - mVibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE); - if (mVibrator != null && !mVibrator.hasVibrator()) { - mVibrator = null; - } - mSeparateNotification = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, CONFIG_DEFAULT_VAL); - loadPreferenceIconResources(mSeparateNotification); - updateRingerMode(); - } + super(context, key, TAG); - private void loadPreferenceIconResources(boolean separateNotification) { - if (separateNotification) { - mTitleId = R.string.separate_ring_volume_option_title; - mNormalIconId = R.drawable.ic_ring_volume; - mSilentIconId = R.drawable.ic_ring_volume_off; - } else { - mTitleId = R.string.ring_volume_option_title; - mNormalIconId = R.drawable.ic_notifications; - mSilentIconId = R.drawable.ic_notifications_off_24dp; - } - // todo: set a distinct vibrate icon for ring vs notification + mNormalIconId = R.drawable.ic_notifications; mVibrateIconId = R.drawable.ic_volume_ringer_vibrate; + mSilentIconId = R.drawable.ic_notifications_off_24dp; + + mSeparateNotification = isSeparateNotificationConfigEnabled(); + updateRingerMode(); } /** * As the responsibility of this slider changes, so should its title & icon */ - public void onDeviceConfigChange(DeviceConfig.Properties properties) { + private void onDeviceConfigChange(DeviceConfig.Properties properties) { Set changeSet = properties.getKeyset(); if (changeSet.contains(SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION)) { boolean valueUpdated = readSeparateNotificationVolumeConfig(); if (valueUpdated) { updateEffectsSuppressor(); selectPreferenceIconState(); - setPreferenceTitle(); } } } - /** - * side effect: updates the cached value of the config, and also the icon - * @return has the config changed? - */ - private boolean readSeparateNotificationVolumeConfig() { - boolean newVal = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, CONFIG_DEFAULT_VAL); - - boolean valueUpdated = newVal != mSeparateNotification; - if (valueUpdated) { - mSeparateNotification = newVal; - loadPreferenceIconResources(newVal); - } - - return valueUpdated; - } - @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) @Override public void onResume() { @@ -150,7 +89,10 @@ public class RingVolumePreferenceController extends VolumeSeekBarPreferenceContr ActivityThread.currentApplication().getMainExecutor(), this::onDeviceConfigChange); updateEffectsSuppressor(); selectPreferenceIconState(); - setPreferenceTitle(); + + if (mPreference != null) { + mPreference.setVisible(getAvailabilityStatus() == AVAILABLE); + } } @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) @@ -168,113 +110,27 @@ public class RingVolumePreferenceController extends VolumeSeekBarPreferenceContr @Override public int getAvailabilityStatus() { - return Utils.isVoiceCapable(mContext) && !mHelper.isSingleVolume() + boolean separateNotification = isSeparateNotificationConfigEnabled(); + + return !separateNotification && Utils.isVoiceCapable(mContext) && !mHelper.isSingleVolume() ? AVAILABLE : UNSUPPORTED_ON_DEVICE; } - @Override - public boolean isSliceable() { - return TextUtils.equals(getPreferenceKey(), KEY_RING_VOLUME); - } - - @Override - public boolean isPublicSlice() { - return true; - } - - @Override - public boolean useDynamicSliceSummary() { - return true; - } - @Override public int getAudioStream() { return AudioManager.STREAM_RING; } @Override - public int getMuteIcon() { - return mMuteIcon; - } + protected boolean hintsMatch(int hints) { + boolean notificationSeparated = isSeparateNotificationConfigEnabled(); - @VisibleForTesting - void updateRingerMode() { - final int ringerMode = mHelper.getRingerModeInternal(); - if (mRingerMode == ringerMode) return; - mRingerMode = ringerMode; - selectPreferenceIconState(); - } - - private void updateEffectsSuppressor() { - final ComponentName suppressor = NotificationManager.from(mContext).getEffectsSuppressor(); - if (Objects.equals(suppressor, mSuppressor)) return; - - if (mNoMan == null) { - mNoMan = INotificationManager.Stub.asInterface( - ServiceManager.getService(Context.NOTIFICATION_SERVICE)); - } - - final int hints; - try { - hints = mNoMan.getHintsFromListenerNoToken(); - } catch (android.os.RemoteException ex) { - Log.w(TAG, "updateEffectsSuppressor: " + ex.getMessage()); - return; - } - - if (hintsMatch(hints, DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, false))) { - mSuppressor = suppressor; - if (mPreference != null) { - final String text = SuppressorHelper.getSuppressionText(mContext, suppressor); - mPreference.setSuppressionText(text); - } - } - } - - @VisibleForTesting - boolean hintsMatch(int hints, boolean notificationSeparated) { return (hints & NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS) != 0 || (hints & NotificationListenerService.HINT_HOST_DISABLE_EFFECTS) != 0 || ((hints & NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS) != 0 && !notificationSeparated); } - @VisibleForTesting - void setPreference(VolumeSeekBarPreference volumeSeekBarPreference) { - mPreference = volumeSeekBarPreference; - } - - @VisibleForTesting - void setVibrator(Vibrator vibrator) { - mVibrator = vibrator; - } - - private void selectPreferenceIconState() { - if (mPreference != null) { - if (mRingerMode == AudioManager.RINGER_MODE_NORMAL) { - mPreference.showIcon(mNormalIconId); - } else { - if (mRingerMode == AudioManager.RINGER_MODE_VIBRATE && mVibrator != null) { - mMuteIcon = mVibrateIconId; - } else { - mMuteIcon = mSilentIconId; - } - mPreference.showIcon(mMuteIcon); - } - } - } - - /** - * This slider can represent both ring and notification, or only ring. - * Note: This cannot be used in the constructor, as the reference to preference object would - * still be null. - */ - private void setPreferenceTitle() { - if (mPreference != null) { - mPreference.setTitle(mTitleId); - } - } private final class H extends Handler { private static final int UPDATE_EFFECTS_SUPPRESSOR = 1; diff --git a/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceController.java b/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceController.java new file mode 100644 index 00000000000..e792d534997 --- /dev/null +++ b/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceController.java @@ -0,0 +1,168 @@ +/* + * Copyright (C) 2022 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.app.INotificationManager; +import android.app.NotificationManager; +import android.content.ComponentName; +import android.content.Context; +import android.media.AudioManager; +import android.os.ServiceManager; +import android.os.Vibrator; +import android.provider.DeviceConfig; +import android.util.Log; + +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; + +import java.util.Objects; + +/** + * Shared functionality and interfaces for volume controllers whose state can change by ringer mode + */ +public abstract class RingerModeAffectedVolumePreferenceController extends + VolumeSeekBarPreferenceController { + + private final String mTag; + + protected int mNormalIconId; + protected int mVibrateIconId; + protected int mSilentIconId; + protected int mMuteIcon; + + protected Vibrator mVibrator; + protected int mRingerMode = AudioManager.RINGER_MODE_NORMAL; + protected ComponentName mSuppressor; + protected boolean mSeparateNotification; + protected INotificationManager mNoMan; + + private static final boolean CONFIG_SEPARATE_NOTIFICATION_DEFAULT_VAL = false; + + public RingerModeAffectedVolumePreferenceController(Context context, String key, String tag) { + super(context, key); + mTag = tag; + mVibrator = mContext.getSystemService(Vibrator.class); + if (mVibrator != null && !mVibrator.hasVibrator()) { + mVibrator = null; + } + } + + protected void updateEffectsSuppressor() { + final ComponentName suppressor = NotificationManager.from(mContext).getEffectsSuppressor(); + if (Objects.equals(suppressor, mSuppressor)) return; + + if (mNoMan == null) { + mNoMan = INotificationManager.Stub.asInterface( + ServiceManager.getService(Context.NOTIFICATION_SERVICE)); + } + + final int hints; + try { + hints = mNoMan.getHintsFromListenerNoToken(); + } catch (android.os.RemoteException ex) { + Log.w(mTag, "updateEffectsSuppressor: " + ex.getMessage()); + return; + } + + if (hintsMatch(hints)) { + mSuppressor = suppressor; + if (mPreference != null) { + final String text = SuppressorHelper.getSuppressionText(mContext, suppressor); + mPreference.setSuppressionText(text); + } + } + } + + @VisibleForTesting + void setPreference(VolumeSeekBarPreference volumeSeekBarPreference) { + mPreference = volumeSeekBarPreference; + } + + @VisibleForTesting + void setVibrator(Vibrator vibrator) { + mVibrator = vibrator; + } + + @Override + public boolean isSliceable() { + return true; + } + + @Override + public boolean isPublicSlice() { + return true; + } + + @Override + public boolean useDynamicSliceSummary() { + return true; + } + + @Override + public int getMuteIcon() { + return mMuteIcon; + } + + protected boolean isSeparateNotificationConfigEnabled() { + return DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, + CONFIG_SEPARATE_NOTIFICATION_DEFAULT_VAL); + } + + /** + * side effect: updates the cached value of the config + * @return has the config changed? + */ + protected boolean readSeparateNotificationVolumeConfig() { + boolean newVal = isSeparateNotificationConfigEnabled(); + + boolean valueUpdated = newVal != mSeparateNotification; + if (valueUpdated) { + mSeparateNotification = newVal; + } + + return valueUpdated; + } + + protected void updateRingerMode() { + final int ringerMode = mHelper.getRingerModeInternal(); + if (mRingerMode == ringerMode) return; + mRingerMode = ringerMode; + selectPreferenceIconState(); + } + + /** + * Switching among normal/mute/vibrate + */ + protected void selectPreferenceIconState() { + if (mPreference != null) { + if (mRingerMode == AudioManager.RINGER_MODE_NORMAL) { + mPreference.showIcon(mNormalIconId); + } else { + if (mRingerMode == AudioManager.RINGER_MODE_VIBRATE && mVibrator != null) { + mMuteIcon = mVibrateIconId; + } else { + mMuteIcon = mSilentIconId; + } + mPreference.showIcon(getMuteIcon()); + } + } + } + + protected abstract boolean hintsMatch(int hints); + +} diff --git a/src/com/android/settings/notification/SeparateRingVolumePreferenceController.java b/src/com/android/settings/notification/SeparateRingVolumePreferenceController.java new file mode 100644 index 00000000000..12133721029 --- /dev/null +++ b/src/com/android/settings/notification/SeparateRingVolumePreferenceController.java @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2022 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.app.ActivityThread; +import android.app.NotificationManager; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.media.AudioManager; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.DeviceConfig; +import android.service.notification.NotificationListenerService; + +import androidx.lifecycle.OnLifecycleEvent; + +import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; +import com.android.settings.R; +import com.android.settings.Utils; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import java.util.Set; + +/** + * This slider is used to represent ring volume when ring is separated from notification + */ +public class SeparateRingVolumePreferenceController extends + RingerModeAffectedVolumePreferenceController { + + private static final String KEY_SEPARATE_RING_VOLUME = "separate_ring_volume"; + private static final String TAG = "SeparateRingVolumePreferenceController"; + + private final RingReceiver mReceiver = new RingReceiver(); + private final H mHandler = new H(); + + public SeparateRingVolumePreferenceController(Context context) { + this(context, KEY_SEPARATE_RING_VOLUME); + } + + public SeparateRingVolumePreferenceController(Context context, String key) { + super(context, key, TAG); + + mNormalIconId = R.drawable.ic_ring_volume; + mVibrateIconId = R.drawable.ic_volume_ringer_vibrate; + mSilentIconId = R.drawable.ic_ring_volume_off; + + mSeparateNotification = isSeparateNotificationConfigEnabled(); + updateRingerMode(); + } + + /** + * Show/hide settings + */ + private void onDeviceConfigChange(DeviceConfig.Properties properties) { + Set changeSet = properties.getKeyset(); + if (changeSet.contains(SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION)) { + boolean valueUpdated = readSeparateNotificationVolumeConfig(); + if (valueUpdated) { + updateEffectsSuppressor(); + selectPreferenceIconState(); + } + } + } + + @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) + @Override + public void onResume() { + super.onResume(); + mReceiver.register(true); + readSeparateNotificationVolumeConfig(); + DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_SYSTEMUI, + ActivityThread.currentApplication().getMainExecutor(), this::onDeviceConfigChange); + updateEffectsSuppressor(); + selectPreferenceIconState(); + + if (mPreference != null) { + mPreference.setVisible(getAvailabilityStatus() == AVAILABLE); + } + } + + @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) + @Override + public void onPause() { + super.onPause(); + mReceiver.register(false); + DeviceConfig.removeOnPropertiesChangedListener(this::onDeviceConfigChange); + } + + @Override + public String getPreferenceKey() { + return KEY_SEPARATE_RING_VOLUME; + } + + @Override + public int getAvailabilityStatus() { + boolean separateNotification = isSeparateNotificationConfigEnabled(); + + return separateNotification && Utils.isVoiceCapable(mContext) && !mHelper.isSingleVolume() + ? AVAILABLE : UNSUPPORTED_ON_DEVICE; + } + + @Override + public int getAudioStream() { + return AudioManager.STREAM_RING; + } + + @Override + protected boolean hintsMatch(int hints) { + return (hints & NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS) != 0 + || (hints & NotificationListenerService.HINT_HOST_DISABLE_EFFECTS) != 0; + } + + + + private final class H extends Handler { + private static final int UPDATE_EFFECTS_SUPPRESSOR = 1; + private static final int UPDATE_RINGER_MODE = 2; + + private H() { + super(Looper.getMainLooper()); + } + + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case UPDATE_EFFECTS_SUPPRESSOR: + updateEffectsSuppressor(); + break; + case UPDATE_RINGER_MODE: + updateRingerMode(); + break; + } + } + } + + private class RingReceiver extends BroadcastReceiver { + private boolean mRegistered; + + public void register(boolean register) { + if (mRegistered == register) return; + if (register) { + final IntentFilter filter = new IntentFilter(); + filter.addAction(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED); + filter.addAction(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION); + mContext.registerReceiver(this, filter); + } else { + mContext.unregisterReceiver(this); + } + mRegistered = register; + } + + @Override + public void onReceive(Context context, Intent intent) { + final String action = intent.getAction(); + if (NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED.equals(action)) { + mHandler.sendEmptyMessage(H.UPDATE_EFFECTS_SUPPRESSOR); + } else if (AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION.equals(action)) { + mHandler.sendEmptyMessage(H.UPDATE_RINGER_MODE); + } + } + } + +} diff --git a/src/com/android/settings/notification/SoundSettings.java b/src/com/android/settings/notification/SoundSettings.java index 2d6f3778ffc..2cc1b1c2591 100644 --- a/src/com/android/settings/notification/SoundSettings.java +++ b/src/com/android/settings/notification/SoundSettings.java @@ -188,6 +188,7 @@ public class SoundSettings extends DashboardFragment implements OnActivityResult volumeControllers.add(use(AlarmVolumePreferenceController.class)); volumeControllers.add(use(MediaVolumePreferenceController.class)); volumeControllers.add(use(RingVolumePreferenceController.class)); + volumeControllers.add(use(SeparateRingVolumePreferenceController.class)); volumeControllers.add(use(NotificationVolumePreferenceController.class)); volumeControllers.add(use(CallVolumePreferenceController.class)); diff --git a/src/com/android/settings/panel/PanelSlicesAdapter.java b/src/com/android/settings/panel/PanelSlicesAdapter.java index d7283667787..1bced76a6b7 100644 --- a/src/com/android/settings/panel/PanelSlicesAdapter.java +++ b/src/com/android/settings/panel/PanelSlicesAdapter.java @@ -54,7 +54,7 @@ public class PanelSlicesAdapter * Maximum number of slices allowed on the panel view. */ @VisibleForTesting - static final int MAX_NUM_OF_SLICES = 7; + static final int MAX_NUM_OF_SLICES = 9; private final List> mSliceLiveData; private final int mMetricsCategory; diff --git a/src/com/android/settings/panel/VolumePanel.java b/src/com/android/settings/panel/VolumePanel.java index 08884d5621f..938ee9d38aa 100644 --- a/src/com/android/settings/panel/VolumePanel.java +++ b/src/com/android/settings/panel/VolumePanel.java @@ -24,7 +24,9 @@ import static com.android.settings.slices.CustomSliceRegistry.REMOTE_MEDIA_SLICE import static com.android.settings.slices.CustomSliceRegistry.VOLUME_ALARM_URI; import static com.android.settings.slices.CustomSliceRegistry.VOLUME_CALL_URI; import static com.android.settings.slices.CustomSliceRegistry.VOLUME_MEDIA_URI; +import static com.android.settings.slices.CustomSliceRegistry.VOLUME_NOTIFICATION_URI; import static com.android.settings.slices.CustomSliceRegistry.VOLUME_RINGER_URI; +import static com.android.settings.slices.CustomSliceRegistry.VOLUME_SEPARATE_RING_URI; import android.app.Activity; import android.app.settings.SettingsEnums; @@ -125,6 +127,10 @@ public class VolumePanel implements PanelContent, LifecycleObserver { return mContext.getText(R.string.sound_settings); } + /** + * When considering ring and notification, we include all controllers unconditionally and rely + * on getAvailability to govern visibility + */ @Override public List getSlices() { final List uris = new ArrayList<>(); @@ -139,6 +145,8 @@ public class VolumePanel implements PanelContent, LifecycleObserver { uris.add(MEDIA_OUTPUT_INDICATOR_SLICE_URI); uris.add(VOLUME_CALL_URI); uris.add(VOLUME_RINGER_URI); + uris.add(VOLUME_SEPARATE_RING_URI); + uris.add(VOLUME_NOTIFICATION_URI); uris.add(VOLUME_ALARM_URI); return uris; } @@ -189,4 +197,4 @@ public class VolumePanel implements PanelContent, LifecycleObserver { } return null; } -} \ No newline at end of file +} diff --git a/src/com/android/settings/slices/CustomSliceRegistry.java b/src/com/android/settings/slices/CustomSliceRegistry.java index c49d6224859..c499823817c 100644 --- a/src/com/android/settings/slices/CustomSliceRegistry.java +++ b/src/com/android/settings/slices/CustomSliceRegistry.java @@ -196,7 +196,7 @@ public class CustomSliceRegistry { .build(); /** - * Full {@link Uri} for the Ringer volume Slice. + * Full {@link Uri} for the Ringer volume Slice. (Ring & notification combined) */ public static final Uri VOLUME_RINGER_URI = new Uri.Builder() .scheme(ContentResolver.SCHEME_CONTENT) @@ -205,6 +205,16 @@ public class CustomSliceRegistry { .appendPath("ring_volume") .build(); + /** + * Full {@link Uri} for the Separate Ring volume Slice. + */ + public static final Uri VOLUME_SEPARATE_RING_URI = new Uri.Builder() + .scheme(ContentResolver.SCHEME_CONTENT) + .authority(SettingsSliceProvider.SLICE_AUTHORITY) + .appendPath(SettingsSlicesContract.PATH_SETTING_ACTION) + .appendPath("separate_ring_volume") + .build(); + /** * Full {@link Uri} for the Notification volume Slice. */ diff --git a/tests/robotests/src/com/android/settings/notification/RingVolumePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/RingVolumePreferenceControllerTest.java index 1ad26c71546..07e599371c7 100644 --- a/tests/robotests/src/com/android/settings/notification/RingVolumePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/RingVolumePreferenceControllerTest.java @@ -32,7 +32,7 @@ import android.service.notification.NotificationListenerService; import android.telephony.TelephonyManager; import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; -import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; import com.android.settings.testutils.shadow.ShadowDeviceConfig; import org.junit.Before; @@ -83,6 +83,9 @@ public class RingVolumePreferenceControllerTest { when(mContext.getResources()).thenReturn(mResources); mController = new RingVolumePreferenceController(mContext); mController.setAudioHelper(mHelper); + + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "false", false); } @Test @@ -103,6 +106,7 @@ public class RingVolumePreferenceControllerTest { @Test public void isAvailable_notSingleVolume_VoiceCapable_shouldReturnTrue() { + when(mHelper.isSingleVolume()).thenReturn(false); when(mTelephonyManager.isVoiceCapable()).thenReturn(true); @@ -126,9 +130,11 @@ public class RingVolumePreferenceControllerTest { assertThat(mController.isPublicSlice()).isTrue(); } - // todo: verify that the title change is displayed, by examining the underlying preference + /** + * Only when the two streams are merged would this controller appear + */ @Test - public void ringNotificationStreamsNotAliased_sliderTitleSetToRingOnly() { + public void ringNotificationStreamsSeparate_controllerIsNotAvailable() { DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "true", false); @@ -136,60 +142,68 @@ public class RingVolumePreferenceControllerTest { final RingVolumePreferenceController controller = new RingVolumePreferenceController(mContext); - int expectedTitleId = R.string.separate_ring_volume_option_title; + int controllerAvailability = controller.getAvailabilityStatus(); - assertThat(controller.mTitleId).isEqualTo(expectedTitleId); - } - - @Test - public void ringNotificationStreamsAliased_sliderTitleIncludesBothRingNotification() { - - DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "false", false); - - final RingVolumePreferenceController control = new RingVolumePreferenceController(mContext); - - int expectedTitleId = R.string.ring_volume_option_title; - - assertThat(control.mTitleId).isEqualTo(expectedTitleId); + assertThat(controllerAvailability) + .isNotEqualTo(BasePreferenceController.AVAILABLE); } @Test public void setHintsRing_aliased_Matches() { + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "false", false); + + assertThat(mController.hintsMatch( - NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS, false)).isTrue(); + NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS)).isTrue(); } @Test public void setHintsRingNotification_aliased_Matches() { - assertThat(mController.hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_EFFECTS, - false)).isTrue(); + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "false", false); + + assertThat(mController.hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_EFFECTS)) + .isTrue(); } @Test public void setHintNotification_aliased_Matches() { + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "false", false); + + assertThat(mController - .hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS, - false)).isTrue(); + .hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS)) + .isTrue(); } @Test public void setHintsRing_unaliased_Matches() { + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "true", false); + assertThat(mController.hintsMatch( - NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS, true)).isTrue(); + NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS)).isTrue(); } @Test public void setHintsRingNotification_unaliased_Matches() { - assertThat(mController.hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_EFFECTS, - true)).isTrue(); + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "true", false); + + assertThat(mController.hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_EFFECTS)) + .isTrue(); } @Test public void setHintNotification_unaliased_doesNotMatch() { + DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.VOLUME_SEPARATE_NOTIFICATION, "true", false); + assertThat(mController - .hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS, - true)).isFalse(); + .hintsMatch(NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS)) + .isFalse(); } @Test diff --git a/tests/robotests/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceControllerTest.java new file mode 100644 index 00000000000..d001653474f --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/RingerModeAffectedVolumePreferenceControllerTest.java @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2022 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 static com.google.common.truth.Truth.assertThat; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.robolectric.RobolectricTestRunner; + +@RunWith(RobolectricTestRunner.class) +public class RingerModeAffectedVolumePreferenceControllerTest { + + private RingerModeAffectedVolumePreferenceController mController; + + @Before + public void setUp() { + mController = Mockito.mock( + RingerModeAffectedVolumePreferenceController.class, + Mockito.CALLS_REAL_METHODS); + } + + @Test + public void isSliceable_returnsTrue() { + assertThat(mController.isSliceable()).isTrue(); + } + + @Test + public void isPublicSlice_returnsTrue() { + assertThat(mController.isPublicSlice()).isTrue(); + } + +} diff --git a/tests/robotests/src/com/android/settings/notification/SeparateRingVolumePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/SeparateRingVolumePreferenceControllerTest.java new file mode 100644 index 00000000000..88c8ff9887d --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/SeparateRingVolumePreferenceControllerTest.java @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2022 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 static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.app.NotificationManager; +import android.content.ComponentName; +import android.content.Context; +import android.content.res.Resources; +import android.media.AudioManager; +import android.os.Vibrator; +import android.telephony.TelephonyManager; + +import com.android.settings.testutils.shadow.ShadowDeviceConfig; + +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 org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; + +@RunWith(RobolectricTestRunner.class) +@Config(shadows = {ShadowDeviceConfig.class}) +public class SeparateRingVolumePreferenceControllerTest { + + @Mock + private AudioHelper mHelper; + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private AudioManager mAudioManager; + @Mock + private Vibrator mVibrator; + @Mock + private NotificationManager mNotificationManager; + @Mock + private ComponentName mSuppressor; + @Mock + private Resources mResources; + + private Context mContext; + + private SeparateRingVolumePreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + ShadowApplication shadowContext = ShadowApplication.getInstance(); + shadowContext.setSystemService(Context.TELEPHONY_SERVICE, mTelephonyManager); + shadowContext.setSystemService(Context.AUDIO_SERVICE, mAudioManager); + shadowContext.setSystemService(Context.VIBRATOR_SERVICE, mVibrator); + shadowContext.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager); + mContext = spy(RuntimeEnvironment.application); + when(mNotificationManager.getEffectsSuppressor()).thenReturn(mSuppressor); + when(mContext.getResources()).thenReturn(mResources); + mController = new SeparateRingVolumePreferenceController(mContext); + mController.setAudioHelper(mHelper); + } + + @Test + public void isAvailable_ringNotificationAliased_shouldReturnFalse() { + when(mHelper.isSingleVolume()).thenReturn(true); + when(mTelephonyManager.isVoiceCapable()).thenReturn(true); + + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void getAudioStream_shouldReturnRing() { + assertThat(mController.getAudioStream()).isEqualTo(AudioManager.STREAM_RING); + } + + @Test + public void isSliceableCorrectKey_returnsTrue() { + final SeparateRingVolumePreferenceController controller = + new SeparateRingVolumePreferenceController(mContext); + assertThat(controller.isSliceable()).isTrue(); + } + + @Test + public void isPublicSlice_returnTrue() { + assertThat(mController.isPublicSlice()).isTrue(); + } + +} diff --git a/tests/robotests/src/com/android/settings/panel/VolumePanelTest.java b/tests/robotests/src/com/android/settings/panel/VolumePanelTest.java index 6c0e131e2e0..74998c9e91d 100644 --- a/tests/robotests/src/com/android/settings/panel/VolumePanelTest.java +++ b/tests/robotests/src/com/android/settings/panel/VolumePanelTest.java @@ -63,6 +63,8 @@ public class VolumePanelTest { CustomSliceRegistry.VOLUME_MEDIA_URI, CustomSliceRegistry.MEDIA_OUTPUT_INDICATOR_SLICE_URI, CustomSliceRegistry.VOLUME_RINGER_URI, + CustomSliceRegistry.VOLUME_SEPARATE_RING_URI, + CustomSliceRegistry.VOLUME_NOTIFICATION_URI, CustomSliceRegistry.VOLUME_ALARM_URI); } From e81d98cc089c467a3be7718ab45c5d82d3a1a115 Mon Sep 17 00:00:00 2001 From: Sorin Basca Date: Tue, 5 Jul 2022 18:37:05 +0100 Subject: [PATCH 2/9] Use Mockito 4.6.1 API Bug: 236636175 Test: atest SettingsRoboTests Change-Id: I2cfda684059520f6ddd1e72c55f1ab1ec9c99e8b Merged-In: I2cfda684059520f6ddd1e72c55f1ab1ec9c99e8b --- color-check-baseline.xml | 224 ++++++++++++++++++ ...ithAdminGrantedPermissionsCounterTest.java | 28 +-- ...WithAdminGrantedPermissionsListerTest.java | 26 +- .../applications/InstalledAppListerTest.java | 10 +- ...cialAppAccessPreferenceControllerTest.java | 2 +- ...DefaultAssistPreferenceControllerTest.java | 4 +- .../FingerprintEnrollEnrollingTest.java | 6 +- .../FingerprintEnrollFindSensorTest.java | 2 +- .../BluetoothDeviceDetailsFragmentTest.java | 2 +- .../DashboardFeatureProviderImplTest.java | 4 +- .../settings/datausage/AppDataUsageTest.java | 10 +- .../datausage/BillingCycleSettingsTest.java | 17 +- .../datausage/lib/DataUsageLibTest.java | 2 +- ...ZoneDetectionPreferenceControllerTest.java | 4 +- ...ModuleVersionPreferenceControllerTest.java | 4 +- ...rmissionsPreferenceControllerTestBase.java | 6 +- ...alledPackagesPreferenceControllerTest.java | 4 +- .../AdvancedPowerUsageDetailTest.java | 9 +- ...atteryAppListPreferenceControllerTest.java | 2 +- .../fuelgauge/BatteryBackupHelperTest.java | 10 +- .../BatteryChartPreferenceControllerTest.java | 13 +- .../fuelgauge/BatteryDiffEntryTest.java | 2 +- ...BatteryHeaderPreferenceControllerTest.java | 6 +- .../fuelgauge/BatteryOptimizeUtilsTest.java | 10 +- .../TetherPreferenceControllerTest.java | 7 +- ...utomaticRulesPreferenceControllerTest.java | 17 +- ...ConversationsPreferenceControllerTest.java | 4 +- ...ioritySendersPreferenceControllerTest.java | 4 +- ...arredContactsPreferenceControllerTest.java | 2 +- ...intJobMessagePreferenceControllerTest.java | 10 +- .../PrintJobPreferenceControllerTest.java | 6 +- .../actionbar/SearchMenuControllerTest.java | 8 +- ...ghlightablePreferenceGroupAdapterTest.java | 8 +- .../NetworkRequestDialogFragmentTest.java | 2 +- .../DisclaimerItemListAdapterTest.java | 8 +- ...EmergencyCallLimitationDisclaimerTest.java | 4 +- .../calling/LocationPolicyDisclaimerTest.java | 4 +- .../WifiCallingDisclaimerFragmentTest.java | 9 +- .../WifiCallingSettingsForSubTest.java | 11 +- .../WifiDetailPreferenceController2Test.java | 12 +- 40 files changed, 374 insertions(+), 149 deletions(-) diff --git a/color-check-baseline.xml b/color-check-baseline.xml index edd2d59be96..9eab06a55d5 100644 --- a/color-check-baseline.xml +++ b/color-check-baseline.xml @@ -525,6 +525,86 @@ column="5"/> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java index 4e08f9841df..71c532c7e2f 100644 --- a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java +++ b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java @@ -20,10 +20,10 @@ import static com.android.settings.testutils.ApplicationTestUtils.buildInfo; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyObject; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; @@ -39,7 +39,6 @@ import android.os.RemoteException; import android.os.UserHandle; import android.os.UserManager; -import java.util.Collections; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -49,6 +48,7 @@ import org.robolectric.RobolectricTestRunner; import org.robolectric.shadows.ShadowApplication; import java.util.Arrays; +import java.util.Collections; @RunWith(RobolectricTestRunner.class) public final class AppWithAdminGrantedPermissionsCounterTest { @@ -129,7 +129,7 @@ public final class AppWithAdminGrantedPermissionsCounterTest { verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MAIN_USER_ID)); verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MANAGED_PROFILE_ID)); - verify(mPackageManager, atLeast(0)).getInstallReason(anyObject(), anyObject()); + verify(mPackageManager, atLeast(0)).getInstallReason(any(), any()); verifyNoMoreInteractions(mPackageManager); } @@ -166,9 +166,9 @@ public final class AppWithAdminGrantedPermissionsCounterTest { } private void configureInstallTimePermissions() throws RemoteException { - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_1_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_1_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_2_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_2_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); when(mPackageManagerService.checkUidPermission(PERMISSION_1, APP_3_UID)) .thenReturn(PackageManager.PERMISSION_DENIED); @@ -178,9 +178,9 @@ public final class AppWithAdminGrantedPermissionsCounterTest { .thenReturn(PackageManager.PERMISSION_DENIED); when(mPackageManagerService.checkUidPermission(PERMISSION_2, APP_4_UID)) .thenReturn(PackageManager.PERMISSION_GRANTED); - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_5_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_5_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_6_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_6_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); } @@ -189,15 +189,15 @@ public final class AppWithAdminGrantedPermissionsCounterTest { .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED); when(mDevicePolicyManager.getPermissionGrantState(null, APP_1, PERMISSION_2)) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_2), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_2), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_3), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_3), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_4), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_4), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_5), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_5), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_6), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_6), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED); } diff --git a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsListerTest.java b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsListerTest.java index a8186373d38..9a4978b9d6e 100644 --- a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsListerTest.java +++ b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsListerTest.java @@ -20,10 +20,10 @@ import static com.android.settings.testutils.ApplicationTestUtils.buildInfo; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyObject; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; @@ -122,19 +122,19 @@ public final class AppWithAdminGrantedPermissionsListerTest { .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED); when(mDevicePolicyManager.getPermissionGrantState(null, APP_1, PERMISSION_2)) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_2), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_2), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_3), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_3), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_4), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_4), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_5), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_5), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED); // Grant install-time permissions as appropriate. - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_1_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_1_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_2_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_2_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); when(mPackageManagerService.checkUidPermission(PERMISSION_1, APP_3_UID)) .thenReturn(PackageManager.PERMISSION_DENIED); @@ -144,7 +144,7 @@ public final class AppWithAdminGrantedPermissionsListerTest { .thenReturn(PackageManager.PERMISSION_DENIED); when(mPackageManagerService.checkUidPermission(PERMISSION_2, APP_4_UID)) .thenReturn(PackageManager.PERMISSION_GRANTED); - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_5_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_5_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); // app3 and app5 were installed by enterprise policy. @@ -168,11 +168,11 @@ public final class AppWithAdminGrantedPermissionsListerTest { buildInfo(APP_6_UID, APP_6, 0 /* flags */, Build.VERSION_CODES.M))); // Grant run-time permissions as appropriate. - when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_6), anyObject())) + when(mDevicePolicyManager.getPermissionGrantState(eq(null), eq(APP_6), any())) .thenReturn(DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED); // Grant install-time permissions as appropriate. - when(mPackageManagerService.checkUidPermission(anyObject(), eq(APP_6_UID))) + when(mPackageManagerService.checkUidPermission(any(), eq(APP_6_UID))) .thenReturn(PackageManager.PERMISSION_DENIED); // app6 was not installed by enterprise policy. @@ -202,7 +202,7 @@ public final class AppWithAdminGrantedPermissionsListerTest { verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MAIN_USER_ID)); verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MANAGED_PROFILE_ID)); - verify(mPackageManager, atLeast(0)).getInstallReason(anyObject(), anyObject()); + verify(mPackageManager, atLeast(0)).getInstallReason(any(), any()); verifyNoMoreInteractions(mPackageManager); } diff --git a/tests/robotests/src/com/android/settings/applications/InstalledAppListerTest.java b/tests/robotests/src/com/android/settings/applications/InstalledAppListerTest.java index e2aed368f80..602d678c9d8 100644 --- a/tests/robotests/src/com/android/settings/applications/InstalledAppListerTest.java +++ b/tests/robotests/src/com/android/settings/applications/InstalledAppListerTest.java @@ -20,11 +20,11 @@ import static com.android.settings.testutils.ApplicationTestUtils.buildInfo; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyObject; -import static org.mockito.ArgumentMatchers.argThat; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.argThat; import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -170,7 +170,7 @@ public final class InstalledAppListerTest { verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MAIN_USER_ID)); verify(mPackageManager).getInstalledApplicationsAsUser(anyInt(), eq(MANAGED_PROFILE_ID)); verify(mPackageManager, atLeast(0)) - .queryIntentActivitiesAsUser(anyObject(), anyInt(), anyInt()); + .queryIntentActivitiesAsUser(any(), anyInt(), anyInt()); } public static boolean checkAppFound(List mInstalledAppList, String appId, diff --git a/tests/robotests/src/com/android/settings/applications/SpecialAppAccessPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/SpecialAppAccessPreferenceControllerTest.java index e0a08364a8c..da5ada783ad 100644 --- a/tests/robotests/src/com/android/settings/applications/SpecialAppAccessPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/SpecialAppAccessPreferenceControllerTest.java @@ -20,7 +20,7 @@ import static com.android.settings.core.BasePreferenceController.AVAILABLE; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; diff --git a/tests/robotests/src/com/android/settings/applications/assist/DefaultAssistPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/assist/DefaultAssistPreferenceControllerTest.java index 3e46027c362..178a26f8453 100644 --- a/tests/robotests/src/com/android/settings/applications/assist/DefaultAssistPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/assist/DefaultAssistPreferenceControllerTest.java @@ -24,7 +24,7 @@ import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.Manifest; @@ -142,6 +142,6 @@ public class DefaultAssistPreferenceControllerTest { controller.getSettingIntent(null); - verifyZeroInteractions(assistUtils); + verifyNoInteractions(assistUtils); } } diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrollingTest.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrollingTest.java index a7b7e85d063..24c2123dfdf 100644 --- a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrollingTest.java +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollEnrollingTest.java @@ -18,9 +18,9 @@ package com.android.settings.biometrics.fingerprint; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.verify; import android.content.Intent; diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollFindSensorTest.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollFindSensorTest.java index 55f0210dad4..95d3b7e3bab 100644 --- a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollFindSensorTest.java +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintEnrollFindSensorTest.java @@ -21,7 +21,7 @@ import static com.google.common.truth.Truth.assertWithMessage; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.verify; import static org.robolectric.RuntimeEnvironment.application; diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java index fac8b584f0a..81f485986b9 100644 --- a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java +++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java @@ -21,8 +21,8 @@ import static android.bluetooth.BluetoothDevice.BOND_NONE; import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Matchers.eq; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/dashboard/DashboardFeatureProviderImplTest.java index f2b0acddbed..37b8ab630fb 100644 --- a/tests/robotests/src/com/android/settings/dashboard/DashboardFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/dashboard/DashboardFeatureProviderImplTest.java @@ -40,7 +40,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.content.Context; @@ -268,7 +268,7 @@ public class DashboardFeatureProviderImplTest { mImpl.bindPreferenceToTileAndGetObservers(mActivity, mFragment, mForceRoundedIcon, null /* keys */, tile, "123", Preference.DEFAULT_ORDER); - verifyZeroInteractions(tile); + verifyNoInteractions(tile); } @Test diff --git a/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java b/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java index 483d74638a7..47db4f29506 100644 --- a/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java +++ b/tests/robotests/src/com/android/settings/datausage/AppDataUsageTest.java @@ -19,14 +19,14 @@ package com.android.settings.datausage; import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyBoolean; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Matchers.eq; import static org.mockito.Mockito.RETURNS_DEEP_STUBS; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyBoolean; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; diff --git a/tests/robotests/src/com/android/settings/datausage/BillingCycleSettingsTest.java b/tests/robotests/src/com/android/settings/datausage/BillingCycleSettingsTest.java index 861b4e395fa..cef5928c717 100644 --- a/tests/robotests/src/com/android/settings/datausage/BillingCycleSettingsTest.java +++ b/tests/robotests/src/com/android/settings/datausage/BillingCycleSettingsTest.java @@ -19,16 +19,15 @@ import static android.net.NetworkPolicy.CYCLE_NONE; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyLong; -import static org.mockito.ArgumentMatchers.anyObject; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyLong; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; +import static org.mockito.Mockito.nullable; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -133,9 +132,9 @@ public class BillingCycleSettingsTest { mDataLimit, mDataWarning, mEnableDataLimit, mEnableDataWarning); doReturn("some-string").when(billingCycleSettings).getString(anyInt(), anyInt()); - when(mNetworkPolicyEditor.getPolicyCycleDay(anyObject())).thenReturn(CYCLE_NONE + 1); - when(mNetworkPolicyEditor.getPolicyLimitBytes(anyObject())).thenReturn(2000L); - when(mNetworkPolicyEditor.getPolicyWarningBytes(anyObject())).thenReturn(1000L); + when(mNetworkPolicyEditor.getPolicyCycleDay(any())).thenReturn(CYCLE_NONE + 1); + when(mNetworkPolicyEditor.getPolicyLimitBytes(any())).thenReturn(2000L); + when(mNetworkPolicyEditor.getPolicyWarningBytes(any())).thenReturn(1000L); billingCycleSettings.updatePrefs(); diff --git a/tests/robotests/src/com/android/settings/datausage/lib/DataUsageLibTest.java b/tests/robotests/src/com/android/settings/datausage/lib/DataUsageLibTest.java index 70a1a38fa0e..4391425d2ba 100644 --- a/tests/robotests/src/com/android/settings/datausage/lib/DataUsageLibTest.java +++ b/tests/robotests/src/com/android/settings/datausage/lib/DataUsageLibTest.java @@ -18,7 +18,7 @@ package com.android.settings.datausage.lib; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/datetime/LocationTimeZoneDetectionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/LocationTimeZoneDetectionPreferenceControllerTest.java index b9c4edc9af2..9fb364ed62e 100644 --- a/tests/robotests/src/com/android/settings/datetime/LocationTimeZoneDetectionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datetime/LocationTimeZoneDetectionPreferenceControllerTest.java @@ -24,7 +24,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.app.time.Capabilities; @@ -99,7 +99,7 @@ public class LocationTimeZoneDetectionPreferenceControllerTest { mController.setChecked(true); // Verify the TimeManager was not called. - verifyZeroInteractions(mTimeManager); + verifyNoInteractions(mTimeManager); } @Test diff --git a/tests/robotests/src/com/android/settings/deviceinfo/firmwareversion/MainlineModuleVersionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/firmwareversion/MainlineModuleVersionPreferenceControllerTest.java index 3f49b15b634..35e044cc2f3 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/firmwareversion/MainlineModuleVersionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/firmwareversion/MainlineModuleVersionPreferenceControllerTest.java @@ -23,8 +23,8 @@ import static com.android.settings.deviceinfo.firmwareversion.MainlineModuleVers import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java index 09d1c84f994..06e41073716 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java @@ -18,10 +18,10 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyObject; -import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.any; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -79,7 +79,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase { } }).when(mFeatureFactory.applicationFeatureProvider) .calculateNumberOfAppsWithAdminGrantedPermissions(eq(mPermissions), - eq(async), anyObject()); + eq(async), any()); } @Test diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java index f39b4b8821b..c32d2d79256 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java @@ -18,7 +18,7 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.anyObject; +import static org.mockito.Mockito.any; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.eq; @@ -74,7 +74,7 @@ public class EnterpriseInstalledPackagesPreferenceControllerTest { return null; } }).when(mFeatureFactory.applicationFeatureProvider) - .calculateNumberOfPolicyInstalledApps(eq(async), anyObject()); + .calculateNumberOfPolicyInstalledApps(eq(async), any()); } @Test diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java index 269c810f852..39f2ce5f314 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java @@ -30,7 +30,7 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.app.AppOpsManager; @@ -45,7 +45,6 @@ import android.os.BatteryStats; import android.os.Bundle; import android.os.Process; import android.os.UserHandle; -import android.util.Pair; import androidx.fragment.app.FragmentActivity; import androidx.loader.app.LoaderManager; @@ -858,7 +857,7 @@ public class AdvancedPowerUsageDetailTest { mFragment.onRadioButtonClicked(mOptimizePreference); mFragment.onPause(); - verifyZeroInteractions(mMetricsFeatureProvider); + verifyNoInteractions(mMetricsFeatureProvider); } @Test @@ -869,7 +868,7 @@ public class AdvancedPowerUsageDetailTest { mFragment.notifyBackupManager(); - verifyZeroInteractions(mBackupManager); + verifyNoInteractions(mBackupManager); } @Test @@ -892,6 +891,6 @@ public class AdvancedPowerUsageDetailTest { mFragment.onPause(); - verifyZeroInteractions(mBackupManager); + verifyNoInteractions(mBackupManager); } } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java index 46773c96622..406fe8ad29a 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java @@ -18,7 +18,7 @@ package com.android.settings.fuelgauge; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java index ca1797ac9e9..256b621e60e 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryBackupHelperTest.java @@ -33,7 +33,7 @@ import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import android.app.AppOpsManager; import android.app.backup.BackupDataInputStream; @@ -251,7 +251,7 @@ public final class BatteryBackupHelperTest { mBatteryBackupHelper.restoreEntity(mBackupDataInputStream); - verifyZeroInteractions(mBackupDataInputStream); + verifyNoInteractions(mBackupDataInputStream); } @Test @@ -289,13 +289,13 @@ public final class BatteryBackupHelperTest { @Test public void restoreOptimizationMode_nullBytesData_skipRestore() throws Exception { mBatteryBackupHelper.restoreOptimizationMode(new byte[0]); - verifyZeroInteractions(mBatteryOptimizeUtils); + verifyNoInteractions(mBatteryOptimizeUtils); mBatteryBackupHelper.restoreOptimizationMode("invalid data format".getBytes()); - verifyZeroInteractions(mBatteryOptimizeUtils); + verifyNoInteractions(mBatteryOptimizeUtils); mBatteryBackupHelper.restoreOptimizationMode(DELIMITER.getBytes()); - verifyZeroInteractions(mBatteryOptimizeUtils); + verifyNoInteractions(mBatteryOptimizeUtils); } @Test diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryChartPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryChartPreferenceControllerTest.java index 1d74491a0e1..3f54270ce26 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryChartPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryChartPreferenceControllerTest.java @@ -18,18 +18,16 @@ package com.android.settings.fuelgauge; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyLong; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyLong; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; import android.app.settings.SettingsEnums; -import android.content.Context; import android.content.ContentValues; +import android.content.Context; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.content.res.Resources; @@ -37,13 +35,11 @@ import android.graphics.drawable.Drawable; import android.os.Bundle; import android.os.LocaleList; import android.text.format.DateUtils; -import android.util.Pair; import androidx.preference.Preference; import androidx.preference.PreferenceCategory; import androidx.preference.PreferenceGroup; -import com.android.settings.R; import com.android.settings.SettingsActivity; import com.android.settings.core.InstrumentedPreferenceFragment; import com.android.settings.testutils.FakeFeatureFactory; @@ -58,11 +54,10 @@ import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; -import java.util.Arrays; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.Locale; -import java.util.List; import java.util.Map; @RunWith(RobolectricTestRunner.class) diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java index 6ea13901eef..e69d565f8b1 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java @@ -19,7 +19,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Matchers.anyInt; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryHeaderPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryHeaderPreferenceControllerTest.java index 6389dc95fe1..78534e138f0 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryHeaderPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryHeaderPreferenceControllerTest.java @@ -23,7 +23,7 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.app.Activity; @@ -267,7 +267,7 @@ public class BatteryHeaderPreferenceControllerTest { mController.updateHeaderByBatteryTips(null, mBatteryInfo); - verifyZeroInteractions(mBatteryUsageProgressBarPref); + verifyNoInteractions(mBatteryUsageProgressBarPref); } @Test @@ -277,7 +277,7 @@ public class BatteryHeaderPreferenceControllerTest { mController.updateHeaderByBatteryTips(lowBatteryTip, null); - verifyZeroInteractions(mBatteryUsageProgressBarPref); + verifyNoInteractions(mBatteryUsageProgressBarPref); } @Test diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java index c154f426b30..db58b630e65 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java @@ -22,11 +22,11 @@ import static com.android.settings.fuelgauge.BatteryOptimizeUtils.MODE_UNRESTRIC import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.app.AppOpsManager; @@ -169,7 +169,7 @@ public class BatteryOptimizeUtilsTest { mBatteryOptimizeUtils.setAppUsageState(MODE_UNRESTRICTED); TimeUnit.SECONDS.sleep(1); - verifyZeroInteractions(mMockBackend); - verifyZeroInteractions(mMockBatteryUtils); + verifyNoInteractions(mMockBackend); + verifyNoInteractions(mMockBatteryUtils); } } diff --git a/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java index bafc021d9b2..9aa79ff4db6 100644 --- a/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java @@ -16,16 +16,15 @@ package com.android.settings.network; -import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.any; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.verifyZeroInteractions; import static org.mockito.Mockito.when; -import android.app.admin.DevicePolicyManager; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothPan; import android.bluetooth.BluetoothProfile; @@ -162,7 +161,7 @@ public class TetherPreferenceControllerTest { mController.onResume(); - verifyZeroInteractions(mPreference); + verifyNoInteractions(mPreference); Settings.Global.putInt(context.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 1); diff --git a/tests/robotests/src/com/android/settings/notification/zen/ZenModeAutomaticRulesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/zen/ZenModeAutomaticRulesPreferenceControllerTest.java index 1660955e323..3791c23193e 100644 --- a/tests/robotests/src/com/android/settings/notification/zen/ZenModeAutomaticRulesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/zen/ZenModeAutomaticRulesPreferenceControllerTest.java @@ -18,6 +18,7 @@ package com.android.settings.notification.zen; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.doReturn; @@ -42,10 +43,10 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.mockito.internal.util.reflection.FieldSetter; import org.robolectric.RobolectricTestRunner; import org.robolectric.util.ReflectionHelpers; +import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; @@ -192,16 +193,26 @@ public class ZenModeAutomaticRulesPreferenceControllerTest { rule.setEnabled(false); rMap.put(testId, rule); mockGetAutomaticZenRules(NUM_RULES, rMap); - FieldSetter.setField(mZenRulePreference, ZenRulePreference.class.getDeclaredField("mId"), testId); + setZenRulePreferenceField("mId", testId); mController.updateState(mockPref); verify(mZenRulePreference, times(1)).updatePreference(any()); verify(mockPref, never()).removeAll(); assertEquals(NUM_RULES, mController.mZenRulePreferences.size()); } + private void setZenRulePreferenceField(String name, Object value) { + try { + Field field = ZenRulePreference.class.getDeclaredField("mId"); + field.setAccessible(true); + field.set(mZenRulePreference, value); + } catch (ReflectiveOperationException e) { + fail("Unable to set mZenRulePreference field: " + name); + } + } + private void mockGetAutomaticZenRules(int numRules, Map rules) { Map.Entry[] arr = new Map.Entry[numRules]; rules.entrySet().toArray(arr); when(mBackend.getAutomaticZenRules()).thenReturn(arr); } -} \ No newline at end of file +} diff --git a/tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceControllerTest.java index 6bf0538c33b..d5834f932c3 100644 --- a/tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceControllerTest.java @@ -26,7 +26,7 @@ import static com.android.settings.notification.zen.ZenModePriorityConversations import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.any; +import static org.mockito.Mockito.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.reset; @@ -146,4 +146,4 @@ public class ZenModePriorityConversationsPreferenceControllerTest { } return null; } -} \ No newline at end of file +} diff --git a/tests/robotests/src/com/android/settings/notification/zen/ZenModePrioritySendersPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/zen/ZenModePrioritySendersPreferenceControllerTest.java index 99fa8e6cdd4..c431c5332ab 100644 --- a/tests/robotests/src/com/android/settings/notification/zen/ZenModePrioritySendersPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/zen/ZenModePrioritySendersPreferenceControllerTest.java @@ -30,8 +30,8 @@ import static com.android.settings.notification.zen.ZenPrioritySendersHelper.KEY import static com.android.settings.notification.zen.ZenPrioritySendersHelper.KEY_NONE; import static com.android.settings.notification.zen.ZenPrioritySendersHelper.UNKNOWN; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Matchers.any; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; diff --git a/tests/robotests/src/com/android/settings/notification/zen/ZenRuleStarredContactsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/zen/ZenRuleStarredContactsPreferenceControllerTest.java index 2f7dfe7f9b8..01f3dfabcb3 100644 --- a/tests/robotests/src/com/android/settings/notification/zen/ZenRuleStarredContactsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/zen/ZenRuleStarredContactsPreferenceControllerTest.java @@ -18,7 +18,7 @@ package com.android.settings.notification.zen; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.any; +import static org.mockito.Mockito.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/print/PrintJobMessagePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/print/PrintJobMessagePreferenceControllerTest.java index 96036d52755..b5d07cc5231 100644 --- a/tests/robotests/src/com/android/settings/print/PrintJobMessagePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/print/PrintJobMessagePreferenceControllerTest.java @@ -21,8 +21,8 @@ import static androidx.lifecycle.Lifecycle.Event.ON_STOP; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyObject; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -72,7 +72,7 @@ public class PrintJobMessagePreferenceControllerTest { mPreference = new Preference(mContext); when(mContext.getSystemService(Context.PRINT_SERVICE)).thenReturn(mPrintManager); when(mPrintManager.getGlobalPrintManagerForUser(anyInt())).thenReturn(mPrintManager); - when(mPrintManager.getPrintJob(anyObject())).thenReturn(mPrintJob); + when(mPrintManager.getPrintJob(any())).thenReturn(mPrintJob); when(mPrintJob.getInfo()).thenReturn(mPrintJobInfo); mController = new PrintJobMessagePreferenceController(mContext, PREF_KEY); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); @@ -93,7 +93,7 @@ public class PrintJobMessagePreferenceControllerTest { @Test public void updateUi_visiblePreference() { - when(mPrintJobInfo.getStatus(anyObject())).thenReturn("TestPrint"); + when(mPrintJobInfo.getStatus(any())).thenReturn("TestPrint"); mLifecycle.handleLifecycleEvent(ON_START); assertThat(mPreference.isVisible()).isTrue(); @@ -103,7 +103,7 @@ public class PrintJobMessagePreferenceControllerTest { @Test public void updateUi_invisiblePreference() { - when(mPrintJobInfo.getStatus(anyObject())).thenReturn(null); + when(mPrintJobInfo.getStatus(any())).thenReturn(null); mLifecycle.handleLifecycleEvent(ON_START); assertThat(mPreference.isVisible()).isFalse(); diff --git a/tests/robotests/src/com/android/settings/print/PrintJobPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/print/PrintJobPreferenceControllerTest.java index 09c5bf368af..da4d58c757b 100644 --- a/tests/robotests/src/com/android/settings/print/PrintJobPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/print/PrintJobPreferenceControllerTest.java @@ -21,8 +21,8 @@ import static androidx.lifecycle.Lifecycle.Event.ON_STOP; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.anyObject; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -75,7 +75,7 @@ public class PrintJobPreferenceControllerTest { mTestLabel = "PrintTest"; when(mContext.getSystemService(Context.PRINT_SERVICE)).thenReturn(mPrintManager); when(mPrintManager.getGlobalPrintManagerForUser(anyInt())).thenReturn(mPrintManager); - when(mPrintManager.getPrintJob(anyObject())).thenReturn(mPrintJob); + when(mPrintManager.getPrintJob(any())).thenReturn(mPrintJob); when(mPrintJob.getInfo()).thenReturn(mPrintJobInfo); mController = new PrintJobPreferenceController(mContext, PREF_KEY); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); diff --git a/tests/robotests/src/com/android/settings/search/actionbar/SearchMenuControllerTest.java b/tests/robotests/src/com/android/settings/search/actionbar/SearchMenuControllerTest.java index c646a935192..2a7bd29a964 100644 --- a/tests/robotests/src/com/android/settings/search/actionbar/SearchMenuControllerTest.java +++ b/tests/robotests/src/com/android/settings/search/actionbar/SearchMenuControllerTest.java @@ -21,7 +21,7 @@ import static com.android.settings.search.actionbar.SearchMenuController.MENU_SE import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.app.settings.SettingsEnums; @@ -91,7 +91,7 @@ public class SearchMenuControllerTest { SearchMenuController.init(mHost); mHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */); - verifyZeroInteractions(mMenu); + verifyNoInteractions(mMenu); } @Test @@ -100,7 +100,7 @@ public class SearchMenuControllerTest { SearchMenuController.init(mHost); mHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */); - verifyZeroInteractions(mMenu); + verifyNoInteractions(mMenu); } @Test @@ -112,6 +112,6 @@ public class SearchMenuControllerTest { mHost.getSettingsLifecycle().onCreateOptionsMenu(mMenu, null /* inflater */); - verifyZeroInteractions(mMenu); + verifyNoInteractions(mMenu); } } diff --git a/tests/robotests/src/com/android/settings/widget/HighlightablePreferenceGroupAdapterTest.java b/tests/robotests/src/com/android/settings/widget/HighlightablePreferenceGroupAdapterTest.java index 62c7bd8091c..e297b788af9 100644 --- a/tests/robotests/src/com/android/settings/widget/HighlightablePreferenceGroupAdapterTest.java +++ b/tests/robotests/src/com/android/settings/widget/HighlightablePreferenceGroupAdapterTest.java @@ -26,7 +26,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import android.content.Context; @@ -111,7 +111,7 @@ public class HighlightablePreferenceGroupAdapterTest { ReflectionHelpers.setField(mAdapter, "mHighlightRequested", false); mAdapter.requestHighlight(mRoot, null /* recyclerView */, mock(AppBarLayout.class)); - verifyZeroInteractions(mRoot); + verifyNoInteractions(mRoot); } @Test @@ -125,7 +125,7 @@ public class HighlightablePreferenceGroupAdapterTest { when(mFragment.getArguments()).thenReturn(null); when(mFragment.getPreferenceScreen()).thenReturn(screen); HighlightablePreferenceGroupAdapter.adjustInitialExpandedChildCount(mFragment); - verifyZeroInteractions(screen); + verifyNoInteractions(screen); } @Test @@ -150,7 +150,7 @@ public class HighlightablePreferenceGroupAdapterTest { HighlightablePreferenceGroupAdapter.adjustInitialExpandedChildCount(mFragment); verify(mFragment).getInitialExpandedChildCount(); - verifyZeroInteractions(screen); + verifyNoInteractions(screen); } @Test diff --git a/tests/robotests/src/com/android/settings/wifi/NetworkRequestDialogFragmentTest.java b/tests/robotests/src/com/android/settings/wifi/NetworkRequestDialogFragmentTest.java index e08a14a469d..66d399c8192 100644 --- a/tests/robotests/src/com/android/settings/wifi/NetworkRequestDialogFragmentTest.java +++ b/tests/robotests/src/com/android/settings/wifi/NetworkRequestDialogFragmentTest.java @@ -173,7 +173,7 @@ public class NetworkRequestDialogFragmentTest { } private List createWifiEntryList() { - List wifiEntryList = spy(new ArrayList<>()); + List wifiEntryList = new ArrayList<>(); final WifiEntry wifiEntry1 = mock(WifiEntry.class); when(wifiEntry1.getSsid()).thenReturn("Test AP 1"); diff --git a/tests/robotests/src/com/android/settings/wifi/calling/DisclaimerItemListAdapterTest.java b/tests/robotests/src/com/android/settings/wifi/calling/DisclaimerItemListAdapterTest.java index 8478a5471ac..610e520e49b 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/DisclaimerItemListAdapterTest.java +++ b/tests/robotests/src/com/android/settings/wifi/calling/DisclaimerItemListAdapterTest.java @@ -21,9 +21,9 @@ import static com.android.settings.wifi.calling.DisclaimerItemListAdapter import static com.android.settings.wifi.calling.DisclaimerItemListAdapter .DisclaimerItemViewHolder.ID_DISCLAIMER_ITEM_TITLE; -import static org.mockito.Matchers.anyBoolean; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyBoolean; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -75,7 +75,7 @@ public class DisclaimerItemListAdapterTest { mDisclaimerItem = spy(new MockDisclaimerItem(mContext, 0 /* subId */)); mDisclaimerItemList.add(mDisclaimerItem); - when(mLayoutInflater.inflate(anyInt(), anyObject(), anyBoolean())).thenReturn(mView); + when(mLayoutInflater.inflate(anyInt(), any(), anyBoolean())).thenReturn(mView); when(mViewGroup.getContext()).thenReturn(mContext); when(mViewGroup.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE)).thenReturn( mLayoutInflater); diff --git a/tests/robotests/src/com/android/settings/wifi/calling/EmergencyCallLimitationDisclaimerTest.java b/tests/robotests/src/com/android/settings/wifi/calling/EmergencyCallLimitationDisclaimerTest.java index 985edda69b5..c8e4cce6d0a 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/EmergencyCallLimitationDisclaimerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/calling/EmergencyCallLimitationDisclaimerTest.java @@ -18,8 +18,8 @@ package com.android.settings.wifi.calling; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/wifi/calling/LocationPolicyDisclaimerTest.java b/tests/robotests/src/com/android/settings/wifi/calling/LocationPolicyDisclaimerTest.java index 3fe9678c26e..148095aac02 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/LocationPolicyDisclaimerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/calling/LocationPolicyDisclaimerTest.java @@ -18,8 +18,8 @@ package com.android.settings.wifi.calling; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingDisclaimerFragmentTest.java b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingDisclaimerFragmentTest.java index 207a2318c61..0ece537371f 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingDisclaimerFragmentTest.java +++ b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingDisclaimerFragmentTest.java @@ -16,10 +16,9 @@ package com.android.settings.wifi.calling; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyBoolean; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyBoolean; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.never; @@ -95,7 +94,7 @@ public class WifiCallingDisclaimerFragmentTest { doReturn(mActivity).when(mFragment).getActivity(); - when(mLayoutInflater.inflate(anyInt(), anyObject(), anyBoolean())).thenReturn(mView); + when(mLayoutInflater.inflate(anyInt(), any(), anyBoolean())).thenReturn(mView); when(mView.findViewById(R.id.agree_button)).thenReturn(mAgreeButton); when(mView.findViewById(R.id.disagree_button)).thenReturn(mDisagreeButton); when(mView.findViewById(R.id.disclaimer_item_list)).thenReturn(mRecyclerView); diff --git a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java index e2c5ca33b4c..1faa611b970 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java +++ b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java @@ -16,17 +16,17 @@ package com.android.settings.wifi.calling; -import static junit.framework.Assert.assertEquals; - import static com.android.settings.SettingsActivity.EXTRA_SHOW_FRAGMENT; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Matchers.eq; +import static junit.framework.Assert.assertEquals; + +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; @@ -44,7 +44,6 @@ import android.telephony.CarrierConfigManager; import android.telephony.TelephonyManager; import android.telephony.ims.ImsMmTelManager; import android.view.View; -import android.widget.TextView; import androidx.preference.Preference; import androidx.preference.PreferenceScreen; diff --git a/tests/robotests/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2Test.java b/tests/robotests/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2Test.java index 08bcd2a2912..b0a50c81fa8 100644 --- a/tests/robotests/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2Test.java +++ b/tests/robotests/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2Test.java @@ -17,15 +17,16 @@ package com.android.settings.wifi.details2; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyBoolean; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.anyBoolean; +import static org.mockito.Mockito.anyInt; +import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; +import static org.mockito.Mockito.nullable; import static org.mockito.Mockito.reset; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.times; @@ -92,7 +93,6 @@ import org.mockito.Answers; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InOrder; -import org.mockito.Matchers; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; @@ -1253,7 +1253,7 @@ public class WifiDetailPreferenceController2Test { mMockWifiConfig.creatorUid = doUid; ComponentName doComponent = new ComponentName(doPackage, "some.Class"); try { - when(mMockPackageManager.getPackageUidAsUser(Matchers.anyString(), Matchers.anyInt())) + when(mMockPackageManager.getPackageUidAsUser(anyString(), anyInt())) .thenReturn(doUid); } catch (PackageManager.NameNotFoundException e) { //do nothing From c617ae851d80ee9bfd2c6565b5ff578063a85387 Mon Sep 17 00:00:00 2001 From: Matt Pietal Date: Wed, 4 Jan 2023 21:39:43 +0000 Subject: [PATCH 3/9] Update wallet setting availability For devices that don't support wallet, don't even show the setting in a disabled state, which can cause confusion and lead the user to believe they can enable it somehow. Fixes: 251089510 Test: WalletPrivacyPreferenceControllerTest Change-Id: I5d60957f24712bb4d75e72fa5f64cab35b6d6a5f --- .../WalletPrivacyPreferenceController.java | 9 ++++++--- ...WalletPrivacyPreferenceControllerTest.java | 20 ++++++++++++++++++- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/src/com/android/settings/display/WalletPrivacyPreferenceController.java b/src/com/android/settings/display/WalletPrivacyPreferenceController.java index fe14a40a01a..f40e8386952 100644 --- a/src/com/android/settings/display/WalletPrivacyPreferenceController.java +++ b/src/com/android/settings/display/WalletPrivacyPreferenceController.java @@ -64,15 +64,18 @@ public class WalletPrivacyPreferenceController extends TogglePreferenceControlle public int getAvailabilityStatus() { if (CustomizableLockScreenUtils.isFeatureEnabled(mContext)) { return UNSUPPORTED_ON_DEVICE; + } else if (!isEnabled()) { + return UNSUPPORTED_ON_DEVICE; + } else if (!isSecure()) { + return DISABLED_DEPENDENT_SETTING; } - - return isEnabled() && isSecure() ? AVAILABLE : DISABLED_DEPENDENT_SETTING; + return AVAILABLE; } @Override public void updateState(Preference preference) { super.updateState(preference); - preference.setEnabled(getAvailabilityStatus() != DISABLED_DEPENDENT_SETTING); + preference.setEnabled(getAvailabilityStatus() == AVAILABLE); refreshSummary(preference); } diff --git a/tests/robotests/src/com/android/settings/display/WalletPrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/WalletPrivacyPreferenceControllerTest.java index 73f4946f9af..32b8b66c45f 100644 --- a/tests/robotests/src/com/android/settings/display/WalletPrivacyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/WalletPrivacyPreferenceControllerTest.java @@ -141,11 +141,29 @@ public class WalletPrivacyPreferenceControllerTest { } @Test - public void getAvailabilityStatus_noService_returnsDisabled() { + public void getAvailabilityStatus_noServiceAndIsSecure_returnsUnsupported() { when(mClient.isWalletServiceAvailable()).thenReturn(false); when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true); + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.UNSUPPORTED_ON_DEVICE); + } + + @Test + public void getAvailabilityStatus_hasServiceButNotSecure_returnsDisabled() { + when(mClient.isWalletServiceAvailable()).thenReturn(true); + when(mLockPatternUtils.isSecure(anyInt())).thenReturn(false); + assertThat(mController.getAvailabilityStatus()).isEqualTo( BasePreferenceController.DISABLED_DEPENDENT_SETTING); } + + @Test + public void getAvailabilityStatus_hasServiceAndIsSecure_returnsAvailable() { + when(mClient.isWalletServiceAvailable()).thenReturn(true); + when(mLockPatternUtils.isSecure(anyInt())).thenReturn(true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.AVAILABLE); + } } From a1ca72224da3a87d3117e764dfea35e03f62a182 Mon Sep 17 00:00:00 2001 From: TYM Tsai Date: Sat, 7 Jan 2023 02:39:03 +0800 Subject: [PATCH 4/9] Fix Content Capture service starting after restriction When a device owner and a profile owner restrict Content Capture, there should be no toggle setting to turn on Content Capture. Bug: 250573776 Test: Manual. Use setps on the comment#3, make sure no toggle setting in the Privacy page. Change-Id: Ia17f852b224c67b9c1cf5846ee9ad5592a485bab --- .../EnableContentCapturePreferenceController.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/com/android/settings/privacy/EnableContentCapturePreferenceController.java b/src/com/android/settings/privacy/EnableContentCapturePreferenceController.java index 3cf72b23dcc..5377f15484e 100644 --- a/src/com/android/settings/privacy/EnableContentCapturePreferenceController.java +++ b/src/com/android/settings/privacy/EnableContentCapturePreferenceController.java @@ -18,6 +18,8 @@ package com.android.settings.privacy; import android.annotation.NonNull; import android.content.Context; +import android.os.UserHandle; +import android.os.UserManager; import com.android.settings.R; import com.android.settings.core.TogglePreferenceController; @@ -42,9 +44,15 @@ public final class EnableContentCapturePreferenceController extends TogglePrefer @Override public int getAvailabilityStatus() { - boolean available = ContentCaptureUtils.isFeatureAvailable() - && ContentCaptureUtils.getServiceSettingsComponentName() == null; - return available ? AVAILABLE : UNSUPPORTED_ON_DEVICE; + if (!ContentCaptureUtils.isFeatureAvailable() + || ContentCaptureUtils.getServiceSettingsComponentName() != null) { + return UNSUPPORTED_ON_DEVICE; + } + if (UserManager.get(mContext).hasUserRestrictionForUser( + UserManager.DISALLOW_CONTENT_CAPTURE, UserHandle.of(UserHandle.myUserId()))) { + return DISABLED_FOR_USER; + } + return AVAILABLE; } @Override From be9cb36c6ed3d7a0c5bd570e39a029d90f19e77d Mon Sep 17 00:00:00 2001 From: TYM Tsai Date: Mon, 19 Dec 2022 15:19:46 +0800 Subject: [PATCH 5/9] Fix html injection in Autofill confirmation dialog AutofillService can inject html in its label. The label will be padded with line breaks which puts the warning off screen. To fix the issue, disable html injection of the label. Bug: 216117246 Test: Manual, check the label of the sample in the confirmation dialog Change-Id: I244d8e9eadbacae6af615d1d2a5a99c86e4fa456 --- .../applications/defaultapps/DefaultAutofillPicker.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/com/android/settings/applications/defaultapps/DefaultAutofillPicker.java b/src/com/android/settings/applications/defaultapps/DefaultAutofillPicker.java index f1e7ac0974c..d96aa6be61f 100644 --- a/src/com/android/settings/applications/defaultapps/DefaultAutofillPicker.java +++ b/src/com/android/settings/applications/defaultapps/DefaultAutofillPicker.java @@ -243,7 +243,7 @@ public class DefaultAutofillPicker extends DefaultAppPickerFragment { } final CharSequence appName = appInfo.loadLabel(); final String message = getContext().getString( - R.string.autofill_confirmation_message, appName); + R.string.autofill_confirmation_message, Html.escapeHtml(appName)); return Html.fromHtml(message); } From 00dfcd83dc9acab5a49d24773bd23d5969257b36 Mon Sep 17 00:00:00 2001 From: Diya Bera Date: Mon, 9 Jan 2023 23:52:34 +0000 Subject: [PATCH 6/9] Fixes background color in SUW fingerprint enrollment Test: Manual (Enroll fingerprint in SUW, background color remains the same) Bug: 246231650 Bug: 250464527 Change-Id: Iffd1543d8b230199c3b925c6538bd418a381c96a --- .../android/settings/biometrics/BiometricUtils.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/com/android/settings/biometrics/BiometricUtils.java b/src/com/android/settings/biometrics/BiometricUtils.java index 4cd2f790620..9cc656cda23 100644 --- a/src/com/android/settings/biometrics/BiometricUtils.java +++ b/src/com/android/settings/biometrics/BiometricUtils.java @@ -39,6 +39,7 @@ import com.android.settings.SetupWizardUtils; import com.android.settings.biometrics.face.FaceEnrollIntroduction; import com.android.settings.biometrics.fingerprint.FingerprintEnrollFindSensor; import com.android.settings.biometrics.fingerprint.FingerprintEnrollIntroduction; +import com.android.settings.biometrics.fingerprint.SetupFingerprintEnrollFindSensor; import com.android.settings.biometrics.fingerprint.SetupFingerprintEnrollIntroduction; import com.android.settings.password.ChooseLockGeneric; import com.android.settings.password.ChooseLockSettingsHelper; @@ -152,9 +153,13 @@ public class BiometricUtils { */ public static Intent getFingerprintFindSensorIntent(@NonNull Context context, @NonNull Intent activityIntent) { - Intent intent = new Intent(context, FingerprintEnrollFindSensor.class); - SetupWizardUtils.copySetupExtras(activityIntent, intent); - return intent; + if (WizardManagerHelper.isAnySetupWizard(activityIntent)) { + Intent intent = new Intent(context, SetupFingerprintEnrollFindSensor.class); + SetupWizardUtils.copySetupExtras(activityIntent, intent); + return intent; + } else { + return new Intent(context, FingerprintEnrollFindSensor.class); + } } /** From fc63046f329d1b18dcd79cd5a3c8df82394e92cd Mon Sep 17 00:00:00 2001 From: Julia Reynolds Date: Tue, 27 Dec 2022 06:54:24 -0500 Subject: [PATCH 7/9] Update string Test: view string in UI Fixes: 262094151 Change-Id: I4f55c340d3144d446465d64008d9d92d622425ae --- res/values/strings.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/res/values/strings.xml b/res/values/strings.xml index 28b35b3fcfc..4839b68e4ff 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -9923,7 +9923,7 @@ Loading apps\u2026 - At your request, Android is blocking this app\'s notifications from appearing on this device + You haven\'t allowed notifications from this app At your request, Android is blocking this category of notifications from appearing on this device From 3e0f8365f5218096c322b217ee2828e1bbd519e0 Mon Sep 17 00:00:00 2001 From: Joshua McCloskey Date: Tue, 10 Jan 2023 19:13:08 +0000 Subject: [PATCH 8/9] Fixed scroll issue w/ FP settings Test: Verified fingerprint preferences are not shown over the fingerprint title when device is rotated in settings screen Fixes: 259338792 Change-Id: Ie99e584247bb52b097e949d0c8c0ed096543aa21 --- .../fingerprint/FingerprintSettings.java | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java b/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java index bbb4f45b702..2721c773af2 100644 --- a/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java +++ b/src/com/android/settings/biometrics/fingerprint/FingerprintSettings.java @@ -494,8 +494,10 @@ public class FingerprintSettings extends SubSettings { if (root != null) { root.removeAll(); } - root = getPreferenceScreen(); - addFingerprintItemPreferences(root); + final String fpPrefKey = addFingerprintItemPreferences(root); + if (isSfps()) { + scrollToPreference(fpPrefKey); + } addPreferencesFromResource(getPreferenceScreenResId()); mRequireScreenOnToAuthPreference = findPreference(KEY_REQUIRE_SCREEN_ON_TO_AUTH); mFingerprintUnlockCategory = findPreference(KEY_FINGERPRINT_UNLOCK_CATEGORY); @@ -529,15 +531,20 @@ public class FingerprintSettings extends SubSettings { } } - private void addFingerprintItemPreferences(PreferenceGroup root) { + private String addFingerprintItemPreferences(PreferenceGroup root) { root.removeAll(); + String keyToReturn = KEY_FINGERPRINT_ADD; final List items = mFingerprintManager.getEnrolledFingerprints(mUserId); final int fingerprintCount = items.size(); for (int i = 0; i < fingerprintCount; i++) { final Fingerprint item = items.get(i); FingerprintPreference pref = new FingerprintPreference(root.getContext(), this /* onDeleteClickListener */); - pref.setKey(genKey(item.getBiometricId())); + String key = genKey(item.getBiometricId()); + if (i == 0) { + keyToReturn = key; + } + pref.setKey(key); pref.setTitle(item.getName()); pref.setFingerprint(item); pref.setPersistent(false); @@ -560,6 +567,8 @@ public class FingerprintSettings extends SubSettings { addPreference.setOnPreferenceChangeListener(this); updateAddPreference(); createFooterPreference(root); + + return keyToReturn; } private void updateAddPreference() { From b8695b8e760abfe7376d688ebd66b29ff5157fdd Mon Sep 17 00:00:00 2001 From: Joshua McCloskey Date: Tue, 10 Jan 2023 22:36:30 +0000 Subject: [PATCH 9/9] Added performant auth feature Test: Manually verified in settings that the performant auth feature(fingerprint) is disabled by default Bug: 261216422 Bug: 265031172 Change-Id: I6422b12f801d038fa514758eca34efcbfdeef27a --- res/values/strings.xml | 4 ++-- ...ireScreenOnToAuthPreferenceController.java | 21 ++++++++++++------- ...creenOnToAuthPreferenceControllerTest.java | 4 ++-- 3 files changed, 17 insertions(+), 12 deletions(-) diff --git a/res/values/strings.xml b/res/values/strings.xml index 4839b68e4ff..d105d784c1d 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -1287,9 +1287,9 @@ Now you can use your fingerprint to unlock your phone or verify it\u2019s you, like when you sign in to apps or approve a purchase - Unlock only when screen is on + Touch to unlock anytime - The screen must be on before you can unlock with your fingerprint. This makes accidental unlocking less likely. + Touch the sensor to unlock, even when the screen is off. This makes accidental unlocking more likely. Screen, Unlock diff --git a/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceController.java b/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceController.java index 5b183c1433f..65070833e09 100644 --- a/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceController.java +++ b/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceController.java @@ -51,21 +51,26 @@ public class FingerprintSettingsRequireScreenOnToAuthPreferenceController } else if (getRestrictingAdmin() != null) { return false; } - int defaultValue = mContext.getResources().getBoolean( - com.android.internal.R.bool.config_requireScreenOnToAuthEnabled) ? 1 : 0; - - return Settings.Secure.getIntForUser( + int toReturn = Settings.Secure.getIntForUser( mContext.getContentResolver(), - Settings.Secure.SFPS_REQUIRE_SCREEN_ON_TO_AUTH_ENABLED, - defaultValue, - getUserHandle()) != 0; + Settings.Secure.SFPS_PERFORMANT_AUTH_ENABLED, + -1, + getUserHandle()); + if (toReturn == -1) { + toReturn = mContext.getResources().getBoolean( + com.android.internal.R.bool.config_requireScreenOnToAuthEnabled) ? 1 : 0; + Settings.Secure.putIntForUser(mContext.getContentResolver(), + Settings.Secure.SFPS_PERFORMANT_AUTH_ENABLED, toReturn, getUserHandle()); + } + + return toReturn == 1; } @Override public boolean setChecked(boolean isChecked) { Settings.Secure.putIntForUser( mContext.getContentResolver(), - Settings.Secure.SFPS_REQUIRE_SCREEN_ON_TO_AUTH_ENABLED, + Settings.Secure.SFPS_PERFORMANT_AUTH_ENABLED, isChecked ? 1 : 0, getUserHandle()); return true; diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceControllerTest.java index ff74d59782a..b6df62eeff7 100644 --- a/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/FingerprintSettingsRequireScreenOnToAuthPreferenceControllerTest.java @@ -81,12 +81,12 @@ public class FingerprintSettingsRequireScreenOnToAuthPreferenceControllerTest { @Test public void onPreferenceChange_settingIsUpdated() { boolean state = Settings.Secure.getInt(mContext.getContentResolver(), - Settings.Secure.SFPS_REQUIRE_SCREEN_ON_TO_AUTH_ENABLED, 1) != 0; + Settings.Secure.SFPS_PERFORMANT_AUTH_ENABLED, 1) != 0; assertThat(mController.isChecked()).isFalse(); assertThat(mController.onPreferenceChange(mPreference, !state)).isTrue(); boolean newState = Settings.Secure.getInt(mContext.getContentResolver(), - Settings.Secure.SFPS_REQUIRE_SCREEN_ON_TO_AUTH_ENABLED, 1) != 0; + Settings.Secure.SFPS_PERFORMANT_AUTH_ENABLED, 1) != 0; assertThat(newState).isEqualTo(!state); }