Android13 PowerManager shutdown流程分析

已于 2024-05-04 00:44:18 修改
阅读量539 收藏 3
点赞数 3
分类专栏： Android Framework Android Power 文章标签： android
于 2024-05-03 17:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuning1985622/article/details/138420348
版权

PowerManager的shutdown方法用于请求设备关机，代码如下：

//frameworks/base/core/java/android/os/PowerManager.java
public final class PowerManager {
    public void shutdown(boolean confirm, String reason, boolean wait) {
        try {
            mService.shutdown(confirm, reason, wait);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }
}

调用mService(IPowerManager)的shutdown方法,IPowerManager是一个接口，由PowerManagerService的内部类BinderService实现：

//frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
public final class PowerManagerService extends SystemService
        implements Watchdog.Monitor {
    final class BinderService extends IPowerManager.Stub {
        public void shutdown(boolean confirm, String reason, boolean wait) {
            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null);


            ShutdownCheckPoints.recordCheckPoint(Binder.getCallingPid(), reason);
            final long ident = Binder.clearCallingIdentity();
            try {
                shutdownOrRebootInternal(HALT_MODE_SHUTDOWN, confirm, reason, wait);
            } finally {
                Binder.restoreCallingIdentity(ident);
            }
        }
    }
}

调用PowerManagerService 的shutdownOrRebootInternal方法：

//frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
public final class PowerManagerService extends SystemService
        implements Watchdog.Monitor {
    private void shutdownOrRebootInternal(final @HaltMode int haltMode, final boolean confirm,
            @Nullable final String reason, boolean wait) {
        if (PowerManager.REBOOT_USERSPACE.equals(reason)) {
            if (!PowerManager.isRebootingUserspaceSupportedImpl()) {
                throw new UnsupportedOperationException(
                        "Attempted userspace reboot on a device that doesn't support it");
            }
            UserspaceRebootLogger.noteUserspaceRebootWasRequested();
        }
        if (mHandler == null || !mSystemReady) {
            if (RescueParty.isAttemptingFactoryReset()) {
                // If we're stuck in a really low-level reboot loop, and a
                // rescue party is trying to prompt the user for a factory data
                // reset, we must GET TO DA CHOPPA!
                // No check point from ShutdownCheckPoints will be dumped at this state.
                PowerManagerService.lowLevelReboot(reason);
            } else {
                throw new IllegalStateException("Too early to call shutdown() or reboot()");
            }
        }


        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synchronized (this) {
                    if (haltMode == HALT_MODE_REBOOT_SAFE_MODE) {
                        ShutdownThread.rebootSafeMode(getUiContext(), confirm);
                    } else if (haltMode == HALT_MODE_REBOOT) {
                        ShutdownThread.reboot(getUiContext(), reason, confirm);
                    } else {
                        ShutdownThread.shutdown(getUiContext(), reason, confirm);
                    }
                }
            }
        };


        // ShutdownThread must run on a looper capable of displaying the UI.
        Message msg = Message.obtain(UiThread.getHandler(), runnable);
        msg.setAsynchronous(true);
        UiThread.getHandler().sendMessage(msg);


        // PowerManager.reboot() is documented not to return so just wait for the inevitable.
        if (wait) {
            synchronized (runnable) {
                while (true) {
                    try {
                        runnable.wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
    }
}

上面方法更加不同的haltMode模式调用不同的方法：

1、调用ShutdownThread的rebootSafeMode方法。

2、调用ShutdownThread的reboot方法。

3、调用ShutdownThread的shutdown方法。

下面分别进行分析：

ShutdownThread rebootSafeMode

调用ShutdownThread的rebootSafeMode方法：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    public static void rebootSafeMode(final Context context, boolean confirm) {
        UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
        if (um.hasUserRestriction(UserManager.DISALLOW_SAFE_BOOT)) {
            return;
        }


        mReboot = true;
        mRebootSafeMode = true;
        mRebootHasProgressBar = false;
        mReason = null;
        shutdownInner(context, confirm);
    }
}

ShutdownThread reboot

调用ShutdownThread的reboot方法：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    public static void reboot(final Context context, String reason, boolean confirm) {
        mReboot = true;
        mRebootSafeMode = false;
        mRebootHasProgressBar = false;
        mReason = reason;
        shutdownInner(context, confirm);
    }
}

上述三个方法都调用了ShutdownThread的shutdownInner方法：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    private static void shutdownInner(final Context context, boolean confirm) {
        // ShutdownThread is called from many places, so best to verify here that the context passed
        // in is themed.
        context.assertRuntimeOverlayThemable();


        // ensure that only one thread is trying to power down.
        // any additional calls are just returned
        synchronized (sIsStartedGuard) {
            if (sIsStarted) {
                Log.d(TAG, "Request to shutdown already running, returning.");
                return;
            }
        }


        // Add checkpoint for this shutdown attempt. The user might still cancel the dialog, but
        // this point preserves the system trace of the trigger point of the ShutdownThread.
        ShutdownCheckPoints.recordCheckPoint(/* reason= */ null);


        final int longPressBehavior = context.getResources().getInteger(
                        com.android.internal.R.integer.config_longPressOnPowerBehavior);
        final int resourceId = mRebootSafeMode
                ? com.android.internal.R.string.reboot_safemode_confirm
                : (longPressBehavior == 2
                        ? com.android.internal.R.string.shutdown_confirm_question
                        : com.android.internal.R.string.shutdown_confirm);


        Log.d(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior);


        if (confirm) {
            final CloseDialogReceiver closer = new CloseDialogReceiver(context);
            if (sConfirmDialog != null) {
                sConfirmDialog.dismiss();
            }
            sConfirmDialog = new AlertDialog.Builder(context)
                    .setTitle(mRebootSafeMode
                            ? com.android.internal.R.string.reboot_safemode_title
                            : com.android.internal.R.string.power_off)
                    .setMessage(resourceId)
                    .setPositiveButton(com.android.internal.R.string.yes, new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            beginShutdownSequence(context);
                        }
                    })
                    .setNegativeButton(com.android.internal.R.string.no, null)
                    .create();
            closer.dialog = sConfirmDialog;
            sConfirmDialog.setOnDismissListener(closer);
            sConfirmDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
            sConfirmDialog.show();
        } else {
            beginShutdownSequence(context);
        }
    }
}

调用ShutdownThread的beginShutdownSequence方法：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    private static final ShutdownThread sInstance = new ShutdownThread();
    private static void beginShutdownSequence(Context context) {
        synchronized (sIsStartedGuard) {
            if (sIsStarted) {
                Log.d(TAG, "Shutdown sequence already running, returning.");
                return;
            }
            sIsStarted = true;
        }


        sInstance.mProgressDialog = showShutdownDialog(context);
        sInstance.mContext = context;
        sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);


        // make sure we never fall asleep again
        sInstance.mCpuWakeLock = null;
        try {
            sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock(
                    PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu");
            sInstance.mCpuWakeLock.setReferenceCounted(false);
            sInstance.mCpuWakeLock.acquire();
        } catch (SecurityException e) {
            Log.w(TAG, "No permission to acquire wake lock", e);
            sInstance.mCpuWakeLock = null;
        }


        // also make sure the screen stays on for better user experience
        sInstance.mScreenWakeLock = null;
        if (sInstance.mPowerManager.isScreenOn()) {
            try {
                sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock(
                        PowerManager.FULL_WAKE_LOCK, TAG + "-screen");
                sInstance.mScreenWakeLock.setReferenceCounted(false);
                sInstance.mScreenWakeLock.acquire();
            } catch (SecurityException e) {
                Log.w(TAG, "No permission to acquire wake lock", e);
                sInstance.mScreenWakeLock = null;
            }
        }


        if (SecurityLog.isLoggingEnabled()) {
            SecurityLog.writeEvent(SecurityLog.TAG_OS_SHUTDOWN);
        }


        // start the thread that initiates shutdown
        sInstance.mHandler = new Handler() {
        };
        sInstance.start();
    }
}

ShutdownThread run

调用sInstance(ShutdownThread)的start方法，之后会运行到ShutdownThread的run：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    public void run() {
        TimingsTraceLog shutdownTimingLog = newTimingsLog();
        shutdownTimingLog.traceBegin("SystemServerShutdown");
        metricShutdownStart();
        metricStarted(METRIC_SYSTEM_SERVER);


        // Start dumping check points for this shutdown in a separate thread.
        Thread dumpCheckPointsThread = ShutdownCheckPoints.newDumpThread(
                new File(CHECK_POINTS_FILE_BASENAME));
        dumpCheckPointsThread.start();


        BroadcastReceiver br = new BroadcastReceiver() {
            @Override public void onReceive(Context context, Intent intent) {
                // We don't allow apps to cancel this, so ignore the result.
                actionDone();
            }
        };


        /*
         * Write a system property in case the system_server reboots before we
         * get to the actual hardware restart. If that happens, we'll retry at
         * the beginning of the SystemServer startup.
         */
        {
            String reason = (mReboot ? "1" : "0") + (mReason != null ? mReason : "");
            SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason);
        }


        /*
         * If we are rebooting into safe mode, write a system property
         * indicating so.
         */
        if (mRebootSafeMode) {
            SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");
        }


        shutdownTimingLog.traceBegin("DumpPreRebootInfo");
        try {
            Slog.i(TAG, "Logging pre-reboot information...");
            PreRebootLogger.log(mContext);
        } catch (Exception e) {
            Slog.e(TAG, "Failed to log pre-reboot information", e);
        }
        shutdownTimingLog.traceEnd(); // DumpPreRebootInfo


        metricStarted(METRIC_SEND_BROADCAST);
        shutdownTimingLog.traceBegin("SendShutdownBroadcast");
        Log.i(TAG, "Sending shutdown broadcast...");


        // First send the high-level shut down broadcast.
        mActionDone = false;
        Intent intent = new Intent(Intent.ACTION_SHUTDOWN);
        intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND | Intent.FLAG_RECEIVER_REGISTERED_ONLY);
        mContext.sendOrderedBroadcastAsUser(intent,
                UserHandle.ALL, null, br, mHandler, 0, null, null);


        final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME;
        synchronized (mActionDoneSync) {
            while (!mActionDone) {
                long delay = endTime - SystemClock.elapsedRealtime();
                if (delay <= 0) {
                    Log.w(TAG, "Shutdown broadcast timed out");
                    break;
                } else if (mRebootHasProgressBar) {
                    int status = (int)((MAX_BROADCAST_TIME - delay) * 1.0 *
                            BROADCAST_STOP_PERCENT / MAX_BROADCAST_TIME);
                    sInstance.setRebootProgress(status, null);
                }
                try {
                    mActionDoneSync.wait(Math.min(delay, ACTION_DONE_POLL_WAIT_MS));
                } catch (InterruptedException e) {
                }
            }
        }
        if (mRebootHasProgressBar) {
            sInstance.setRebootProgress(BROADCAST_STOP_PERCENT, null);
        }
        shutdownTimingLog.traceEnd(); // SendShutdownBroadcast
        metricEnded(METRIC_SEND_BROADCAST);


        Log.i(TAG, "Shutting down activity manager...");
        shutdownTimingLog.traceBegin("ShutdownActivityManager");
        metricStarted(METRIC_AM);


        final IActivityManager am =
                IActivityManager.Stub.asInterface(ServiceManager.checkService("activity"));
        if (am != null) {
            try {
                am.shutdown(MAX_BROADCAST_TIME);
            } catch (RemoteException e) {
            }
        }
        if (mRebootHasProgressBar) {
            sInstance.setRebootProgress(ACTIVITY_MANAGER_STOP_PERCENT, null);
        }
        shutdownTimingLog.traceEnd();// ShutdownActivityManager
        metricEnded(METRIC_AM);


        Log.i(TAG, "Shutting down package manager...");
        shutdownTimingLog.traceBegin("ShutdownPackageManager");
        metricStarted(METRIC_PM);


        final PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class);
        if (pm != null) {
            pm.shutdown();
        }
        if (mRebootHasProgressBar) {
            sInstance.setRebootProgress(PACKAGE_MANAGER_STOP_PERCENT, null);
        }
        shutdownTimingLog.traceEnd(); // ShutdownPackageManager
        metricEnded(METRIC_PM);


        // Shutdown radios.
        shutdownTimingLog.traceBegin("ShutdownRadios");
        metricStarted(METRIC_RADIOS);
        shutdownRadios(MAX_RADIO_WAIT_TIME);
        if (mRebootHasProgressBar) {
            sInstance.setRebootProgress(RADIO_STOP_PERCENT, null);
        }
        shutdownTimingLog.traceEnd(); // ShutdownRadios
        metricEnded(METRIC_RADIOS);


        if (mRebootHasProgressBar) {
            sInstance.setRebootProgress(MOUNT_SERVICE_STOP_PERCENT, null);


            // If it's to reboot to install an update and uncrypt hasn't been
            // done yet, trigger it now.
            uncrypt();
        }


        // Wait for the check points dump thread to finish, or kill it if not finished in time.
        shutdownTimingLog.traceBegin("ShutdownCheckPointsDumpWait");
        try {
            dumpCheckPointsThread.join(MAX_CHECK_POINTS_DUMP_WAIT_TIME);
        } catch (InterruptedException ex) {
        }
        shutdownTimingLog.traceEnd(); // ShutdownCheckPointsDumpWait


        shutdownTimingLog.traceEnd(); // SystemServerShutdown
        metricEnded(METRIC_SYSTEM_SERVER);
        saveMetrics(mReboot, mReason);
        // Remaining work will be done by init, including vold shutdown
        rebootOrShutdown(mContext, mReboot, mReason);
    }
}

调用ShutdownThread的rebootOrShutdown方法：

//frameworks/base/services/core/java/com/android/server/power/ShutdownThread.java
public final class ShutdownThread extends Thread {
    public static void rebootOrShutdown(final Context context, boolean reboot, String reason) {
        if (reboot) {
            Log.i(TAG, "Rebooting, reason: " + reason);
            PowerManagerService.lowLevelReboot(reason);
            Log.e(TAG, "Reboot failed, will attempt shutdown instead");
            reason = null;
        } else if (SHUTDOWN_VIBRATE_MS > 0 && context != null) {
            // vibrate before shutting down
     // 关机前震动
            Vibrator vibrator = new SystemVibrator(context);
            try {
                vibrator.vibrate(SHUTDOWN_VIBRATE_MS, VIBRATION_ATTRIBUTES);
            } catch (Exception e) {
                // Failure to vibrate shouldn't interrupt shutdown.  Just log it.
                Log.w(TAG, "Failed to vibrate during shutdown.", e);
            }


            // vibrator is asynchronous so we need to wait to avoid shutting down too soon.
            try {
                Thread.sleep(SHUTDOWN_VIBRATE_MS);
            } catch (InterruptedException unused) {
            }
        }
        // Shutdown power
        Log.i(TAG, "Performing low-level shutdown...");
        PowerManagerService.lowLevelShutdown(reason);
    }
}

调用PowerManagerService的lowLevelShutdown方法：

//frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java
public final class PowerManagerService extends SystemService
        implements Watchdog.Monitor {
    public static void lowLevelShutdown(String reason) {
        if (reason == null) {
            reason = "";
        }
        SystemProperties.set("sys.powerctl", "shutdown," + reason);
    }
}

调用SystemProperties的set方法，SystemProperties是一个用于访问和修改Android系统属性的工具类。系统属性是一些键值对，用于存储和传递系统相关的配置信息。通过SystemProperties类，开发者可以获取和设置这些系统属性：

//frameworks/base/core/java/android/os/SystemProperties.java
public class SystemProperties {
    public static void set(@NonNull String key, @Nullable String val) {
        if (val != null && !key.startsWith("ro.") && val.getBytes(StandardCharsets.UTF_8).length
                > PROP_VALUE_MAX) {
            throw new IllegalArgumentException("value of system property '" + key
                    + "' is longer than " + PROP_VALUE_MAX + " bytes: " + val);
        }
        if (TRACK_KEY_ACCESS) onKeyAccess(key);
        native_set(key, val);
    }
}

调用native_set方法，native_set是Native方法，在android_os_SystemPropecties.cpp中定义：

//frameworks/base/core/jni/android_os_SystemPropecties.cpp
void SystemProperties_set(JNIEnv *env, jobject clazz, jstring keyJ,
                          jstring valJ)
{
    ScopedUtfChars key(env, keyJ);
    if (!key.c_str()) {
        return;
    }
    std::optional<ScopedUtfChars> value;
    if (valJ != nullptr) {
        value.emplace(env, valJ);
        if (!value->c_str()) {
            return;
        }
    }
    bool success;
#if defined(__BIONIC__)
    success = !__system_property_set(key.c_str(), value ? value->c_str() : "");
#else
    success = android::base::SetProperty(key.c_str(), value ? value->c_str() : "");
#endif
    if (!success) {
        jniThrowException(env, "java/lang/RuntimeException",
                          "failed to set system property (check logcat for reason)");
    }
}
一个学渣的自我救赎
关注
专栏目录
Unity调用Android系统PowerManager类功能.zip
02-24
在Android中，你需要创建一个BroadcastReceiver监听ACTION_SHUTDOWN广播，然后在接收到广播时调用`powerManager.shutdown(false)`，第二个参数表示是否等待所有正在运行的任务完成。 - `reboot(String reason)`方法...
android PowerManager 关机
qq_19447521的博客
05-22 134
PowerManager mPowerManager=(PowerManager) context.getSystemService(Context.POWER_SERVICE); mPowerManager.shutdown(false,PowerManager.SHUTDOWN_USER_REQUESTED,false);
Android系统关机和重启
qq_43529089的博客
04-21 4725
一. 发送系统广播方式 Broadcast是Android的四大基本组件之中的一个。也就是我们常说的广播。Android系统本身就包括了很多广播，时时刻刻在监听着系统中注冊的每个广播并随时准备响应操作。 当中，就有关于关机或重新启动的广播：Intent.ACTION_REQUEST_SHUTDOWN和Intent.ACTION_REBOOT，通过发送这两个广播。Android就能自己主动接收广播。并响应关机或重新启动的操作。ACTION_REQUEST和ACTION_REBOOT是Intent...
Android 软重启的执行
最新发布
华南烹鱼宴
06-27 1052
软重启的参考实现方案包括一项用于自定义软重启期间显示的动画的功能。在操作结束时，init会启动bootanim服务。动画文件必须遵循以下格式如果未指定软重启的专用动画文件，bootanim会显示默认的android动画。
Android 12 关机重启流程
pecuyu
05-22 6169
文章托管在gitee上 Android Notes , 同步csdn 本文基于Android12 分析 关机流程 Android上层触发关机的入口很多，但最终几乎都是调用ShutdownThread.shutdown来实现。如下是一些常见的调用关机的点： StatusBarManagerService#shutdown, 这个主要是对接SystemUI WindowManagerService#shutdown， 以WindowManagerFuncs接口提供给系统其他模块使用，诸如GlobalAct.
power键或者其他什么键down直接关机 ，做成关机键。
youthking1314的博客
12-26 224
power键或者其他什么键down直接关机 ，做成关机键。
Android实战——设备关机和重启分析
小旭的专栏
09-13 948
设备关机和重启分析
Android系统关机或重启的几种实现方式
Peak的博客
02-12 1万+
默认的SDK并没有提供应用开发者直接的Android系统关机或重启的API接口，一般来讲，实现Android系统的关机或重启，需要较高的权限（系统权限甚至Root权限）。所以，在一般的APP中，如果想要实现关机或重启功能，要么是在App中声明系统权限，要么是通过某种“间接”的方式，比如广播或反射，来间接实现系统关机或重启。再者，就是放在源码环境中进行编译，这样做有一个好处，就是可以直接调用Android中不公开的API，这是Eclipse＋SDK没法达到的效果。下面是我自己尝试的几种方式： 一. ..
Android系统关机的全流程解析
09-02
在`frameworks/base/core/java/android/os/PowerManager.java`中，存在一个名为`reboot()`的接口，用于执行设备重启或关机操作。这个方法需要`android.permission.REBOOT`权限，并且有一个可选参数`reason`，用于...
Android 3.2 sdk API13
04-08
11. **开发工具**：随着API 13的发布，Eclipse ADT（Android Developer Tools）也得到了相应的更新，提供了更好的调试工具、性能分析器和UI设计工具，帮助开发者更高效地构建和测试应用。 综上所述，Android 3.2 ...
Fwk 唤醒流程分析doc
02-05
在 Android 设备进入休眠状态之后，若接收到特定事件（如按键消息、来电或闹钟等），设备内核会从休眠状态中被唤醒，并进一步通知 Framework（即 Android 框架层）开始执行唤醒流程。这一过程主要涉及两个核心步骤：...
Android PowerManager的使用
weixin_44021334的博客
08-19 1739
如果需要使 CPU 保持运行状态，以便在设备进入休眠模式之前完成某项工作，可以使用“唤醒锁定”。
Android开发：代码实现系统关机和重启
热门推荐
shakdy的博客
02-27 1万+
情景分析： 需求：在系统没有root的条件下，应用程序控制系统关机和重启 解决方法： 测试环境：Android 4.4手机 ；Android Studio 1 将自己的应用程序获取系统权限 参考：Android应用如何获取系统权限 2 代码实现如下 package com.smart.rebootdemo; import android.content.Context; im...
Android实现系统关机和重启
qq_40731414的博客
03-19 374
一、将APP提升至系统权限 在AndroidMenifest.xml中添加如下代码： android:sharedUserId="android.uid.system" 二、 添加关机权限 <uses-permission android:name="android.permission.SHUTDOWN" /> 三、由于需要在源码中编译项目，所以要为项目编写mk文件，在项目根目录下添加Android.mk文件，内容如下所示： LOCAL_PATH:= $(call my-dir) in
Android关机、重启的实现,但需要权限
qq_40207976的博客
09-26 1259
//关机 public void shutDown() { try { Runtime.getRuntime().exec("reboot -p"); } catch (IOException e) { e.printStackTrace(); } } //重启 public void reboot() { try { Runtime.getRuntime().exec("reboot"); } catch (IOE
Android7.0关机流程分析
宇落 生命不息，奋斗不止......
01-17 9119
在长按power键时系统会弹出对话框,让用户选择关机, 重启或者其他模式. 在本文中重点讲解系统关机流程. 让大家了解在系统关机过程都做了哪些事情,而导致关机慢又有那些主要的原因.在Android7.0 PowerManagerService亮灭屏(一)一文中有对按power键传输讲解, 长按power键是在java层的PhoneWindowManager.java中进行处理的. p
Android 长按和短按POWER KEY 按键触发
zjy764219923的专栏
07-17 1761
功能需求短按实现弹出：重启或者关机对话框 长按直接关机： 1.短按： <integer name="config_shortPressOnPowerBehavior">1</integer> <!-- Control the behavior when the user double presses the power button. 0 - Nothing 1 - Togg...
Android代码中实现关机
lebulangzhen的博客
12-21 4980
想要在代码中实现关机需要apk有系统权限，要在manifest文件添加android:sharedUserId=“android.uid.system”，还要有系统签名。 ###第一种方式 直接使用adb shell 命令，调用reboot命令来关机 try { Runtime.getRuntime().exec("reboot -p"); //关机 } catch (IOException e) { e.printStackTrace(); } ###第二种方式 电泳PowerManag
android 实现代码关机
大脸猫的博客
06-17 8915
开始从网上搜索，通过发action的方式实现，不过一直没有成功。 Intent intent = new Intent();   intent.setAction(Intent.ACTION_SHUTDOWN); sendBroadcast(intent); 加权限 若有成功的同学，希望留言相告，谢谢。 这里介绍我自己的方法。 1. power服务实现了关机功能 f
Android 灭屏流程
04-27
Android 灭屏流程大致如下： 1.用户按下电源键或者时间到了自动灭屏的时间。 2.触发 PowerManager 的 goToSleep 方法，将系统休眠。 3. PowerManagerService 调用 DisplayPowerController 的 setScreenState 方法，设置屏幕状态为 STATE_OFF。 4. DisplayPowerController 会根据屏幕状态的变化来更新屏幕亮度和颜色等相关设置。 5. 如果有需要执行的操作，例如释放 wakelock，关闭背光灯等，则在 setScreenState 方法中执行。 6. 最后，屏幕关闭，设备进入休眠状态。 需要注意的是，不同的 Android 版本和设备厂商可能会有些细微差别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值