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

Improve the UI of Press & hold power button settings

Browse Source 
The following changes has been made:
- The on/off toggle for Assistant now becomes two radio selectors ("Power Menu" and "Digital Assistant"). This is to make things clearer that Press & hold power button can be configured to power menu.
- The corresponding power menu animation will be shown when "Power Menu" is selected.
- The Assistant specific sensitivity settings and the foot notes are hidden when "Power Menu" is selected.
- Some minor wording updates according to the requests from Assistant / Settings UXW.

Bug: 229722937
Test: robotest, manual
Change-Id: Ib356fba861ad8c4a2626a0e0bd8cf3e4d90ce9a6
This commit is contained in:
Peter Zhang
2022-07-15 16:00:22 +02:00
parent 51d087cd67
commit f0013da134
20 changed files with 1213 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
res/raw/lottie_power_menu.json → res/raw/lottie_long_press_power_for_assistant.json
View File

1
res/raw/lottie_long_press_power_for_power_menu.json Normal file
View File

File diff suppressed because one or more lines are too long

35
res/values/strings.xml
View File

@@ -12741,7 +12741,7 @@
<!-- Summary for prevent ringing setting -->
<string name="prevent_ringing_option_mute_summary">Mute</string>
<!-- Summary for prevent ringing setting when the option itself is unavailable. [CHAR LIMIT=NONE] -->
<string name="prevent_ringing_option_unavailable_lpp_summary">To enable, first change \"Press and hold power button\" to the power menu.</string>
<string name="prevent_ringing_option_unavailable_lpp_summary">To enable, first change \"Press &amp; hold power button\" to the power menu.</string>
<!-- Title for detail page of wifi network [CHAR LIMIT=30] -->
<string name="pref_title_network_details">Network details</string>
@@ -13500,29 +13500,28 @@
<!-- Cards and passes name lower case [CHAR LIMIT=40] -->
<string name="cards_passes_lower">cards &amp; passes</string>
<!-- Power menu setting name [CHAR LIMIT=NONE] -->
<string name="power_menu_setting_name">Press and hold power button</string>
<!-- Power menu setting name [CHAR LIMIT=60] -->
<string name="power_menu_setting_name">Press &amp; hold power button</string>
<!-- Power menu setting summary to describe press and hold power button for Assistant is enabled. [CHAR LIMIT=NONE] -->
<string name="power_menu_summary_long_press_for_assist_enabled">Press and hold for the Assistant</string>
<!-- Power menu setting summary to describe press and hold power button for Assistant is disabled and power menu will appear. [CHAR LIMIT=NONE] -->
<string name="power_menu_summary_long_press_for_assist_disabled_with_power_menu">Press and hold for the power menu</string>
<!-- Power menu setting summary to describe press and hold power button for Assistant is disabled and nothing will happen. [CHAR LIMIT=NONE] -->
<string name="power_menu_summary_long_press_for_assist_disabled_no_action">Press and hold disabled</string>
<!-- Power menu setting section title for selecting the press and hold power button behavior. [CHAR LIMIT=60] -->
<string name="power_menu_long_press_category_title">Press &amp; hold power button to access</string>
<!-- Power menu setting option to make press and hold power button to open Power Menu. [CHAR LIMIT=60] -->
<string name="power_menu_long_press_for_power_menu_title">Power menu</string>
<!-- Power menu setting option to make press and hold power button to open Assistant. [CHAR LIMIT=60] -->
<string name="power_menu_long_press_for_assistant_title">Digital assistant</string>
<!-- Power menu setting summary to describe press and hold power button will open Assistant. [CHAR LIMIT=NONE] -->
<string name="power_menu_summary_long_press_for_assistant">Access digital assistant</string>
<!-- Power menu setting summary to describe press and hold power button will open Power Menu. [CHAR LIMIT=NONE] -->
<string name="power_menu_summary_long_press_for_power_menu">Access power menu</string>
<!-- Power menu setting privacy no secure screen lock set [CHAR_LIMIT=NONE] -->
<string name="lockscreen_privacy_not_secure">To use, first set a screen lock</string>
<!-- Power menu setting use long press power to invoke assistant. [CHAR LIMIT=NONE] -->
<string name="power_menu_long_press_for_assist">Hold for Assistant</string>
<!-- Power menu setting use log press power to invoke assistant summary. [CHAR LIMIT=NONE] -->
<string name="power_menu_long_press_for_assist_summary">Trigger the Assistant by holding the power button</string>
<!-- Power menu explanation to press power and volume up to show power and emergency menu. [CHAR LIMIT=NONE] -->
<string name="power_menu_power_volume_up_hint">Power &amp; Emergency Menu:\nPress Power and Volume up at the same time.</string>
<!-- Power menu explanation to press power and volume up to show power menu. [CHAR LIMIT=NONE] -->
<string name="power_menu_power_volume_up_hint">Power menu:\nPress the power button and the volume up button at the same time</string>
<!-- Power menu explanation where to find prevent ringing option. [CHAR LIMIT=NONE] -->
<string name="power_menu_power_prevent_ringing_hint">Prevent ringing:\nShortcut available in the volume menu.</string>
<string name="power_menu_power_prevent_ringing_hint">Prevent ringing:\nPress a volume button for the shortcut</string>
<!-- Power menu title of the seekbar setting controlling duration of how long the power button must be held to invoke assistant. [CHAR LIMIT=NONE]-->
<string name="power_menu_long_press_for_assist_sensitivity_title">Press &amp; hold duration</string>

26
res/xml/power_menu_settings.xml
View File

@@ -23,19 +23,28 @@
android:key="gesture_power_menu_video"
settings:searchable="false"
settings:lottie_imageAssetsFolder="power_menu"
settings:lottie_rawRes="@raw/lottie_power_menu"/>
settings:lottie_rawRes="@raw/lottie_long_press_power_for_power_menu"
settings:controller="com.android.settings.gestures.LongPressPowerIllustrationPreferenceController"/>
<SwitchPreference
android:key="gesture_power_menu_long_press_for_assist"
android:title="@string/power_menu_long_press_for_assist"
android:summary="@string/power_menu_long_press_for_assist_summary"
settings:controller="com.android.settings.gestures.LongPressPowerButtonPreferenceController"
/>
<PreferenceCategory
android:key="gesture_power_menu_long_press_category"
android:title="@string/power_menu_long_press_category_title">
<com.android.settingslib.widget.SelectorWithWidgetPreference
android:key="gesture_power_menu_long_press_for_power_menu"
android:title="@string/power_menu_long_press_for_power_menu_title"
settings:controller="com.android.settings.gestures.LongPressPowerForPowerMenuPreferenceController"/>
<com.android.settingslib.widget.SelectorWithWidgetPreference
android:key="gesture_power_menu_long_press_for_assistant"
android:title="@string/power_menu_long_press_for_assistant_title"
settings:controller="com.android.settings.gestures.LongPressPowerForAssistantPreferenceController"/>
</PreferenceCategory>
<com.android.settings.widget.LabeledSeekBarPreference
android:key="gesture_power_menu_long_press_for_assist_sensitivity"
android:title="@string/power_menu_long_press_for_assist_sensitivity_title"
android:summary="@string/power_menu_long_press_for_assist_sensitivity_summary"
settings:allowDividerAbove="true"
settings:textStart="@string/power_menu_long_press_for_assist_sensitivity_low_label"
settings:textEnd="@string/power_menu_long_press_for_assist_sensitivity_high_label"
settings:controller="com.android.settings.gestures.LongPressPowerSensitivityPreferenceController"
@@ -45,5 +54,6 @@
android:key="power_menu_power_volume_up_hint"
android:title="@string/power_menu_power_volume_up_hint"
android:selectable="false"
settings:searchable="false"/>
settings:searchable="false"
settings:controller="com.android.settings.gestures.LongPressPowerFooterPreferenceController"/>
</PreferenceScreen>

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

220
tests/robotests/src/com/android/settings/gestures/LongPressPowerButtonPreferenceControllerTest.java
View File

@@ -1,220 +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.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.app.Application;
import android.content.res.Resources;
import android.provider.Settings;
import androidx.annotation.StringRes;
import androidx.preference.Preference;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.R;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.mockito.stubbing.Answer;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class LongPressPowerButtonPreferenceControllerTest {
private static final String KEY_LONG_PRESS_POWER_BUTTON =
"gesture_power_menu_long_press_for_assist";
private Application mContext;
private Resources mResources;
private LongPressPowerButtonPreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = mock(Resources.class);
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getString(anyInt())).thenAnswer((Answer<String>) invocation -> {
int id = invocation.getArgument(0);
return getString(id);
});
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
mController = new LongPressPowerButtonPreferenceController(mContext,
KEY_LONG_PRESS_POWER_BUTTON);
mController.mAssistSwitch = mock(Preference.class);
mController.mFooterHint = mock(Preference.class);
}
@Test
public void isAvailable_configIsTrue_shouldReturnTrue() {
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_configIsFalse_shouldReturnFalse() {
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void preferenceChecked_powerMenuHintTextShown() {
mController.onPreferenceChange(null, true);
verify(mController.mFooterHint).setSummary(
getString(
R.string.power_menu_power_volume_up_hint));
verify(mController.mFooterHint).setVisible(true);
}
@Test
public void preferenceUnchecked_keyChordEnabled_powerMenuHintTextShown() {
when(mResources.getInteger(
com.android.internal.R.integer.config_keyChordPowerVolumeUp))
.thenReturn(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS);
mController.onPreferenceChange(null, false);
verify(mController.mFooterHint).setSummary(
getString(
R.string.power_menu_power_volume_up_hint));
verify(mController.mFooterHint).setVisible(true);
}
@Test
public void preferenceChecked_hushGestureEnabled_powerMenuHintTextIncludesHushHint() {
when(mResources.getBoolean(
com.android.internal.R.bool.config_volumeHushGestureEnabled))
.thenReturn(true);
mController.onPreferenceChange(null, true);
verify(mController.mFooterHint).setSummary(
getString(
R.string.power_menu_power_volume_up_hint) + "\n\n"
+ getString(
R.string.power_menu_power_prevent_ringing_hint));
verify(mController.mFooterHint).setVisible(true);
}
@Test
public void preferenceUnchecked_keyChordDisabled_powerMenuHintTextHidden() {
mController.onPreferenceChange(null, false);
when(mResources.getInteger(
com.android.internal.R.integer.config_keyChordPowerVolumeUp))
.thenReturn(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_NO_ACTION);
verify(mController.mFooterHint).setVisible(false);
}
@Test
public void preferenceChecked_longPressPowerSettingSetToAssistant() {
mController.onPreferenceChange(null, true);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, -1)).isEqualTo(
PowerMenuSettingsUtils.LONG_PRESS_POWER_ASSISTANT_VALUE);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP, -1)).isEqualTo(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_GLOBAL_ACTIONS);
}
@Test
public void preferenceUnchecked_longPressPowerSettingSetToDefaultValue() {
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(
PowerMenuSettingsUtils.LONG_PRESS_POWER_GLOBAL_ACTIONS);
mController.onPreferenceChange(null, false);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, -1)).isEqualTo(
PowerMenuSettingsUtils.LONG_PRESS_POWER_GLOBAL_ACTIONS);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP, -1)).isEqualTo(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_NO_ACTION);
verify(mController.mAssistSwitch).setSummary(
getString(
R.string.power_menu_summary_long_press_for_assist_disabled_with_power_menu));
}
@Test
public void preferenceUnchecked_muteChordDefault_longPressPowerSettingSetToDefaultValue() {
// Value out of range chosen deliberately.
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(8);
when(mResources.getInteger(
com.android.internal.R.integer.config_keyChordPowerVolumeUp))
.thenReturn(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE);
mController.onPreferenceChange(null, false);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, -1)).isEqualTo(8);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP, -1)).isEqualTo(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_MUTE_TOGGLE);
}
@Test
public void preferenceUnchecked_assistDefault_setNoAction() {
// Ensure that the Assistant is the default behavior for LPP.
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(
PowerMenuSettingsUtils.LONG_PRESS_POWER_ASSISTANT_VALUE);
mController.onPreferenceChange(null, false);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, -1)).isEqualTo(
PowerMenuSettingsUtils.LONG_PRESS_POWER_GLOBAL_ACTIONS);
assertThat(Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP, -1)).isEqualTo(
LongPressPowerButtonPreferenceController.KEY_CHORD_POWER_VOLUME_UP_NO_ACTION);
verify(mController.mAssistSwitch).setSummary(getString(
R.string.power_menu_summary_long_press_for_assist_disabled_with_power_menu));
}
private String getString(@StringRes int id) {
return ApplicationProvider.getApplicationContext().getString(id);
}
}

115
tests/robotests/src/com/android/settings/gestures/LongPressPowerFooterPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,115 @@
/*
* 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 static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.app.Application;
import android.content.res.Resources;
import android.text.TextUtils;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.R;
import com.android.settingslib.widget.FooterPreference;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class LongPressPowerFooterPreferenceControllerTest {
private Application mContext;
private Resources mResources;
private Preference mPreference;
private LongPressPowerFooterPreferenceController mController;
@Before
public void setUp() {
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = spy(mContext.getResources());
when(mContext.getResources()).thenReturn(mResources);
mPreference = new FooterPreference(mContext);
mController = new LongPressPowerFooterPreferenceController(mContext, "test_key");
PreferenceScreen mScreen = mock(PreferenceScreen.class);
when(mScreen.findPreference("test_key")).thenReturn(mPreference);
mController.displayPreference(mScreen);
}
@Test
public void updateState_longPressPowerForPowerMenu_hidesPreference() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isVisible()).isFalse();
}
@Test
public void updateState_longPressPowerForAssistant_showsPreference() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isVisible()).isTrue();
}
@Test
public void updateState_notEligible_showsPreference() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isVisible()).isTrue();
}
@Test
public void updateState_hushGestureEnabled_includesPreventRingingHint() {
when(mResources.getBoolean(com.android.internal.R.bool.config_volumeHushGestureEnabled))
.thenReturn(true);
mController.updateState(mPreference);
assertThat(mPreference.getSummary().toString())
.isEqualTo(
TextUtils.concat(
mContext.getString(R.string.power_menu_power_volume_up_hint),
"\n\n",
mContext.getString(
R.string.power_menu_power_prevent_ringing_hint)));
}
@Test
public void updateState_hushGestureDisabled_doesNotIncludePreventRingingHint() {
when(mResources.getBoolean(com.android.internal.R.bool.config_volumeHushGestureEnabled))
.thenReturn(false);
mController.updateState(mPreference);
assertThat(mPreference.getSummary().toString())
.isEqualTo(mContext.getString(R.string.power_menu_power_volume_up_hint));
}
}

116
tests/robotests/src/com/android/settings/gestures/LongPressPowerForAssistantPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,116 @@
/*
* 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 static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.app.Application;
import android.content.res.Resources;
import androidx.preference.PreferenceScreen;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.SelectorWithWidgetPreference;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class LongPressPowerForAssistantPreferenceControllerTest {
private Application mContext;
private Resources mResources;
private SelectorWithWidgetPreference mPreference;
private LongPressPowerForAssistantPreferenceController mController;
@Before
public void setUp() {
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = spy(mContext.getResources());
mPreference = new SelectorWithWidgetPreference(mContext);
mController = new LongPressPowerForAssistantPreferenceController(mContext, "test_key");
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(5); // Default to Assistant
PreferenceScreen mScreen = mock(PreferenceScreen.class);
when(mScreen.findPreference("test_key")).thenReturn(mPreference);
mController.displayPreference(mScreen);
mController.onStart();
}
@Test
public void initialState_longPressPowerForPowerMenu_preferenceNotChecked() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isFalse();
}
@Test
public void initialState_longPressPowerForAssistant_preferenceChecked() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isTrue();
}
@Test
public void getAvailabilityStatus_longPressPowerSettingAvailable_returnsAvailable() {
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_longPressPowerSettingNotAvailable_returnsNotAvailable() {
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void onClick_updatesSettingsValue_checksPreference() {
// Initial state: preference not checked
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
mController.updateState(mPreference);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isFalse();
assertThat(mPreference.isChecked()).isFalse();
mPreference.performClick();
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isTrue();
assertThat(mPreference.isChecked()).isTrue();
}
}

116
tests/robotests/src/com/android/settings/gestures/LongPressPowerForPowerMenuPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,116 @@
/*
* 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 static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.app.Application;
import android.content.res.Resources;
import androidx.preference.PreferenceScreen;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.widget.SelectorWithWidgetPreference;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class LongPressPowerForPowerMenuPreferenceControllerTest {
private Application mContext;
private Resources mResources;
private SelectorWithWidgetPreference mPreference;
private LongPressPowerForPowerMenuPreferenceController mController;
@Before
public void setUp() {
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = spy(mContext.getResources());
mPreference = new SelectorWithWidgetPreference(mContext);
mController = new LongPressPowerForPowerMenuPreferenceController(mContext, "test_key");
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(5); // Default to Assistant
PreferenceScreen mScreen = mock(PreferenceScreen.class);
when(mScreen.findPreference("test_key")).thenReturn(mPreference);
mController.displayPreference(mScreen);
mController.onStart();
}
@Test
public void initialState_longPressPowerForPowerMenu_preferenceChecked() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isTrue();
}
@Test
public void initialState_longPressPowerForAssistant_preferenceNotChecked() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(mPreference.isChecked()).isFalse();
}
@Test
public void getAvailabilityStatus_longPressPowerSettingAvailable_returnsAvailable() {
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_longPressPowerSettingNotAvailable_returnsNotAvailable() {
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void onClick_updatesSettingsValue_checksPreference() {
// Initial state: preference not checked
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isTrue();
assertThat(mPreference.isChecked()).isFalse();
mPreference.performClick();
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isFalse();
assertThat(mPreference.isChecked()).isTrue();
}
}

74
tests/robotests/src/com/android/settings/gestures/LongPressPowerIllustrationPreferenceControllerTest.java Normal file
View File

@@ -0,0 +1,74 @@
/*
* 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 static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.app.Application;
import androidx.preference.PreferenceScreen;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.R;
import com.android.settingslib.widget.IllustrationPreference;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class LongPressPowerIllustrationPreferenceControllerTest {
private Application mContext;
private IllustrationPreference mPreference;
private LongPressPowerIllustrationPreferenceController mController;
@Before
public void setUp() {
mContext = ApplicationProvider.getApplicationContext();
mPreference = new IllustrationPreference(mContext);
mController = new LongPressPowerIllustrationPreferenceController(mContext, "test_key");
PreferenceScreen mScreen = mock(PreferenceScreen.class);
when(mScreen.findPreference("test_key")).thenReturn(mPreference);
mController.displayPreference(mScreen);
}
@Test
public void updateState_longPressPowerForPowerMenu_showsPowerMenuAnimation() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
mController.updateState(mPreference);
assertThat(mPreference.getLottieAnimationResId())
.isEqualTo(R.raw.lottie_long_press_power_for_power_menu);
}
@Test
public void updateState_longPressPowerForAssistant_showsAssistantAnimation() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
mController.updateState(mPreference);
assertThat(mPreference.getLottieAnimationResId())
.isEqualTo(R.raw.lottie_long_press_power_for_assistant);
}
}

67
tests/robotests/src/com/android/settings/gestures/LongPressPowerSensitivityPreferenceControllerTest.java
View File

@@ -26,14 +26,20 @@ import android.app.Application;
import android.content.res.Resources;
import android.provider.Settings;
import androidx.preference.PreferenceScreen;
import androidx.test.core.app.ApplicationProvider;
import com.android.settings.widget.LabeledSeekBarPreference;
import com.android.settingslib.testutils.shadow.ShadowInteractionJankMonitor;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {ShadowInteractionJankMonitor.class})
public class LongPressPowerSensitivityPreferenceControllerTest {
private static final String KEY_LONG_PRESS_SENSITIVITY =
@@ -43,7 +49,9 @@ public class LongPressPowerSensitivityPreferenceControllerTest {
private Application mContext;
private Resources mResources;
private LabeledSeekBarPreference mPreference;
private LongPressPowerSensitivityPreferenceController mController;
private PreferenceScreen mScreen;
@Before
public void setUp() {
@@ -52,11 +60,22 @@ public class LongPressPowerSensitivityPreferenceControllerTest {
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getIntArray(
com.android.internal.R.array.config_longPressOnPowerDurationSettings))
com.android.internal.R.array.config_longPressOnPowerDurationSettings))
.thenReturn(SENSITIVITY_VALUES);
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(5); // Default to Assistant
mPreference = new LabeledSeekBarPreference(mContext, null);
mController = new LongPressPowerSensitivityPreferenceController(mContext,
KEY_LONG_PRESS_SENSITIVITY);
mScreen = mock(PreferenceScreen.class);
when(mScreen.findPreference(KEY_LONG_PRESS_SENSITIVITY)).thenReturn(mPreference);
mController.displayPreference(mScreen);
}
@Test
@@ -98,46 +117,64 @@ public class LongPressPowerSensitivityPreferenceControllerTest {
}
@Test
public void longPressForAssistEnabled_isAvailable() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS,
PowerMenuSettingsUtils.LONG_PRESS_POWER_ASSISTANT_VALUE);
public void longPressForAssistant_isVisible() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
assertThat(mController.getAvailabilityStatus()).isEqualTo(
LongPressPowerSensitivityPreferenceController.AVAILABLE);
mController.updateState(mPreference);
assertThat(mPreference.isVisible()).isTrue();
}
@Test
public void longPressForAssistDisabled_isNotAvailableDueToDependentSetting() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS,
PowerMenuSettingsUtils.LONG_PRESS_POWER_NO_ACTION);
public void longPressForPowerMenu_isHidden() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
assertThat(mController.getAvailabilityStatus()).isEqualTo(
LongPressPowerSensitivityPreferenceController.DISABLED_DEPENDENT_SETTING);
mController.updateState(mPreference);
assertThat(mPreference.isVisible()).isFalse();
}
@Test
public void sensitivityValuesAreNull_notAvailable() {
public void longPressPowerSettingNotAvailable_notAvailable_isHidden() {
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
mController.updateState(mPreference);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(LongPressPowerSensitivityPreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mPreference.isVisible()).isFalse();
}
@Test
public void sensitivityValuesAreNull_notAvailable_isHidden() {
when(mResources.getIntArray(
com.android.internal.R.array.config_longPressOnPowerDurationSettings))
.thenReturn(null);
mController = new LongPressPowerSensitivityPreferenceController(mContext,
KEY_LONG_PRESS_SENSITIVITY);
mController.displayPreference(mScreen);
mController.updateState(mPreference);
assertThat(mController.getAvailabilityStatus()).isEqualTo(
LongPressPowerSensitivityPreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mPreference.isVisible()).isFalse();
}
@Test
public void sensitivityValuesArrayTooShort_notAvailable() {
public void sensitivityValuesArrayTooShort_notAvailable_isHidden() {
when(mResources.getIntArray(
com.android.internal.R.array.config_longPressOnPowerDurationSettings))
.thenReturn(new int[]{200});
mController = new LongPressPowerSensitivityPreferenceController(mContext,
KEY_LONG_PRESS_SENSITIVITY);
mController.displayPreference(mScreen);
mController.updateState(mPreference);
assertThat(mController.getAvailabilityStatus()).isEqualTo(
LongPressPowerSensitivityPreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mPreference.isVisible()).isFalse();
}
}

79
tests/robotests/src/com/android/settings/gestures/PowerMenuPreferenceControllerTest.java
View File

@@ -18,20 +18,21 @@ package com.android.settings.gestures;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.res.Resources;
import androidx.test.core.app.ApplicationProvider;
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 PowerMenuPreferenceControllerTest {
@@ -41,35 +42,75 @@ public class PowerMenuPreferenceControllerTest {
private static final String KEY_GESTURE_POWER_MENU = "gesture_power_menu";
@Before
public void setUp() {
mContext = spy(RuntimeEnvironment.application);
mResources = mock(Resources.class);
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mContext.getResources()).thenReturn(mResources);
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = spy(mContext.getResources());
mController = new PowerMenuPreferenceController(mContext, KEY_GESTURE_POWER_MENU);
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1); // Default to power menu
}
@Test
public void getAvailabilityStatus_assistAvailable_available() {
public void getAvailabilityStatus_settingsAvailable_returnsAvailable() {
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1); // Default to power menu
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.AVAILABLE);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_assistUnavailable_unavailable() {
public void getAvailabilityStatus_settingsNotAvailable_returnsNotAvailable() {
when(mResources.getBoolean(
com.android.internal.R.bool.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1); // Default to power menu
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.UNSUPPORTED_ON_DEVICE);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getAvailabilityStatus_longPressPowerSettingNotAvailable_returnsNotAvailable() {
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(3); // Default to power off (unsupported setup)
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getSummary_longPressPowerToAssistant_returnsNotAvailable() {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
assertThat(mController.getSummary().toString())
.isEqualTo(
mContext.getString(R.string.power_menu_summary_long_press_for_assistant));
}
@Test
public void getSummary_longPressPowerToPowerMenu_returnsNotAvailable() {
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
assertThat(mController.getSummary().toString())
.isEqualTo(
mContext.getString(R.string.power_menu_summary_long_press_for_power_menu));
}
}

127
tests/robotests/src/com/android/settings/gestures/PowerMenuSettingsUtilsTest.java
View File

@@ -44,48 +44,123 @@ public class PowerMenuSettingsUtilsTest {
mContext = spy(ApplicationProvider.getApplicationContext());
mResources = mock(Resources.class);
when(mContext.getResources()).thenReturn(mResources);
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(true);
}
@Test
public void longPressBehaviourValuePresent_returnsValue() {
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(0);
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, 1);
assertThat(PowerMenuSettingsUtils.getPowerButtonSettingValue(mContext)).isEqualTo(1);
public void isLongPressPowerForAssistantEnabled_valueSetToAssistant_returnsTrue() {
Settings.Global.putInt(
mContext.getContentResolver(), Settings.Global.POWER_BUTTON_LONG_PRESS, 5);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isTrue();
}
@Test
public void longPressBehaviourValueNotPresent_returnsDefault() {
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(2);
assertThat(PowerMenuSettingsUtils.getPowerButtonSettingValue(mContext)).isEqualTo(2);
public void isLongPressPowerForAssistantEnabled_valueNotSetToAssistant_returnsFalse() {
Settings.Global.putInt(
mContext.getContentResolver(), Settings.Global.POWER_BUTTON_LONG_PRESS, 3);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isFalse();
}
@Test
public void longPressBehaviourValueSetToAssistant_isAssistEnabledReturnsTrue() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, 5);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext)).isTrue();
public void isLongPressPowerForAssistantEnabled_valueNotSet_defaultToAssistant_returnsTrue() {
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(5);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isTrue();
}
@Test
public void longPressBehaviourValueNotSetToAssistant_isAssistEnabledReturnsFalse() {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS, 3);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext)).isFalse();
public void isLongPressPowerForAssistantEnabled_valueNotSet_defaultToPowerMenu_returnsFalse() {
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1);
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistantEnabled(mContext)).isFalse();
}
@Test
public void longPressBehaviourDefaultSetToAssistant_isAssistEnabledReturnsFalse() {
when(mResources.getInteger(
com.android.internal.R.integer.config_longPressOnPowerBehavior))
public void isLongPressPowerSettingAvailable_defaultToAssistant_returnsTrue() {
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(5);
assertThat(PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)).isTrue();
}
@Test
public void isLongPressPowerSettingAvailable_defaultToPowerMenu_returnsTrue() {
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1);
assertThat(PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)).isTrue();
}
@Test
public void isLongPressPowerSettingAvailable_defaultToPowerOff_returnsFalse() {
// Power off is the unsupported option in long press power settings
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(3);
assertThat(PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)).isFalse();
}
assertThat(PowerMenuSettingsUtils.isLongPressPowerForAssistEnabled(mContext)).isFalse();
@Test
public void isLongPressPowerSettingAvailable_settingDisabled_returnsFalse() {
// Disable the setting
when(mResources.getBoolean(
com.android.internal.R.bool
.config_longPressOnPowerForAssistantSettingAvailable))
.thenReturn(false);
when(mResources.getInteger(com.android.internal.R.integer.config_longPressOnPowerBehavior))
.thenReturn(1);
assertThat(PowerMenuSettingsUtils.isLongPressPowerSettingAvailable(mContext)).isFalse();
}
@Test
public void setLongPressPowerForAssistant_updatesValue() throws Exception {
boolean result = PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
assertThat(result).isTrue();
assertThat(
Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS))
.isEqualTo(5);
}
@Test
public void setLongPressPowerForAssistant_updatesKeyChordValueToPowerMenu() throws Exception {
PowerMenuSettingsUtils.setLongPressPowerForAssistant(mContext);
assertThat(
Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP))
.isEqualTo(2);
}
@Test
public void setLongPressPowerForPowerMenu_updatesValue() throws Exception {
boolean result = PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
assertThat(result).isTrue();
assertThat(
Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.POWER_BUTTON_LONG_PRESS))
.isEqualTo(1);
}
@Test
public void setLongPressPowerForPowerMenu_updatesKeyChordValueToDefault() throws Exception {
when(mResources.getInteger(com.android.internal.R.integer.config_keyChordPowerVolumeUp))
.thenReturn(1);
PowerMenuSettingsUtils.setLongPressPowerForPowerMenu(mContext);
assertThat(
Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.KEY_CHORD_POWER_VOLUME_UP))
.isEqualTo(1);
}
}