PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topic "OHM-newUI-Sys-Gesture" into sc-dev

Browse Source 
* changes:
  Update key visual changes for one handed mode settings
  Remove redundant swipe down notification and one handed sub settings
This commit is contained in:
Jason Chang
2021-06-12 11:49:16 +00:00
committed by Android (Google) Code Review
parent 38df9ce8bb 76d6d66353
commit 5213fbced1
20 changed files with 574 additions and 868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
res/values/strings.xml
View File

@@ -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>

7
res/xml/gestures.xml
View File

@@ -33,13 +33,6 @@
settings:searchable="false"
settings:controller="com.android.settings.gestures.SwipeToNotificationPreferenceController" />
<Preference
android:key="gesture_swipe_bottom_to_notification"
android:title="@string/swipe_bottom_to_notifications_title"
android:fragment="com.android.settings.gestures.SwipeBottomToNotificationSettings"
settings:searchable="false"
settings:controller="com.android.settings.gestures.SwipeBottomToNotificationPreferenceController" />
<Preference
android:key="gesture_double_tap_power_input_summary"
android:title="@string/double_tap_power_for_camera_title"

43
res/xml/one_handed_settings.xml
View File

@@ -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>

38
res/xml/swipe_bottom_to_notification_settings.xml
View File

@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ Copyright (C) 2020 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.
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:settings="http://schemas.android.com/apk/res-auto"
android:title="@string/swipe_bottom_to_notifications_title">
<com.android.settingslib.widget.LayoutPreference
android:key="one_handed_header"
android:layout="@layout/one_handed_header"
android:persistent="false"
android:selectable="false"
settings:allowDividerBelow="false"
settings:searchable="false"/>
<SwitchPreference
android:key="gesture_swipe_bottom_to_notification"
android:title="@string/swipe_bottom_to_notifications_title"
android:summary="@string/swipe_bottom_to_notifications_summary"
settings:controller="com.android.settings.gestures.SwipeBottomToNotificationPreferenceController"
settings:allowDividerAbove="true" />
</PreferenceScreen>

69
src/com/android/settings/gestures/OneHandedAppTapsExitPreferenceController.java → src/com/android/settings/gestures/OneHandedActionPullDownPrefController.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 The Android Open Source Project
* 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.
@@ -22,61 +22,61 @@ import android.net.Uri;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.core.TogglePreferenceController;
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 app taps to exit of one-handed mode
*/
public class OneHandedAppTapsExitPreferenceController extends TogglePreferenceController implements
LifecycleObserver, OnStart, OnStop, OneHandedSettingsUtils.TogglesCallback {
* 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 OneHandedAppTapsExitPreferenceController(Context context, String key) {
public OneHandedActionPullDownPrefController(Context context, String key) {
super(context, key);
mUtils = new OneHandedSettingsUtils(context);
}
// By default, app taps to stop one-handed is enabled, this will get default value once.
OneHandedSettingsUtils.setTapsAppToExitEnabled(mContext, isChecked());
@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.isOneHandedModeEnabled(mContext)
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 updateState(Preference preference) {
super.updateState(preference);
final int availabilityStatus = getAvailabilityStatus();
preference.setEnabled(
availabilityStatus == AVAILABLE || availabilityStatus == AVAILABLE_UNSEARCHABLE);
}
@Override
public boolean setChecked(boolean isChecked) {
return OneHandedSettingsUtils.setTapsAppToExitEnabled(mContext, isChecked);
}
@Override
public boolean isChecked() {
return OneHandedSettingsUtils.isTapsAppToExitEnabled(mContext);
}
@Override
public void onStart() {
mUtils.registerToggleAwareObserver(this);
@@ -89,6 +89,13 @@ public class OneHandedAppTapsExitPreferenceController extends TogglePreferenceCo
@Override
public void onChange(Uri uri) {
updateState(mPreference);
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);
}
}
}

101
src/com/android/settings/gestures/OneHandedActionShowNotificationPrefController.java Normal file
View File

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

27
src/com/android/settings/gestures/OneHandedEnablePreferenceController.java
View File

@@ -19,38 +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 OneHandedSettingsUtils.isFeatureAvailable(mContext)
? AVAILABLE : UNSUPPORTED_ON_DEVICE;
}
@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);
}
}

56
src/com/android/settings/gestures/OneHandedMainSwitchPreferenceController.java Normal file
View File

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

40
src/com/android/settings/gestures/OneHandedSettingsUtils.java
View File

@@ -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
@@ -190,12 +211,17 @@ public class OneHandedSettingsUtils {
}
/**
*
* Check if One-handed mode settings controllers can enabled or disabled.
* @param context App context
* @return Support One-Handed mode feature or not.
* @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 isFeatureAvailable(Context context) {
return isSupportOneHandedMode() && getNavigationBarMode(context) != 0;
public static boolean canEnableController(Context context) {
return (OneHandedSettingsUtils.isOneHandedModeEnabled(context)
&& OneHandedSettingsUtils.getNavigationBarMode(context) != 0 /* 3-button mode */);
}
/**
@@ -218,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);
}
@@ -231,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

138
src/com/android/settings/gestures/OneHandedTimeoutPreferenceController.java
View File

@@ -1,138 +0,0 @@
/*
* Copyright (C) 2020 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.ListPreference;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
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 java.util.HashMap;
import java.util.Map;
/**
* The Controller to handle one-handed mode timeout state.
**/
public class OneHandedTimeoutPreferenceController extends BasePreferenceController implements
Preference.OnPreferenceChangeListener, LifecycleObserver, OnStart, OnStop,
OneHandedSettingsUtils.TogglesCallback {
private final Map<String, String> mTimeoutMap;
private final OneHandedSettingsUtils mUtils;
private Preference mTimeoutPreference;
public OneHandedTimeoutPreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeoutMap = new HashMap<>();
initTimeoutMap();
mUtils = new OneHandedSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)
? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public boolean onPreferenceChange(Preference preference, Object object) {
if (!(preference instanceof ListPreference)) {
return false;
}
final int newValue = Integer.parseInt((String) object);
OneHandedSettingsUtils.setTimeoutValue(mContext, newValue);
updateState(preference);
return true;
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
if (!(preference instanceof ListPreference)) {
return;
}
final ListPreference listPreference = (ListPreference) preference;
listPreference.setValue(getTimeoutValue());
final int availabilityStatus = getAvailabilityStatus();
preference.setEnabled(
availabilityStatus == AVAILABLE || availabilityStatus == AVAILABLE_UNSEARCHABLE);
}
@Override
public CharSequence getSummary() {
if (OneHandedSettingsUtils.getTimeoutValue(mContext) == 0) {
return mContext.getResources().getString(R.string.screensaver_settings_summary_never);
}
return String.format(mContext.getResources().getString(
R.string.screen_timeout_summary), mTimeoutMap.get(getTimeoutValue()));
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mTimeoutPreference = screen.findPreference(mPreferenceKey);
}
@Override
public void onStart() {
mUtils.registerToggleAwareObserver(this);
}
@Override
public void onStop() {
mUtils.unregisterToggleAwareObserver();
}
@Override
public void onChange(Uri uri) {
updateState(mTimeoutPreference);
}
private String getTimeoutValue() {
return String.valueOf(OneHandedSettingsUtils.getTimeoutValue(mContext));
}
private void initTimeoutMap() {
if (mTimeoutMap.size() != 0) {
return;
}
final String[] timeoutValues = mContext.getResources().getStringArray(
R.array.one_handed_timeout_values);
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
if (timeoutValues.length != timeoutTitles.length) {
return;
}
for (int i = 0; i < timeoutValues.length; i++) {
mTimeoutMap.put(timeoutValues[i], timeoutTitles[i]);
}
}
}

71
src/com/android/settings/gestures/SwipeBottomToNotificationPreferenceController.java
View File

@@ -1,71 +0,0 @@
/*
* Copyright (C) 2020 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.R;
import com.android.settings.core.TogglePreferenceController;
/**
* Handles swipe bottom to expand notification panel gesture.
**/
public class SwipeBottomToNotificationPreferenceController extends TogglePreferenceController {
public SwipeBottomToNotificationPreferenceController(Context context, String key) {
super(context, key);
}
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isFeatureAvailable(mContext)
? AVAILABLE : UNSUPPORTED_ON_DEVICE;
}
@Override
public boolean isSliceable() {
return true;
}
@Override
public boolean isPublicSlice() {
return true;
}
@Override
public boolean setChecked(boolean isChecked) {
if (isChecked) {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
}
OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, isChecked);
return true;
}
@Override
public boolean isChecked() {
return OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext);
}
@Override
public CharSequence getSummary() {
// This toggle preference summary will be updated in gesture preference page since we bound
// it with entry preference in gesture.xml
return mContext.getText(
isChecked() ? R.string.gesture_setting_on : R.string.gesture_setting_off);
}
}

59
src/com/android/settings/gestures/SwipeBottomToNotificationSettings.java
View File

@@ -1,59 +0,0 @@
/*
* Copyright (C) 2020 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.app.settings.SettingsEnums;
import android.content.Context;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
/**
* The Fragment for swipe bottom to notification gesture settings.
*/
public class SwipeBottomToNotificationSettings extends DashboardFragment {
private static final String TAG = "SwipeBottomToNotificationSettings";
@Override
public int getMetricsCategory() {
return SettingsEnums.SETTINGS_SWIPE_BOTTOM_TO_NOTIFICATION;
}
@Override
protected String getLogTag() {
return TAG;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.swipe_bottom_to_notification_settings;
}
public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider(R.xml.swipe_bottom_to_notification_settings) {
@Override
protected boolean isPageSearchEnabled(Context context) {
if (!OneHandedSettingsUtils.isSupportOneHandedMode()) {
return false;
}
return !OneHandedSettingsUtils.isOneHandedModeEnabled(context);
}
};
}

108
tests/robotests/src/com/android/settings/gestures/OneHandedActionPullDownPrefControllerTest.java Normal file
View File

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

107
tests/robotests/src/com/android/settings/gestures/OneHandedActionShowNotificationPrefControllerTest.java Normal file
View File

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

37
tests/robotests/src/com/android/settings/gestures/OneHandedEnablePreferenceControllerTest.java
View File

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

85
tests/robotests/src/com/android/settings/gestures/OneHandedMainSwitchPreferenceControllerTest.java Normal file
View File

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

111
tests/robotests/src/com/android/settings/gestures/OneHandedTimeoutPreferenceControllerTest.java
View File

@@ -1,111 +0,0 @@
/*
* Copyright (C) 2020 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.UserHandle;
import androidx.preference.ListPreference;
import com.android.settings.R;
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 OneHandedTimeoutPreferenceControllerTest {
private static final String KEY = "gesture_one_handed_timeout";
private Context mContext;
private OneHandedTimeoutPreferenceController mController;
private ListPreference mPreference;
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
mController = new OneHandedTimeoutPreferenceController(mContext, KEY);
mPreference = new ListPreference(mContext);
mPreference.setKey(KEY);
OneHandedSettingsUtils.setUserId(UserHandle.myUserId());
}
@Test
public void getAvailabilityStatus_enabledOneHanded_shouldAvailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_disableOneHanded_shouldUnavailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING);
}
@Test
public void updateState_enableOneHanded_switchShouldEnabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isTrue();
}
@Test
public void updateState_disableOneHanded_switchShouldDisabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isFalse();
}
@Test
public void getSummary_setTimeoutNever_shouldReturnNeverSummary() {
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
OneHandedSettingsUtils.setTimeoutValue(mContext,
OneHandedSettingsUtils.OneHandedTimeout.NEVER.getValue());
assertThat(mController.getSummary()).isEqualTo(
timeoutTitles[OneHandedSettingsUtils.OneHandedTimeout.NEVER.ordinal()]);
}
@Test
public void getSummary_setTimeoutShort_shouldReturnShortSummary() {
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
OneHandedSettingsUtils.setTimeoutValue(mContext,
OneHandedSettingsUtils.OneHandedTimeout.SHORT.getValue());
assertThat(mController.getSummary()).isEqualTo(String.format(
mContext.getResources().getString(R.string.screen_timeout_summary),
timeoutTitles[OneHandedSettingsUtils.OneHandedTimeout.SHORT.ordinal()]));
}
}

134
tests/robotests/src/com/android/settings/gestures/SwipeBottomToNotificationPreferenceControllerTest.java
View File

@@ -1,134 +0,0 @@
/*
* Copyright (C) 2020 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.android.settings.core.BasePreferenceController.AVAILABLE;
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;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class SwipeBottomToNotificationPreferenceControllerTest {
private static final String KEY = "gesture_swipe_bottom_to_notification";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private SwipeBottomToNotificationPreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mController = new SwipeBottomToNotificationPreferenceController(mContext, KEY);
}
@Test
public void setChecked_toggledOn_enablesSwipeBottomToNotification() {
mController.setChecked(true);
assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isTrue();
assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isFalse();
}
@Test
public void setChecked_toggledOff_disablesSwipeBottomToNotification() {
mController.setChecked(false);
assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isFalse();
}
@Test
public void getAvailabilityStatus_oneHandedUnsupported_returnsUnsupport() {
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_oneHandedSupported_returnsAvailable() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
setNavigationBarMode(mContext, "2" /* fully gestural */);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void getAvailabilityStatus_set3ButtonModeProperty_returnsUnsupport() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
setNavigationBarMode(mContext, "0" /* 3-button */);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getSummary_gestureEnabled_returnsOnSummary() {
mController.setChecked(true);
assertThat(mController.getSummary()).isEqualTo(
mContext.getText(R.string.gesture_setting_on));
}
@Test
public void getSummary_gestureDisabled_returnsOffSummary() {
mController.setChecked(false);
assertThat(mController.getSummary()).isEqualTo(
mContext.getText(R.string.gesture_setting_off));
}
@Test
public void isChecked_getDefaultConfig_returnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false");
Settings.Secure.resetToDefaults(mContext.getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_ENABLED);
assertThat(mController.isChecked()).isFalse();
}
/**
* 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());
}
}

102
tests/robotests/src/com/android/settings/gestures/SwipeBottomToNotificationSettingsTest.java
View File

@@ -1,102 +0,0 @@
/*
* Copyright (C) 2020 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.provider.SearchIndexableResource;
import com.android.settings.R;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.util.ReflectionHelpers;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
public class SwipeBottomToNotificationSettingsTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private SwipeBottomToNotificationSettings mSettings = new SwipeBottomToNotificationSettings();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void getPreferenceScreenResId_shouldReturnsXml() {
assertThat(mSettings.getPreferenceScreenResId())
.isEqualTo(R.xml.swipe_bottom_to_notification_settings);
}
@Test
public void searchIndexProvider_shouldIndexResource() {
final List<SearchIndexableResource> indexRes =
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(
mContext, true /* enabled */);
assertThat(indexRes.get(0).xmlResId).isEqualTo(mSettings.getPreferenceScreenResId());
}
@Test
public void isPageSearchEnabled_oneHandedUnsupported_shouldReturnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false");
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isFalse();
}
@Test
public void isPageSearchEnabled_oneHandedDisabled_shouldReturnTrue() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isTrue();
}
@Test
public void isPageSearchEnabled_oneHandedEnabled_shouldReturnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isFalse();
}
}

94
tests/unit/src/com/android/settings/gestures/OneHandedAppTapsExitPreferenceControllerTest.java
View File

@@ -1,94 +0,0 @@
/*
* Copyright (C) 2020 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.UserHandle;
import androidx.preference.SwitchPreference;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.android.settings.core.TogglePreferenceController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
public class OneHandedAppTapsExitPreferenceControllerTest {
private static final String KEY = "gesture_app_taps_to_exit";
private Context mContext;
private SwitchPreference mSwitchPreference;
private OneHandedAppTapsExitPreferenceController mController;
@Before
public void setUp() {
mContext = ApplicationProvider.getApplicationContext();
mController = new OneHandedAppTapsExitPreferenceController(mContext, KEY);
mSwitchPreference = new SwitchPreference(mContext);
mSwitchPreference.setKey(KEY);
OneHandedSettingsUtils.setUserId(UserHandle.myUserId());
}
@Test
public void setChecked_setBoolean_checkIsTrueOrFalse() {
mController.setChecked(false);
assertThat(mController.isChecked()).isFalse();
mController.setChecked(true);
assertThat(mController.isChecked()).isTrue();
}
@Test
public void getAvailabilityStatus_enabledOneHanded_shouldAvailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(TogglePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_disabledOneHanded_shouldUnavailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(TogglePreferenceController.DISABLED_DEPENDENT_SETTING);
}
@Test
public void updateState_enableOneHanded_switchShouldEnabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
mController.updateState(mSwitchPreference);
assertThat(mSwitchPreference.isEnabled()).isTrue();
}
@Test
public void updateState_disableOneHanded_switchShouldDisabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
mController.updateState(mSwitchPreference);
assertThat(mSwitchPreference.isEnabled()).isFalse();
}
}