Android Settings 按住电源按钮的操作方法

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

    @override
    public void onradiobuttonclicked(selectorwithwidgetpreference preference) {
        powermenusettingsutils.setlongpresspowerforpowermenu(mcontext);
        if (mpreference != null) {
            updatestate(mpreference);
        }
    }

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

    @override
    public void onradiobuttonclicked(selectorwithwidgetpreference preference) {
        powermenusettingsutils.setlongpresspowerforassistant(mcontext);
        if (mpreference != null) {
            updatestate(mpreference);
        }
    }

    private static final string power_button_long_press_setting =
            settings.global.power_button_long_press;
    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
    // ... 
    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;
    }

    /**
     * correctly sets long press power button behavior.
     *
     * the issue is that setting for longpresspower button behavior is not available on all devices
     * and actually changes default behavior of two properties - the long press power button
     * and volume up + power button combo. oem can also reconfigure these behaviors in config.xml,
     * so we need to be careful that we don't irreversibly change power button behavior when
     * restoring. or switch to a non-default button behavior.
     */
    private void setlongpresspowerbehavior(contentresolver cr, string value) {
        // we will not restore the value if the long press power setting option is unavailable.
        if (!mcontext.getresources().getboolean(
                com.android.internal.r.bool.config_longpressonpowerforassistantsettingavailable)) {
            return;
        }
        int longpressonpowerbehavior;
        try {
            longpressonpowerbehavior = integer.parseint(value);
        } catch (numberformatexception e) {
            return;
        }
        if (longpressonpowerbehavior < long_press_power_nothing
                || longpressonpowerbehavior > long_press_power_for_assistant) {
            return;
        }
        // when user enables long press power for assistant, we also switch the meaning
        // of volume up + power key chord to the "show power menu" option.
        // if the user disables long press power for assistant, we switch back to default oem
        // behavior configured in config.xml. if the default behavior is "lpp for assistant",
        // then we fall back to "long press for power menu" behavior.
        if (longpressonpowerbehavior == long_press_power_for_assistant) {
            settings.global.putint(cr, settings.global.power_button_long_press,
                    long_press_power_for_assistant);
            settings.global.putint(cr, settings.global.key_chord_power_volume_up,
                    key_chord_power_volume_up_global_actions);
        } else {
            // we're restoring "lpp for assistant disabled" state, prefer oem config.xml behavior
            // if possible.
            int longpressonpowerdevicebehavior = mcontext.getresources().getinteger(
                    com.android.internal.r.integer.config_longpressonpowerbehavior);
            if (longpressonpowerdevicebehavior == long_press_power_for_assistant) {
                // the default on device is "lpp for assistant enabled" so fall back to power menu.
                settings.global.putint(cr, settings.global.power_button_long_press,
                        long_press_power_global_actions);
            } else {
                // the default is non-assistant behavior, so restore that default.
                settings.global.putint(cr, settings.global.power_button_long_press,
                        longpressonpowerdevicebehavior);
            }
            // clear and restore default power + volume up behavior as well.
            int powervolumeupdefaultbehavior = mcontext.getresources().getinteger(
                    com.android.internal.r.integer.config_keychordpowervolumeup);
            settings.global.putint(cr, settings.global.key_chord_power_volume_up,
                    powervolumeupdefaultbehavior);
        }
    }

    <!-- control the behavior when the user long presses the power button.
            0 - nothing
            1 - global actions menu
            2 - power off (with confirmation)
            3 - power off (without confirmation)
            4 - go to voice assist
            5 - go to assistant (settings.secure.assistant)
    -->
    <integer name="config_longpressonpowerbehavior">5</integer>

/*
 * copyright (c) 2021 the android open source project
 *
 * licensed under the apache license, version 2.0 (the "license");
 * you may not use this file except in compliance with the license.
 * you may obtain a copy of the license at
 *
 *      http://www.apache.org/licenses/license-2.0
 *
 * unless required by applicable law or agreed to in writing, software
 * distributed under the license is distributed on an "as is" basis,
 * without warranties or conditions of any kind, either express or implied.
 * see the license for the specific language governing permissions and
 * limitations under the license.
 */
package com.android.settings.gestures;
import android.content.context;
import android.net.uri;
import 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;
/** handles changes to the long press power button sensitivity slider. */
public class longpresspowersensitivitypreferencecontroller extends sliderpreferencecontroller
        implements powermenusettingsutils.settingsstatecallback, lifecycleobserver {
    @nullable
    private final int[] msensitivityvalues;
    private final powermenusettingsutils mutils;
    @nullable
    private labeledseekbarpreference mpreference;
    public longpresspowersensitivitypreferencecontroller(context context, string preferencekey) {
        super(context, preferencekey);
        msensitivityvalues = context.getresources().getintarray(
                com.android.internal.r.array.config_longpressonpowerdurationsettings);
        mutils = new powermenusettingsutils(context);
    }
    /** @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();
    }
    @override
    public void displaypreference(preferencescreen screen) {
        super.displaypreference(screen);
        mpreference = screen.findpreference(getpreferencekey());
        if (mpreference != null) {
            mpreference.setcontinuousupdates(false);
            mpreference.sethapticfeedbackmode(
                    labeledseekbarpreference.haptic_feedback_mode_on_ticks);
            mpreference.setmin(getmin());
            mpreference.setmax(getmax());
        }
    }
    @override
    public void updatestate(preference preference) {
        super.updatestate(preference);
        final labeledseekbarpreference pref = (labeledseekbarpreference) preference;
        pref.setvisible(
                powermenusettingsutils.islongpresspowerforassistantenabled(mcontext)
                        && getavailabilitystatus() == available);
        pref.setprogress(getsliderposition());
    }
    @override
    public int getavailabilitystatus() {
        if (msensitivityvalues == null
                || msensitivityvalues.length < 2
                || !powermenusettingsutils.islongpresspowersettingavailable(mcontext)) {
            return unsupported_on_device;
        }
        return available;
    }
    @override
    public int getsliderposition() {
        return msensitivityvalues == null ? 0 : closestvalueindex(msensitivityvalues,
                getcurrentsensitivityvalue());
    }
    @override
    public boolean setsliderposition(int position) {
        if (msensitivityvalues == null || position < 0 || position >= msensitivityvalues.length) {
            return false;
        }
        return settings.global.putint(mcontext.getcontentresolver(),
                settings.global.power_button_long_press_duration_ms,
                msensitivityvalues[position]);
    }
    @override
    public void onchange(uri uri) {
        if (mpreference != null) {
            updatestate(mpreference);
        }
    }
    @override
    public int getmax() {
        if (msensitivityvalues == null || msensitivityvalues.length == 0) {
            return 0;
        }
        return msensitivityvalues.length - 1;
    }
    @override
    public int getmin() {
        return 0;
    }
    private int getcurrentsensitivityvalue() {
        return settings.global.getint(mcontext.getcontentresolver(),
                settings.global.power_button_long_press_duration_ms,
                mcontext.getresources().getinteger(
                        com.android.internal.r.integer.config_longpressonpowerdurationms));
    }
    private static int closestvalueindex(int[] values, int needle) {
        int mindistance = integer.max_value;
        int valueindex = 0;
        for (int i = 0; i < values.length; i++) {
            int diff = math.abs(values[i] - needle);
            if (diff < mindistance) {
                mindistance = diff;
                valueindex = i;
            }
        }
        return valueindex;
    }
}

    <!-- the possible ui options to be surfaced for configuring long press power on duration
         action. value set in config_longpressonpowerdurationms should be one of the available
         options to allow users to restore default. -->
    <integer-array name="config_longpressonpowerdurationsettings">
        <item>250</item>
        <item>350</item>
        <item>500</item>
        <item>650</item>
        <item>750</item>
    </integer-array>