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 am: 5213fbced1 am: 7e61c806e9

Browse Source 
Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/apps/Settings/+/14804130

Change-Id: I0ba93c73c85b9c8120ed23fa3642921fe73fe87f
This commit is contained in:
Jason Chang
2021-06-12 12:06:55 +00:00
committed by Automerger Merge Worker
parent d5f53900ba 7e61c806e9
commit 3ab0d7b1b9
20 changed files with 574 additions and 868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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