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

Merge "Improve the UI of Press & hold power button settings" into tm-qpr-dev

Browse Source
This commit is contained in:
Peter Zhang
2022-07-25 17:18:25 +00:00
committed by Android (Google) Code Review
parent aea8f1aeb2 f0013da134
commit 1cc741a745
20 changed files with 1213 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
src/com/android/settings/gestures/LongPressPowerButtonPreferenceController.java
View File

@@ -1,196 +0,0 @@
/*
* 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.android.settings.gestures.PowerMenuSettingsUtils.LONG_PRESS_POWER_ASSISTANT_VALUE;
import static com.android.settings.gestures.PowerMenuSettingsUtils.LONG_PRESS_POWER_GLOBAL_ACTIONS;
import static com.android.settings.gestures.PowerMenuSettingsUtils.POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE;
import static com.android.settings.gestures.PowerMenuSettingsUtils.POWER_BUTTON_LONG_PRESS_SETTING;
import android.content.Context;
import android.provider.Settings;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
/**
* Configures the behaviour of long press power button action.
*/
public class LongPressPowerButtonPreferenceController extends TogglePreferenceController {
private static final String KEY_CHORD_POWER_VOLUME_UP_SETTING =
Settings.Global.KEY_CHORD_POWER_VOLUME_UP;
private static final String FOOTER_HINT_KEY = "power_menu_power_volume_up_hint";
private static final String ASSIST_SWITCH_KEY = "gesture_power_menu_long_press_for_assist";
/**
* Values used for volume key chord behaviour when Assist setting is enabled.
*
* Values based on config_keyChordPowerVolumeUp in
* frameworks/base/core/res/res/values/config.xml
*/
@VisibleForTesting
static final int KEY_CHORD_POWER_VOLUME_UP_NO_ACTION = 0;
@VisibleForTesting
static final int KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE = 1;
@VisibleForTesting
static final int KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS = 2;
private static final int KEY_CHORD_POWER_VOLUME_UP_DEFAULT_VALUE_RESOURCE =
com.android.internal.R.integer.config_keyChordPowerVolumeUp;
@MonotonicNonNull
@VisibleForTesting
Preference mFooterHint;
@MonotonicNonNull
@VisibleForTesting
Preference mAssistSwitch;
public LongPressPowerButtonPreferenceController(Context context, String key) {
super(context, key);
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mFooterHint = screen.findPreference(FOOTER_HINT_KEY);
mAssistSwitch = screen.findPreference(ASSIST_SWITCH_KEY);
refreshStateDisplay();
}
@Override
public CharSequence getSummary() {
final int powerButtonValue = PowerMenuSettingsUtils.getPowerButtonSettingValue(mContext);
if (powerButtonValue == LONG_PRESS_POWER_ASSISTANT_VALUE) {
return mContext.getString(R.string.power_menu_summary_long_press_for_assist_enabled);
} else if (powerButtonValue == LONG_PRESS_POWER_GLOBAL_ACTIONS) {
return mContext.getString(
R.string.power_menu_summary_long_press_for_assist_disabled_with_power_menu);
} else {
return mContext.getString(
R.string.power_menu_summary_long_press_for_assist_disabled_no_action);
}
}
@Override
public int getAvailabilityStatus() {
final boolean enabled = mContext.getResources().getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable);
return enabled ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
}
@Override
public boolean isChecked() {
return PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext);
}
@Override
public boolean setChecked(boolean isChecked) {
if (setPowerLongPressValue(isChecked)) {
// The key chord value is dependant on the long press setting and it always
// toggled in tandem. POWER_BUTTON_LONG_PRESS_SETTING is always the source
// of truth for both.
setPowerVolumeChordValue(isChecked);
refreshStateDisplay();
return true;
}
return false;
}
@Override
public int getSliceHighlightMenuRes() {
return R.string.menu_key_system;
}
private void refreshStateDisplay() {
if (mAssistSwitch != null) {
mAssistSwitch.setSummary(getSummary());
}
if (mFooterHint != null) {
String footerHintText = mContext.getString(R.string.power_menu_power_volume_up_hint);
// If the device supports hush gesture, we need to notify the user where to find
// the setting.
if (mContext.getResources().getBoolean(
com.android.internal.R.bool.config_volumeHushGestureEnabled)) {
footerHintText = footerHintText + "\n\n" + mContext.getString(
R.string.power_menu_power_prevent_ringing_hint);
}
mFooterHint.setSummary(footerHintText);
mFooterHint.setVisible(isPowerMenuKeyChordEnabled(mContext));
}
}
private static boolean isPowerMenuKeyChordEnabled(Context context) {
return Settings.Global.getInt(context.getContentResolver(),
KEY_CHORD_POWER_VOLUME_UP_SETTING,
context.getResources().getInteger(
com.android.internal.R.integer.config_keyChordPowerVolumeUp))
== KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS;
}
private boolean setPowerLongPressValue(boolean isChecked) {
if (isChecked) {
return Settings.Global.putInt(mContext.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING, LONG_PRESS_POWER_ASSISTANT_VALUE);
}
// We need to determine the right disabled value based on the device default
// for long-press power.
// If the default is to start the assistant, then the fallback is GlobalActions.
final int defaultPowerButtonValue = mContext.getResources().getInteger(
POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE);
if (defaultPowerButtonValue == LONG_PRESS_POWER_ASSISTANT_VALUE) {
return Settings.Global.putInt(mContext.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING, LONG_PRESS_POWER_GLOBAL_ACTIONS);
}
// If the default is something different than Assist, we use that default.
return Settings.Global.putInt(mContext.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING, defaultPowerButtonValue);
}
/**
* Updates {@link Settings.Global.KEY_CHORD_POWER_VOLUME_UP} based on the changed value of
* {@link #POWER_BUTTON_LONG_PRESS_SETTING}. If power button is used for Assist, key chord
* should show the power menu.
*/
private boolean setPowerVolumeChordValue(boolean isPowerButtonLongPressChecked) {
if (isPowerButtonLongPressChecked) {
return Settings.Global.putInt(mContext.getContentResolver(),
KEY_CHORD_POWER_VOLUME_UP_SETTING, KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS);
}
// We restore key chord to the default value.
int keyChordDefaultValue = mContext.getResources().getInteger(
KEY_CHORD_POWER_VOLUME_UP_DEFAULT_VALUE_RESOURCE);
return Settings.Global.putInt(mContext.getContentResolver(),
KEY_CHORD_POWER_VOLUME_UP_SETTING, keyChordDefaultValue);
}
}

92
src/com/android/settings/gestures/LongPressPowerFooterPreferenceController.java Normal file
View File

@@ -0,0 +1,92 @@
/*
* Copyright (C) 2022 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 android.text.TextUtils;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
/** Configures the behaviour of long press power footer. */
public class LongPressPowerFooterPreferenceController extends BasePreferenceController
implements PowerMenuSettingsUtils.SettingsStateCallback, LifecycleObserver {
private Preference mPreference;
private final PowerMenuSettingsUtils mUtils;
public LongPressPowerFooterPreferenceController(Context context, String key) {
super(context, key);
mUtils = new PowerMenuSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return AVAILABLE;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
CharSequence footerHintText = mContext.getString(R.string.power_menu_power_volume_up_hint);
// If the device supports hush gesture, we need to tell the user where to find the setting.
if (mContext.getResources()
.getBoolean(com.android.internal.R.bool.config_volumeHushGestureEnabled)) {
footerHintText =
TextUtils.concat(
footerHintText,
"\n\n",
mContext.getString(R.string.power_menu_power_prevent_ringing_hint));
}
preference.setSummary(footerHintText);
preference.setVisible(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext));
}
@Override
public void onChange(Uri uri) {
if (mPreference != null) {
updateState(mPreference);
}
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_START) */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
mUtils.registerObserver(this);
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_STOP) */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
mUtils.unregisterObserver();
}
}

100
src/com/android/settings/gestures/LongPressPowerForAssistantPreferenceController.java Normal file
View File

@@ -0,0 +1,100 @@
/*
* Copyright (C) 2022 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.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.SelectorWithWidgetPreference;
/**
* Configures the behaviour of the radio selector to configure long press power button to Assistant.
*/
public class LongPressPowerForAssistantPreferenceController extends BasePreferenceController
implements PowerMenuSettingsUtils.SettingsStateCallback,
SelectorWithWidgetPreference.OnClickListener,
LifecycleObserver {
private SelectorWithWidgetPreference mPreference;
private final PowerMenuSettingsUtils mUtils;
public LongPressPowerForAssistantPreferenceController(Context context, String key) {
super(context, key);
mUtils = new PowerMenuSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
if (mPreference != null) {
mPreference.setOnClickListener(this);
}
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
if (preference instanceof SelectorWithWidgetPreference) {
((SelectorWithWidgetPreference) preference)
.setChecked(
PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext));
}
}
@Override
public void onRadioButtonClicked(SelectorWithWidgetPreference preference) {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
if (mPreference != null) {
updateState(mPreference);
}
}
@Override
public void onChange(Uri uri) {
if (mPreference != null) {
updateState(mPreference);
}
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_START) */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
mUtils.registerObserver(this);
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_STOP) */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
mUtils.unregisterObserver();
}
}

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

@@ -0,0 +1,101 @@
/*
* Copyright (C) 2022 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.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.SelectorWithWidgetPreference;
/**
* Configures the behaviour of the radio selector to configure long press power button to Power
* Menu.
*/
public class LongPressPowerForPowerMenuPreferenceController extends BasePreferenceController
implements PowerMenuSettingsUtils.SettingsStateCallback,
SelectorWithWidgetPreference.OnClickListener,
LifecycleObserver {
private SelectorWithWidgetPreference mPreference;
private final PowerMenuSettingsUtils mUtils;
public LongPressPowerForPowerMenuPreferenceController(Context context, String key) {
super(context, key);
mUtils = new PowerMenuSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
if (mPreference != null) {
mPreference.setOnClickListener(this);
}
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
if (preference instanceof SelectorWithWidgetPreference) {
((SelectorWithWidgetPreference) preference)
.setChecked(
!PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext));
}
}
@Override
public void onRadioButtonClicked(SelectorWithWidgetPreference preference) {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
if (mPreference != null) {
updateState(mPreference);
}
}
@Override
public void onChange(Uri uri) {
if (mPreference != null) {
updateState(mPreference);
}
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_START) */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
mUtils.registerObserver(this);
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_STOP) */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
mUtils.unregisterObserver();
}
}

84
src/com/android/settings/gestures/LongPressPowerIllustrationPreferenceController.java Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (C) 2022 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.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.IllustrationPreference;
/** Configures the behaviour of long press power illustration. */
public class LongPressPowerIllustrationPreferenceController extends BasePreferenceController
implements PowerMenuSettingsUtils.SettingsStateCallback, LifecycleObserver {
private IllustrationPreference mIllustrationPreference;
private final PowerMenuSettingsUtils mUtils;
public LongPressPowerIllustrationPreferenceController(Context context, String key) {
super(context, key);
mUtils = new PowerMenuSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return AVAILABLE;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mIllustrationPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
((IllustrationPreference) preference)
.setLottieAnimationResId(
PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)
? R.raw.lottie_long_press_power_for_assistant
: R.raw.lottie_long_press_power_for_power_menu);
}
@Override
public void onChange(Uri uri) {
if (mIllustrationPreference != null) {
updateState(mIllustrationPreference);
}
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_START) */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
mUtils.registerObserver(this);
}
/** @OnLifecycleEvent(Lifecycle.Event.ON_STOP) */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
mUtils.unregisterObserver();
}
}

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

@@ -17,37 +17,28 @@
package com.android.settings.gestures;
import android.content.Context;
import android.database.ContentObserver;
import android.os.Handler;
import android.net.Uri;
import android.provider.Settings;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.core.SliderPreferenceController;
import com.android.settings.widget.LabeledSeekBarPreference;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnStart;
import com.android.settingslib.core.lifecycle.events.OnStop;
/** Handles changes to the long press power button sensitivity slider. */
public class LongPressPowerSensitivityPreferenceController extends
SliderPreferenceController implements
LifecycleObserver, OnStart, OnStop {
private final ContentObserver mPowerButtonObserver = new ContentObserver(Handler.getMain()) {
@Override
public void onChange(boolean selfChange) {
if (mPreference != null) {
updateState(mPreference);
}
}
};
public class LongPressPowerSensitivityPreferenceController extends SliderPreferenceController
implements PowerMenuSettingsUtils.SettingsStateCallback, LifecycleObserver {
@Nullable
private final int[] mSensitivityValues;
private final PowerMenuSettingsUtils mUtils;
@Nullable
private LabeledSeekBarPreference mPreference;
@@ -55,18 +46,19 @@ public class LongPressPowerSensitivityPreferenceController extends
super(context, preferenceKey);
mSensitivityValues = context.getResources().getIntArray(
com.android.internal.R.array.config_longPressOnPowerDurationSettings);
mUtils = new PowerMenuSettingsUtils(context);
}
@Override
/** @OnLifecycleEvent(Lifecycle.Event.ON_START) */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
mContext.getContentResolver().registerContentObserver(
Settings.Global.getUriFor(PowerMenuSettingsUtils.POWER_BUTTON_LONG_PRESS_SETTING),
false, mPowerButtonObserver);
mUtils.registerObserver(this);
}
@Override
/** @OnLifecycleEvent(Lifecycle.Event.ON_STOP) */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
mContext.getContentResolver().unregisterContentObserver(mPowerButtonObserver);
mUtils.unregisterObserver();
}
@Override
@@ -86,21 +78,19 @@ public class LongPressPowerSensitivityPreferenceController extends
public void updateState(Preference preference) {
super.updateState(preference);
final LabeledSeekBarPreference pref = (LabeledSeekBarPreference) preference;
pref.setEnabled(
isAvailable() && PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext));
pref.setVisible(
PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)
&& getAvailabilityStatus() == AVAILABLE);
pref.setProgress(getSliderPosition());
}
@Override
public int getAvailabilityStatus() {
if (mSensitivityValues == null || mSensitivityValues.length < 2) {
if (mSensitivityValues == null
|| mSensitivityValues.length < 2
|| !PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)) {
return UNSUPPORTED_ON_DEVICE;
}
if (!PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext)) {
return DISABLED_DEPENDENT_SETTING;
}
return AVAILABLE;
}
@@ -120,6 +110,13 @@ public class LongPressPowerSensitivityPreferenceController extends
mSensitivityValues[position]);
}
@Override
public void onChange(Uri uri) {
if (mPreference != null) {
updateState(mPreference);
}
}
@Override
public int getMax() {
if (mSensitivityValues == null || mSensitivityValues.length == 0) {

23
src/com/android/settings/gestures/PowerMenuPreferenceController.java
View File

@@ -16,9 +16,6 @@
package com.android.settings.gestures;
import static com.android.settings.gestures.PowerMenuSettingsUtils.LONG_PRESS_POWER_ASSISTANT_VALUE;
import static com.android.settings.gestures.PowerMenuSettingsUtils.LONG_PRESS_POWER_GLOBAL_ACTIONS;
import android.content.Context;
import com.android.settings.R;
@@ -32,25 +29,17 @@ public class PowerMenuPreferenceController extends BasePreferenceController {
@Override
public CharSequence getSummary() {
final int powerButtonValue = PowerMenuSettingsUtils.getPowerButtonSettingValue(mContext);
if (powerButtonValue == LONG_PRESS_POWER_ASSISTANT_VALUE) {
return mContext.getText(R.string.power_menu_summary_long_press_for_assist_enabled);
} else if (powerButtonValue == LONG_PRESS_POWER_GLOBAL_ACTIONS) {
return mContext.getText(
R.string.power_menu_summary_long_press_for_assist_disabled_with_power_menu);
if (PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)) {
return mContext.getText(R.string.power_menu_summary_long_press_for_assistant);
} else {
return mContext.getText(
R.string.power_menu_summary_long_press_for_assist_disabled_no_action);
return mContext.getText(R.string.power_menu_summary_long_press_for_power_menu);
}
}
@Override
public int getAvailabilityStatus() {
return isAssistInvocationAvailable() ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
}
private boolean isAssistInvocationAvailable() {
return mContext.getResources().getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable);
return PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
}

154
src/com/android/settings/gestures/PowerMenuSettingsUtils.java
View File

@@ -16,53 +16,163 @@
package com.android.settings.gestures;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.Settings;
/** Common code for long press power settings shared between controllers. */
final class PowerMenuSettingsUtils {
/**
* Setting storing the current behaviour of long press power.
*/
public static final String POWER_BUTTON_LONG_PRESS_SETTING =
/** Setting storing the current behaviour of long press power. */
private static final String POWER_BUTTON_LONG_PRESS_SETTING =
Settings.Global.POWER_BUTTON_LONG_PRESS;
/** Setting storing the current behaviour of key chord power + volume up. */
private static final String KEY_CHORD_POWER_VOLUME_UP_SETTING =
Settings.Global.KEY_CHORD_POWER_VOLUME_UP;
/**
* Value used for long press power button behaviour when the Assist setting is disabled.
* Value used for long press power button behaviour when long press power for Assistant is
* disabled.
*
* If this value matches Assist setting, then it falls back to Global Actions panel or
* power menu, depending on their respective settings.
* <p>If this value matches long press power for Assistant, then it falls back to Global Actions
* panel (i.e., the Power Menu), depending on their respective settings.
*/
public static final int POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE =
private static final int POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE =
com.android.internal.R.integer.config_longPressOnPowerBehavior;
/**
* Values used for long press power button behaviour when Assist setting is enabled.
*
* {@link com.android.server.policy.PhoneWindowManager#LONG_PRESS_POWER_GLOBAL_ACTIONS} for
* source of the value.
* Value used for key chord power + volume up behaviour when long press power for Assistant is
* disabled.
*/
static final int LONG_PRESS_POWER_NO_ACTION = 0;
static final int LONG_PRESS_POWER_GLOBAL_ACTIONS = 1;
static final int LONG_PRESS_POWER_ASSISTANT_VALUE = 5; // Settings.Secure.ASSISTANT
private static final int KEY_CHORD_POWER_VOLUME_UP_DEFAULT_VALUE_RESOURCE =
com.android.internal.R.integer.config_keyChordPowerVolumeUp;
private static final int LONG_PRESS_POWER_GLOBAL_ACTIONS = 1; // a.k.a., Power Menu
private static final int LONG_PRESS_POWER_ASSISTANT_VALUE = 5; // Settings.Secure.ASSISTANT
private static final int KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS = 2;
private static final Uri POWER_BUTTON_LONG_PRESS_URI =
Settings.Global.getUriFor(POWER_BUTTON_LONG_PRESS_SETTING);
/**
* @return current value of power button behaviour.
* @return true if long press power for assistant is currently enabled.
*/
public static int getPowerButtonSettingValue(Context context) {
return Settings.Global.getInt(context.getContentResolver(),
public static boolean isLongPressPowerForAssistantEnabled(Context context) {
int longPressPowerSettingValue = Settings.Global.getInt(
context.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING,
context.getResources().getInteger(POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE));
return longPressPowerSettingValue == LONG_PRESS_POWER_ASSISTANT_VALUE;
}
/**
* @return true if long press power for assist is currently enabled.
* @return true if long press power for assistant setting is available on the device.
*/
public static boolean isLongPressPowerForAssistEnabled(Context context) {
return getPowerButtonSettingValue(context) == LONG_PRESS_POWER_ASSISTANT_VALUE;
public static boolean isLongPressPowerSettingAvailable(Context context) {
if (!context.getResources().getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable)) {
return false;
}
int defaultLongPressPowerSettingValue =
context.getResources().getInteger(POWER_BUTTON_LONG_PRESS_DEFAULT_VALUE_RESOURCE);
switch (defaultLongPressPowerSettingValue) {
case LONG_PRESS_POWER_GLOBAL_ACTIONS:
case LONG_PRESS_POWER_ASSISTANT_VALUE:
// We support switching between Power Menu and Digital Assistant.
return true;
default:
// All other combinations are not supported.
return false;
}
}
private PowerMenuSettingsUtils() {
public static boolean setLongPressPowerForAssistant(Context context) {
if (Settings.Global.putInt(
context.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING,
LONG_PRESS_POWER_ASSISTANT_VALUE)) {
// Make power + volume up buttons to open the power menu
Settings.Global.putInt(
context.getContentResolver(),
KEY_CHORD_POWER_VOLUME_UP_SETTING,
KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS);
return true;
}
return false;
}
public static boolean setLongPressPowerForPowerMenu(Context context) {
if (Settings.Global.putInt(
context.getContentResolver(),
POWER_BUTTON_LONG_PRESS_SETTING,
LONG_PRESS_POWER_GLOBAL_ACTIONS)) {
// We restore power + volume up buttons to the default action.
int keyChordDefaultValue =
context.getResources()
.getInteger(KEY_CHORD_POWER_VOLUME_UP_DEFAULT_VALUE_RESOURCE);
Settings.Global.putInt(
context.getContentResolver(),
KEY_CHORD_POWER_VOLUME_UP_SETTING,
keyChordDefaultValue);
return true;
}
return false;
}
private final Context mContext;
private final SettingsObserver mSettingsObserver;
PowerMenuSettingsUtils(Context context) {
mContext = context;
mSettingsObserver = new SettingsObserver(new Handler(Looper.getMainLooper()));
}
/**
* Registers callback for observing SettingsProvider state.
*
* @param callback for state changes
*/
public void registerObserver(SettingsStateCallback callback) {
mSettingsObserver.setCallback(callback);
final ContentResolver resolver = mContext.getContentResolver();
resolver.registerContentObserver(POWER_BUTTON_LONG_PRESS_URI, true, mSettingsObserver);
}
/** Unregisters callback for observing SettingsProvider state. */
public void unregisterObserver() {
final ContentResolver resolver = mContext.getContentResolver();
resolver.unregisterContentObserver(mSettingsObserver);
}
/** An interface for when SettingsProvider key state changes. */
public interface SettingsStateCallback {
/** Callback method for SettingsProvider key state changes. */
void onChange(Uri uri);
}
private static final class SettingsObserver extends ContentObserver {
private SettingsStateCallback mCallback;
SettingsObserver(Handler handler) {
super(handler);
}
private void setCallback(SettingsStateCallback callback) {
mCallback = callback;
}
@Override
public void onChange(boolean selfChange, Uri uri) {
if (mCallback != null) {
mCallback.onChange(uri);
}
}
}
}