Update key visual changes for one handed mode settings

Follow new visual UI to change the design.

Bug: 175851783
Bug: 188868459
Bug: 189001678

Test: manual verified on Settings > System > Gesture page
> System controls page
Test: make RunSettingsRoboTests ROBOTEST_FILTER=
      "com.android.settings.gestures
      .OneHandedEnablePreferenceControllerTest"
Test: make RunSettingsRoboTests ROBOTEST_FILTER=
      "com.android.settings.gestures
      .OneHandedMainSwitchPreferenceControllerTest"
Test: make RunSettingsRoboTests ROBOTEST_FILTER=
      "com.android.settings.gestures
      .OneHandedActionPullDownPrefControllerTest"
Test: make RunSettingsRoboTests ROBOTEST_FILTER=
      "com.android.settings.gestures
      .OneHandedActionShowNotificationPrefControllerTest"

Change-Id: I86535fd9f49726c7234353032b950640346a02c5

res/values/strings.xml

@@ -11676,7 +11676,7 @@
     <string name="swipe_bottom_to_notifications_summary">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.</string>
 
     <!-- Preference and settings suggestion title text for one handed [CHAR LIMIT=60] -->
-    <string name="one_handed_title">One-Handed mode</string>
+    <string name="one_handed_title">One-handed mode</string>
     <!-- Preference Switch for enabling one handed [CHAR LIMIT=60] -->
     <string name="one_handed_mode_enabled">Use one-handed mode</string>
     <!-- Preference Switch for app taps to exit one handed [CHAR LIMIT=60] -->
@@ -11691,6 +11691,19 @@
     <string name="one_handed_timeout_long">12 seconds</string>
     <!-- Search keywords for "One-Handed" settings [CHAR_LIMIT=NONE] -->
     <string name="keywords_one_handed">reachability</string>
+    <!-- Category title for one handed swipe down [CHAR_LIMIT=60] -->
+    <string name="one_handed_mode_swipe_down_category">Swipe down to</string>
+    <!-- One-handed mode Intro Text [CHAR_LIMIT=NONE] -->
+    <string name="one_handed_mode_intro_text">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.</string>
+    <!-- One-handed mode pull down screen into reach action title [CHAR_LIMIT=60] -->
+    <string name="one_handed_action_pull_down_screen_title">Pull screen into reach</string>
+    <!-- One-handed mode pull down screen into reach action title [CHAR_LIMIT=NONE] -->
+    <string name="one_handed_action_pull_down_screen_summary">The top of the screen will move into reach of your thumb.</string>
+    <!-- One-handed mode show notification action [CHAR_LIMIT=60] -->
+    <string name="one_handed_action_show_notification_title">Show notifications</string>
+    <!-- One-handed mode show notification action [CHAR_LIMIT=NONE] -->
+    <string name="one_handed_action_show_notification_summary">Notification and settings will appear.</string>
+    <!-- One-handed mode Intro text for gesture navigation [CHAR_LIMIT=NONE] -->
 
     <!-- Summary text for ambient display double tap [CHAR LIMIT=NONE]-->
     <string name="ambient_display_summary">To check time, notifications, and other info, double-tap your screen.</string>

res/xml/one_handed_settings.xml

@@ -21,12 +21,6 @@
     android:persistent="false"
     android:title="@string/one_handed_title">
 
-    <com.android.settingslib.widget.MainSwitchPreference
-        android:key="gesture_one_handed_mode_enabled"
-        android:title="@string/one_handed_mode_enabled"
-        settings:keywords="@string/keywords_one_handed"
-        settings:controller="com.android.settings.gestures.OneHandedEnablePreferenceController"/>
-
     <com.android.settingslib.widget.LayoutPreference
         android:key="one_handed_header"
         android:layout="@layout/one_handed_header"
@@ -35,16 +29,31 @@
         settings:allowDividerBelow="false"
         settings:searchable="false"/>
 
-    <SwitchPreference
-        android:key="gesture_app_taps_to_exit"
-        android:title="@string/one_handed_app_taps_to_exit"
-        settings:controller="com.android.settings.gestures.OneHandedAppTapsExitPreferenceController"/>
+    <com.android.settingslib.widget.MainSwitchPreference
+        android:key="gesture_one_handed_mode_enabled_main_switch"
+        android:title="@string/one_handed_mode_enabled"
+        settings:keywords="@string/keywords_one_handed"
+        settings:controller="com.android.settings.gestures.OneHandedMainSwitchPreferenceController"/>
 
-    <ListPreference
-        android:key="gesture_one_handed_timeout"
-        android:entries="@array/one_handed_timeout_title"
-        android:entryValues="@array/one_handed_timeout_values"
-        android:persistent="false"
-        android:title="@string/one_handed_timeout_title"
-        settings:controller="com.android.settings.gestures.OneHandedTimeoutPreferenceController"/>
+    <com.android.settingslib.widget.TopIntroPreference
+        android:key="gesture_one_handed_mode_intro_text"
+        android:title="@string/one_handed_mode_intro_text"/>
+
+    <PreferenceCategory
+        android:key="gesture_one_handed_mode_swipe_down"
+        android:title="@string/one_handed_mode_swipe_down_category">
+
+        <com.android.settingslib.widget.RadioButtonPreference
+            android:key="gesture_one_handed_action_pull_screen_down"
+            android:title="@string/one_handed_action_pull_down_screen_title"
+            android:summary="@string/one_handed_action_pull_down_screen_summary"
+            settings:controller="com.android.settings.gestures.OneHandedActionPullDownPrefController"/>
+
+        <com.android.settingslib.widget.RadioButtonPreference
+            android:key="gesture_one_handed_action_show_notification"
+            android:title="@string/one_handed_action_show_notification_title"
+            android:summary="@string/one_handed_action_show_notification_summary"
+            settings:controller="com.android.settings.gestures.OneHandedActionShowNotificationPrefController"/>
+
+    </PreferenceCategory>
 </PreferenceScreen>

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);
+        }
+    }
+}

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);
+        }
+    }
+}

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);
     }
 }

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;
+    }
+}

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

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);
+    }
+}

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);
+    }
+}

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());
-    }
 }

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);
+    }
+}