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

@@ -12454,6 +12454,8 @@
     <string name="prevent_ringing_option_vibrate_summary">Vibrate</string>
     <!-- Summary for prevent ringing setting -->
     <string name="prevent_ringing_option_mute_summary">Mute</string>
+    <!-- Summary for prevent ringing setting when the option itself is unavailable. [CHAR LIMIT=NONE] -->
+    <string name="prevent_ringing_option_unavailable_lpp_summary">To enable, first change \"Press and hold power button\" to the power menu.</string>
 
     <!-- Title for detail page of wifi network [CHAR LIMIT=30] -->
     <string name="pref_title_network_details">Network details</string>

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) {
+        if (isVolumePowerKeyChordSetToHush()) {
-            case VOLUME_HUSH_VIBRATE:
+            switch (value) {
-                summary = mContext.getText(R.string.prevent_ringing_option_vibrate_summary);
+                case VOLUME_HUSH_VIBRATE:
-                break;
+                    summary = mContext.getText(R.string.prevent_ringing_option_vibrate_summary);
-            case VOLUME_HUSH_MUTE:
+                    break;
-                summary = mContext.getText(R.string.prevent_ringing_option_mute_summary);
+                case VOLUME_HUSH_MUTE:
-                break;
+                    summary = mContext.getText(R.string.prevent_ringing_option_mute_summary);
-            // VOLUME_HUSH_OFF
+                    break;
-            default:
+                // VOLUME_HUSH_OFF
-                summary = mContext.getText(R.string.switch_off_text);
+                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(
+        if (!mContext.getResources().getBoolean(
-                com.android.internal.R.bool.config_volumeHushGestureEnabled)
+                com.android.internal.R.bool.config_volumeHushGestureEnabled)) {
-                ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
+            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);
             }
         }

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() {
+    public void isAvailable_configIsTrueAndKeyChordMute_shouldAvailableUnSearchable() {
-        when(mContext.getResources()).thenReturn(mResources);
         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,