From bb75bb911edf67ac32169dfdb1ea473f635282a3 Mon Sep 17 00:00:00 2001 From: Jernej Virag Date: Thu, 1 Jul 2021 15:35:56 +0000 Subject: [PATCH] Update Prevent Ringing setting to avoid conflict with long press power Long press power setting overrides Prevent ringing setting key chord. This updates the Prevent Ringing setting to disable it when LPP setting conflicts and adds a string describing why this setting is disabled. Bug: 191971326 Test: Manually on device Unit tests in PreventRingingParentPreferenceController Change-Id: If9fc8318381def7e4bbd71a0f5db3f38c474cb3d --- res/values/strings.xml | 2 + ...ventRingingParentPreferenceController.java | 78 +++++++++++++++---- ...RingingParentPreferenceControllerTest.java | 64 +++++++++++++-- 3 files changed, 125 insertions(+), 19 deletions(-) diff --git a/res/values/strings.xml b/res/values/strings.xml index 26fbd795575..a5294103167 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -12454,6 +12454,8 @@ Vibrate Mute + + To enable, first change \"Press and hold power button\" to the power menu. Network details diff --git a/src/com/android/settings/gestures/PreventRingingParentPreferenceController.java b/src/com/android/settings/gestures/PreventRingingParentPreferenceController.java index b67943817ee..b3b39fbd7e5 100644 --- a/src/com/android/settings/gestures/PreventRingingParentPreferenceController.java +++ b/src/com/android/settings/gestures/PreventRingingParentPreferenceController.java @@ -37,10 +37,15 @@ import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnStart; import com.android.settingslib.core.lifecycle.events.OnStop; +import com.google.common.annotations.VisibleForTesting; + /** The controller manages the behaviour of the Prevent Ringing gesture setting. */ public class PreventRingingParentPreferenceController extends TogglePreferenceController implements LifecycleObserver, OnStart, OnStop { + @VisibleForTesting + static final int KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE = 1; + final String SECURE_KEY = VOLUME_HUSH_GESTURE; private PrimarySwitchPreference mPreference; @@ -59,6 +64,10 @@ public class PreventRingingParentPreferenceController extends TogglePreferenceCo @Override public boolean isChecked() { + if (!isVolumePowerKeyChordSetToHush()) { + return false; + } + final int preventRinging = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.VOLUME_HUSH_GESTURE, Settings.Secure.VOLUME_HUSH_VIBRATE); @@ -85,25 +94,47 @@ public class PreventRingingParentPreferenceController extends TogglePreferenceCo final int value = Settings.Secure.getInt( mContext.getContentResolver(), SECURE_KEY, VOLUME_HUSH_VIBRATE); CharSequence summary; - switch (value) { - case VOLUME_HUSH_VIBRATE: - summary = mContext.getText(R.string.prevent_ringing_option_vibrate_summary); - break; - case VOLUME_HUSH_MUTE: - summary = mContext.getText(R.string.prevent_ringing_option_mute_summary); - break; - // VOLUME_HUSH_OFF - default: - summary = mContext.getText(R.string.switch_off_text); + if (isVolumePowerKeyChordSetToHush()) { + switch (value) { + case VOLUME_HUSH_VIBRATE: + summary = mContext.getText(R.string.prevent_ringing_option_vibrate_summary); + break; + case VOLUME_HUSH_MUTE: + summary = mContext.getText(R.string.prevent_ringing_option_mute_summary); + break; + // VOLUME_HUSH_OFF + default: + summary = mContext.getText(R.string.switch_off_text); + } + preference.setEnabled(true); + mPreference.setSwitchEnabled(true); + } else { + summary = mContext.getText(R.string.prevent_ringing_option_unavailable_lpp_summary); + preference.setEnabled(false); + mPreference.setSwitchEnabled(false); } + preference.setSummary(summary); } @Override public int getAvailabilityStatus() { - return mContext.getResources().getBoolean( - com.android.internal.R.bool.config_volumeHushGestureEnabled) - ? AVAILABLE : UNSUPPORTED_ON_DEVICE; + if (!mContext.getResources().getBoolean( + com.android.internal.R.bool.config_volumeHushGestureEnabled)) { + return UNSUPPORTED_ON_DEVICE; + } + if (isVolumePowerKeyChordSetToHush()) { + return AVAILABLE; + } + if (mContext.getResources().getBoolean( + com.android.internal + .R.bool.config_longPressOnPowerForAssistantSettingAvailable)) { + // The power + volume key chord is not set to hush gesture - it's been disabled + // by long press power for Assistant. + return DISABLED_DEPENDENT_SETTING; + } + + return UNSUPPORTED_ON_DEVICE; } @Override @@ -121,9 +152,26 @@ public class PreventRingingParentPreferenceController extends TogglePreferenceCo } } + /** + * Returns true if power + volume up key chord is actually set to "mute toggle". If not, + * this setting will have no effect and should be disabled. + * + * This handles the condition when long press on power for Assistant changes power + volume + * chord to power menu and this setting needs to be disabled. + */ + private boolean isVolumePowerKeyChordSetToHush() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.KEY_CHORD_POWER_VOLUME_UP, + mContext.getResources().getInteger( + com.android.internal.R.integer.config_keyChordPowerVolumeUp)) + == KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE; + } + private class SettingObserver extends ContentObserver { private final Uri mVolumeHushGestureUri = Settings.Secure.getUriFor( Settings.Secure.VOLUME_HUSH_GESTURE); + private final Uri mKeyChordVolumePowerUpUri = Settings.Global.getUriFor( + Settings.Global.KEY_CHORD_POWER_VOLUME_UP); private final Preference mPreference; @@ -133,6 +181,7 @@ public class PreventRingingParentPreferenceController extends TogglePreferenceCo } public void register(ContentResolver cr) { + cr.registerContentObserver(mKeyChordVolumePowerUpUri, false, this); cr.registerContentObserver(mVolumeHushGestureUri, false, this); } @@ -143,7 +192,8 @@ public class PreventRingingParentPreferenceController extends TogglePreferenceCo @Override public void onChange(boolean selfChange, Uri uri) { super.onChange(selfChange, uri); - if (uri == null || mVolumeHushGestureUri.equals(uri)) { + if (uri == null || mVolumeHushGestureUri.equals(uri) + || mKeyChordVolumePowerUpUri.equals(uri)) { updateState(mPreference); } } diff --git a/tests/robotests/src/com/android/settings/gestures/PreventRingingParentPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/PreventRingingParentPreferenceControllerTest.java index 4844a1cb0a7..48a047f2da8 100644 --- a/tests/robotests/src/com/android/settings/gestures/PreventRingingParentPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/PreventRingingParentPreferenceControllerTest.java @@ -22,6 +22,8 @@ import static android.provider.Settings.Secure.VOLUME_HUSH_OFF; import static android.provider.Settings.Secure.VOLUME_HUSH_VIBRATE; import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING; +import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE; import static com.google.common.truth.Truth.assertThat; @@ -33,8 +35,10 @@ import android.content.res.Resources; import android.provider.Settings; import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; import com.android.settings.R; +import com.android.settings.widget.PrimarySwitchPreference; import org.junit.Before; import org.junit.Test; @@ -50,6 +54,9 @@ public class PreventRingingParentPreferenceControllerTest { @Mock private Resources mResources; + @Mock + PreferenceScreen mScreen; + private Context mContext; private PreventRingingParentPreferenceController mController; private Preference mPreference; @@ -58,21 +65,53 @@ public class PreventRingingParentPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); mContext = spy(RuntimeEnvironment.application.getApplicationContext()); + when(mContext.getResources()).thenReturn(mResources); + when(mResources.getInteger( + com.android.internal.R.integer.config_keyChordPowerVolumeUp)).thenReturn( + PreventRingingParentPreferenceController.KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE); mController = new PreventRingingParentPreferenceController(mContext, "test_key"); - mPreference = new Preference(mContext); + mPreference = new PrimarySwitchPreference(mContext); + when(mScreen.findPreference("test_key")).thenReturn(mPreference); + mController.displayPreference(mScreen); } @Test - public void testIsAvailable_configIsTrue_shouldAvailableUnSearchable() { - when(mContext.getResources()).thenReturn(mResources); + public void isAvailable_configIsTrueAndKeyChordMute_shouldAvailableUnSearchable() { when(mResources.getBoolean( com.android.internal.R.bool.config_volumeHushGestureEnabled)).thenReturn(true); - assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @Test - public void testIsAvailable_configIsFalse_shouldReturnFalse() { + public void getAvailabilityStatus_configIsTrueAndKeyNotMute_shouldReturnDisabledDependent() { + when(mContext.getResources()).thenReturn(mResources); + when(mResources.getBoolean( + com.android.internal.R.bool.config_volumeHushGestureEnabled)).thenReturn(true); + when(mResources.getBoolean( + com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable)) + .thenReturn(true); + when(mResources.getInteger( + com.android.internal.R.integer.config_keyChordPowerVolumeUp)).thenReturn(2); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_configIsTrueLppDisabled_shouldReturnUnsupportedOnDevice() { + when(mContext.getResources()).thenReturn(mResources); + when(mResources.getBoolean( + com.android.internal.R.bool.config_volumeHushGestureEnabled)).thenReturn(true); + when(mResources.getBoolean( + com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable)) + .thenReturn(false); + when(mResources.getInteger( + com.android.internal.R.integer.config_keyChordPowerVolumeUp)).thenReturn(2); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE); + } + + @Test + public void isAvailable_configIsFalse_shouldReturnFalse() { when(mContext.getResources()).thenReturn(mResources); when(mResources.getBoolean( com.android.internal.R.bool.config_volumeHushGestureEnabled)).thenReturn(false); @@ -101,6 +140,21 @@ public class PreventRingingParentPreferenceControllerTest { R.string.switch_off_text)); } + @Test + public void updateState_keyChordDisabled_summaryUpdated() { + when(mResources.getInteger( + com.android.internal.R.integer.config_keyChordPowerVolumeUp)).thenReturn(2); + // Ensure that the state displays unchecked even if the underlying field is set. + Settings.Secure.putInt(mContext.getContentResolver(), VOLUME_HUSH_GESTURE, + VOLUME_HUSH_MUTE); + mController.updateState(mPreference); + + assertThat(mPreference.isEnabled()).isFalse(); + assertThat(mPreference.getSummary()).isEqualTo(mContext.getResources().getText( + R.string.prevent_ringing_option_unavailable_lpp_summary)); + assertThat(mController.isChecked()).isFalse(); + } + @Test public void isChecked_vibrate_shouldReturnTrue() { Settings.Secure.putInt(mContext.getContentResolver(), VOLUME_HUSH_GESTURE,