diff --git a/res/values/strings.xml b/res/values/strings.xml index ac06f735143..a2fa5a2b7be 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -12449,6 +12449,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,