diff --git a/res/values/strings.xml b/res/values/strings.xml index fe90b863458..60b8cd26176 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -11676,7 +11676,7 @@ Swipe down on the bottom edge of the screen to show your notifications.\nYou can\'t use one-handed mode when this feature is turned on. - One-Handed mode + One-handed mode Use one-handed mode @@ -11691,6 +11691,19 @@ 12 seconds reachability + + Swipe down to + + To use one handed mode, swipe down from the bottom edge of the screen. To use this feature, make sure gesture navigation is turned on in system navigation settings. + + Pull screen into reach + + The top of the screen will move into reach of your thumb. + + Show notifications + + Notification and settings will appear. + To check time, notifications, and other info, double-tap your screen. diff --git a/res/xml/one_handed_settings.xml b/res/xml/one_handed_settings.xml index b2c7de9788d..f46b7eae186 100644 --- a/res/xml/one_handed_settings.xml +++ b/res/xml/one_handed_settings.xml @@ -21,12 +21,6 @@ android:persistent="false" android:title="@string/one_handed_title"> - - - + - + + + + + + + + + diff --git a/src/com/android/settings/gestures/OneHandedActionPullDownPrefController.java b/src/com/android/settings/gestures/OneHandedActionPullDownPrefController.java new file mode 100644 index 00000000000..84ea8b6c457 --- /dev/null +++ b/src/com/android/settings/gestures/OneHandedActionPullDownPrefController.java @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2021 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.gestures; + +import android.content.Context; +import android.net.Uri; + +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.core.BasePreferenceController; +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.android.settingslib.widget.RadioButtonPreference; + +/** + * The controller to handle one-handed mode pull screen into reach preference. + **/ +public class OneHandedActionPullDownPrefController extends BasePreferenceController + implements OneHandedSettingsUtils.TogglesCallback, LifecycleObserver, OnStart, OnStop { + + private final OneHandedSettingsUtils mUtils; + + private Preference mPreference; + + public OneHandedActionPullDownPrefController(Context context, String key) { + super(context, key); + mUtils = new OneHandedSettingsUtils(context); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + if (preference instanceof RadioButtonPreference) { + ((RadioButtonPreference) preference).setChecked( + !OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)); + } + } + + @Override + public int getAvailabilityStatus() { + return (OneHandedSettingsUtils.isSupportOneHandedMode() + && OneHandedSettingsUtils.canEnableController(mContext)) + ? AVAILABLE : DISABLED_DEPENDENT_SETTING; + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (!getPreferenceKey().equals(preference.getKey())) { + return false; + } + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, false); + if (preference instanceof RadioButtonPreference) { + ((RadioButtonPreference) preference).setChecked(true); + } + return true; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public void onStart() { + mUtils.registerToggleAwareObserver(this); + } + + @Override + public void onStop() { + mUtils.unregisterToggleAwareObserver(); + } + + @Override + public void onChange(Uri uri) { + if (mPreference == null) { + return; + } + if (uri.equals(OneHandedSettingsUtils.ONE_HANDED_MODE_ENABLED_URI)) { + mPreference.setEnabled(OneHandedSettingsUtils.canEnableController(mContext)); + } else if (uri.equals(OneHandedSettingsUtils.SHOW_NOTIFICATION_ENABLED_URI)) { + updateState(mPreference); + } + } +} diff --git a/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefController.java b/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefController.java new file mode 100644 index 00000000000..564429986e1 --- /dev/null +++ b/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefController.java @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2021 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.gestures; + +import android.content.Context; +import android.net.Uri; + +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.core.BasePreferenceController; +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.android.settingslib.widget.RadioButtonPreference; + +/** + * The controller to handle one-handed mode show notification preference. + **/ +public class OneHandedActionShowNotificationPrefController extends BasePreferenceController + implements OneHandedSettingsUtils.TogglesCallback, LifecycleObserver, OnStart, OnStop { + + private final OneHandedSettingsUtils mUtils; + + private Preference mPreference; + + public OneHandedActionShowNotificationPrefController(Context context, String key) { + super(context, key); + mUtils = new OneHandedSettingsUtils(context); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + if (preference instanceof RadioButtonPreference) { + ((RadioButtonPreference) preference).setChecked( + OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)); + } + } + + @Override + public int getAvailabilityStatus() { + return (OneHandedSettingsUtils.isSupportOneHandedMode() + && OneHandedSettingsUtils.canEnableController(mContext)) + ? AVAILABLE : DISABLED_DEPENDENT_SETTING; + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (!getPreferenceKey().equals(preference.getKey())) { + return false; + } + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, true); + if (preference instanceof RadioButtonPreference) { + ((RadioButtonPreference) preference).setChecked(true); + } + return true; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public void onStart() { + mUtils.registerToggleAwareObserver(this); + } + + @Override + public void onStop() { + mUtils.unregisterToggleAwareObserver(); + } + + @Override + public void onChange(Uri uri) { + if (mPreference == null) { + return; + } + if (uri.equals(OneHandedSettingsUtils.ONE_HANDED_MODE_ENABLED_URI)) { + mPreference.setEnabled(OneHandedSettingsUtils.canEnableController(mContext)); + } else if (uri.equals(OneHandedSettingsUtils.SHOW_NOTIFICATION_ENABLED_URI)) { + updateState(mPreference); + } + } +} diff --git a/src/com/android/settings/gestures/OneHandedEnablePreferenceController.java b/src/com/android/settings/gestures/OneHandedEnablePreferenceController.java index d7bf7b041da..e388585e5f4 100644 --- a/src/com/android/settings/gestures/OneHandedEnablePreferenceController.java +++ b/src/com/android/settings/gestures/OneHandedEnablePreferenceController.java @@ -19,37 +19,25 @@ package com.android.settings.gestures; import android.content.Context; import com.android.settings.R; -import com.android.settings.widget.SettingsMainSwitchPreferenceController; +import com.android.settings.core.BasePreferenceController; /** * The controller to handle one-handed mode enable or disable state. **/ -public class OneHandedEnablePreferenceController extends SettingsMainSwitchPreferenceController { +public class OneHandedEnablePreferenceController extends BasePreferenceController { - public OneHandedEnablePreferenceController(Context context, String key) { - super(context, key); + public OneHandedEnablePreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); } - @Override public int getAvailabilityStatus() { - return AVAILABLE; - } - - @Override - public boolean setChecked(boolean isChecked) { - OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, isChecked); - OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, !isChecked); - return true; - } - - @Override - public boolean isChecked() { - return OneHandedSettingsUtils.isOneHandedModeEnabled(mContext); + return OneHandedSettingsUtils.isSupportOneHandedMode() ? AVAILABLE : UNSUPPORTED_ON_DEVICE; } @Override public CharSequence getSummary() { return mContext.getText( - isChecked() ? R.string.gesture_setting_on : R.string.gesture_setting_off); + OneHandedSettingsUtils.isOneHandedModeEnabled(mContext) + ? R.string.gesture_setting_on : R.string.gesture_setting_off); } } diff --git a/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceController.java b/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceController.java new file mode 100644 index 00000000000..043588e8a39 --- /dev/null +++ b/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceController.java @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2021 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.gestures; + +import android.content.Context; + +import com.android.settings.widget.SettingsMainSwitchPreferenceController; + +/** + * The controller to handle one-handed mode main switch enable or disable state. + **/ +public class OneHandedMainSwitchPreferenceController extends + SettingsMainSwitchPreferenceController { + + public OneHandedMainSwitchPreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public int getAvailabilityStatus() { + return (OneHandedSettingsUtils.isSupportOneHandedMode() + && OneHandedSettingsUtils.getNavigationBarMode(mContext) != 0 /* 3-button mode */) + ? AVAILABLE : DISABLED_DEPENDENT_SETTING; + } + + @Override + public boolean isChecked() { + return OneHandedSettingsUtils.isOneHandedModeEnabled(mContext); + } + + @Override + public boolean setChecked(boolean isChecked) { + if (isChecked) { + // Set default value for TapsAppToExit and Timeout + OneHandedSettingsUtils.setTapsAppToExitEnabled(mContext, true); + OneHandedSettingsUtils.setTimeoutValue(mContext, + OneHandedSettingsUtils.OneHandedTimeout.MEDIUM.getValue()); + } + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, isChecked); + return true; + } +} diff --git a/src/com/android/settings/gestures/OneHandedSettingsUtils.java b/src/com/android/settings/gestures/OneHandedSettingsUtils.java index fc784e0f75a..a9311296b43 100644 --- a/src/com/android/settings/gestures/OneHandedSettingsUtils.java +++ b/src/com/android/settings/gestures/OneHandedSettingsUtils.java @@ -26,6 +26,8 @@ import android.os.SystemProperties; import android.os.UserHandle; import android.provider.Settings; +import androidx.annotation.VisibleForTesting; + /** * The Util to query one-handed mode settings config */ @@ -34,6 +36,10 @@ public class OneHandedSettingsUtils { static final String SUPPORT_ONE_HANDED_MODE = "ro.support_one_handed_mode"; static final int OFF = 0; static final int ON = 1; + static final Uri ONE_HANDED_MODE_ENABLED_URI = + Settings.Secure.getUriFor(Settings.Secure.ONE_HANDED_MODE_ENABLED); + static final Uri SHOW_NOTIFICATION_ENABLED_URI = + Settings.Secure.getUriFor(Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED); public enum OneHandedTimeout { NEVER(0), SHORT(4), MEDIUM(8), LONG(12); @@ -176,6 +182,21 @@ public class OneHandedSettingsUtils { sCurrentUserId); } + /** + * Set NavigationBar mode flag to Settings provider. + * @param context App context + * @param value Navigation bar mode: + * 0 = 3 button + * 1 = 2 button + * 2 = fully gestural + * @return true if the value was set, false on database errors. + */ + @VisibleForTesting + public boolean setNavigationBarMode(Context context, String value) { + return Settings.Secure.putStringForUser(context.getContentResolver(), + Settings.Secure.NAVIGATION_MODE, value, UserHandle.myUserId()); + } + /** * Get NavigationBar mode flag from Settings provider. * @param context App context @@ -189,6 +210,20 @@ public class OneHandedSettingsUtils { Settings.Secure.NAVIGATION_MODE, 2 /* fully gestural */, sCurrentUserId); } + /** + * Check if One-handed mode settings controllers can enabled or disabled. + * @param context App context + * @return true if controllers are able to enabled, false otherwise. + * + * Note: For better UX experience, just disabled controls that let users know to use + * this feature, they need to make sure gesture navigation is turned on in system + * navigation settings. + */ + public static boolean canEnableController(Context context) { + return (OneHandedSettingsUtils.isOneHandedModeEnabled(context) + && OneHandedSettingsUtils.getNavigationBarMode(context) != 0 /* 3-button mode */); + } + /** * Registers callback for observing Settings.Secure.ONE_HANDED_MODE_ENABLED state. * @param callback for state changes @@ -209,9 +244,6 @@ public class OneHandedSettingsUtils { private final class SettingsObserver extends ContentObserver { private TogglesCallback mCallback; - private final Uri mOneHandedEnabledAware = Settings.Secure.getUriFor( - Settings.Secure.ONE_HANDED_MODE_ENABLED); - SettingsObserver(Handler handler) { super(handler); } @@ -222,7 +254,8 @@ public class OneHandedSettingsUtils { public void observe() { final ContentResolver resolver = mContext.getContentResolver(); - resolver.registerContentObserver(mOneHandedEnabledAware, true, this); + resolver.registerContentObserver(ONE_HANDED_MODE_ENABLED_URI, true, this); + resolver.registerContentObserver(SHOW_NOTIFICATION_ENABLED_URI, true, this); } @Override diff --git a/tests/robotests/src/com/android/settings/gestures/OneHandedActionPullDownPrefControllerTest.java b/tests/robotests/src/com/android/settings/gestures/OneHandedActionPullDownPrefControllerTest.java new file mode 100644 index 00000000000..60398de9937 --- /dev/null +++ b/tests/robotests/src/com/android/settings/gestures/OneHandedActionPullDownPrefControllerTest.java @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2021 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.gestures; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; +import android.os.SystemProperties; +import android.os.UserHandle; + +import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.widget.RadioButtonPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class OneHandedActionPullDownPrefControllerTest { + + private static final String KEY = "gesture_one_handed_action_pull_screen_down"; + + private Context mContext; + private OneHandedSettingsUtils mUtils; + private OneHandedActionPullDownPrefController mController; + private RadioButtonPreference mPreference; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + mUtils = new OneHandedSettingsUtils(mContext); + mController = new OneHandedActionPullDownPrefController(mContext, KEY); + mPreference = new RadioButtonPreference(mContext); + OneHandedSettingsUtils.setUserId(UserHandle.myUserId()); + } + + @Test + public void updateState_showNotificationEnabled_shouldUnchecked() { + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, true); + + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void updateState_showNotificationDisabled_shouldChecked() { + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, false); + + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void getAvailabilityStatus_setOneHandedModeDisabled_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_setNavi3ButtonMode_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "0" /* 3 button */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_setNaviGesturalMode_shouldEnabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.AVAILABLE); + } + + @Test + public void getAvailabilityStatus_unsetSupportOneHandedModeProperty_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } +} diff --git a/tests/robotests/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefControllerTest.java b/tests/robotests/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefControllerTest.java new file mode 100644 index 00000000000..b56a4f78f16 --- /dev/null +++ b/tests/robotests/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefControllerTest.java @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2021 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.gestures; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; +import android.os.SystemProperties; +import android.os.UserHandle; + +import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.widget.RadioButtonPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class OneHandedActionShowNotificationPrefControllerTest { + + private static final String KEY = "gesture_one_handed_action_show_notification"; + + private Context mContext; + private OneHandedSettingsUtils mUtils; + private OneHandedActionShowNotificationPrefController mController; + private RadioButtonPreference mPreference; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + mUtils = new OneHandedSettingsUtils(mContext); + mController = new OneHandedActionShowNotificationPrefController(mContext, KEY); + mPreference = new RadioButtonPreference(mContext); + OneHandedSettingsUtils.setUserId(UserHandle.myUserId()); + } + + @Test + public void updateState_setGesturalMode_shouldEnabled() { + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + mController.updateState(mPreference); + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void updateState_ShowNotificationEnabled_shouldChecked() { + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, true); + + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void updateState_showNotificationDisabled_shouldUnchecked() { + OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, false); + + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void getAvailabilityStatus_setOneHandedModeDisabled_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_setNavi3ButtonMode_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "0" /* 3 button */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_unsetSupportOneHandedModeProperty_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false"); + OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } +} diff --git a/tests/robotests/src/com/android/settings/gestures/OneHandedEnablePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/OneHandedEnablePreferenceControllerTest.java index e5b86880faa..d0f64854ebc 100644 --- a/tests/robotests/src/com/android/settings/gestures/OneHandedEnablePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/OneHandedEnablePreferenceControllerTest.java @@ -21,7 +21,6 @@ import static com.google.common.truth.Truth.assertThat; import android.content.Context; import android.os.SystemProperties; import android.os.UserHandle; -import android.provider.Settings; import com.android.settings.R; import com.android.settings.core.BasePreferenceController; @@ -47,21 +46,9 @@ public class OneHandedEnablePreferenceControllerTest { OneHandedSettingsUtils.setUserId(UserHandle.myUserId()); } - @Test - public void setChecked_setBoolean_checkIsTrueOrFalse() { - mController.setChecked(false); - assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isFalse(); - assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isTrue(); - - mController.setChecked(true); - assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isTrue(); - assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isFalse(); - } - @Test public void getAvailabilityStatus_setSupportOneHandedModeProperty_shouldAvailable() { SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); - setNavigationBarMode(mContext, "2" /* fully gestural */); assertThat(mController.getAvailabilityStatus()) .isEqualTo(BasePreferenceController.AVAILABLE); @@ -70,16 +57,6 @@ public class OneHandedEnablePreferenceControllerTest { @Test public void getAvailabilityStatus_unsetSupportOneHandedModeProperty_shouldUnsupported() { SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false"); - setNavigationBarMode(mContext, "2" /* fully gestural */); - - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE); - } - - @Test - public void getAvailabilityStatus_set3ButtonModeProperty_shouldUnsupported() { - SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); - setNavigationBarMode(mContext, "0" /* 3-button */); assertThat(mController.getAvailabilityStatus()) .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE); @@ -100,18 +77,4 @@ public class OneHandedEnablePreferenceControllerTest { assertThat(mController.getSummary()) .isEqualTo(mContext.getText(R.string.switch_off_text)); } - - /** - * Set NavigationBar mode flag to Settings provider. - * @param context App context - * @param value Navigation bar mode: - * 0 = 3 button - * 1 = 2 button - * 2 = fully gestural - * @return true if the value was set, false on database errors. - */ - private boolean setNavigationBarMode(Context context, String value) { - return Settings.Secure.putStringForUser(context.getContentResolver(), - Settings.Secure.NAVIGATION_MODE, value, UserHandle.myUserId()); - } } diff --git a/tests/robotests/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceControllerTest.java new file mode 100644 index 00000000000..40cf795acd4 --- /dev/null +++ b/tests/robotests/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceControllerTest.java @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2021 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.gestures; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; +import android.os.SystemProperties; +import android.os.UserHandle; + +import com.android.settings.core.BasePreferenceController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class OneHandedMainSwitchPreferenceControllerTest { + + private static final String KEY = "gesture_one_handed_mode_enabled_main_switch"; + + private Context mContext; + private OneHandedSettingsUtils mUtils; + private OneHandedMainSwitchPreferenceController mController; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + mUtils = new OneHandedSettingsUtils(mContext); + mController = new OneHandedMainSwitchPreferenceController(mContext, KEY); + OneHandedSettingsUtils.setUserId(UserHandle.myUserId()); + } + + @Test + public void setChecked_setBoolean_checkIsTrueOrFalse() { + mController.setChecked(false); + assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isFalse(); + + mController.setChecked(true); + assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isTrue(); + } + + @Test + public void getAvailabilityStatus_setSupportOneHandedModeProperty_shouldAvailable() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.AVAILABLE); + } + + @Test + public void getAvailabilityStatus_unsetSupportOneHandedModeProperty_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false"); + mUtils.setNavigationBarMode(mContext, "2" /* fully gestural */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_set3ButtonMode_shouldDisabled() { + SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true"); + mUtils.setNavigationBarMode(mContext, "0" /* 3-button mode */); + + assertThat(mController.getAvailabilityStatus()) + .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING); + } +}