详解Android 关机/重启流程

本文基于android 10源码分析

手机长按power键，弹出关机提示对话框，如下图

一、先来看长按power键执行的流程。

开机后先注册输入监听事件，长按power键时，kernel层会发出一个事件上来，该事件最终被InputDispatcher.handleReceiveCallback监听到

frameworks\native\services\inputflinger\InputDispatcher.cpp
int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {
InputDispatcher* d = static_cast<InputDispatcher*>(data);
{ 
..........
    sp<Connection> connection = d->mConnectionsByFd.valueAt(connectionIndex);
    if (!(events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP))) {
       .......
        status_t status;
        for (;;) {
            uint32_t seq;
            bool handled;
            //收到完成分发的信号才跳出循环
            status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);
            if (status) {
                break;
            }
            //完成分发循环
            d->finishDispatchCycleLocked(currentTime, connection, seq, handled);
            gotOne = true;
        }
       ........
    }
    .........
    return 0; // remove the callback
} // release lock

frameworks\native\services\inputflinger\InputDispatcher.cpp
void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
const sp<Connection>& connection, uint32_t seq, bool handled) {
    ......
    // 完成一次按键分发，通知其他系统组件并准备开始下一个调度周期
    onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);
}

frameworks\native\services\inputflinger\InputDispatcher.cpp
void InputDispatcher::onDispatchCycleFinishedLocked(
        nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) {
    CommandEntry* commandEntry = postCommandLocked(
            & InputDispatcher::doDispatchCycleFinishedLockedInterruptible);
    commandEntry->connection = connection;
    commandEntry->eventTime = currentTime;
    commandEntry->seq = seq;
    commandEntry->handled = handled;
}

frameworks\native\services\inputflinger\InputDispatcher.cpp
void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(
CommandEntry* commandEntry) {
.........
    //按键事件
    if (dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {
        KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);
        restartEvent = afterKeyEventLockedInterruptible(connection,
                dispatchEntry, keyEntry, handled);
    } else if (dispatchEntry->eventEntry->type == EventEntry::TYPE_MOTION) {//触摸滑动事件
        MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);
        restartEvent = afterMotionEventLockedInterruptible(connection,
                dispatchEntry, motionEntry, handled);
    } else {
        restartEvent = false;
    }
    // 开始下一次的按键分发
    startDispatchCycleLocked(now(), connection);
}

bool InputDispatcher::afterKeyEventLockedInterruptible(const sp<Connection>& connection,
        DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled) {
  ..............................
            KeyEvent event;
            //对keyevent的结构体赋值，如按键的keyCode action downtime eventtime等
            initializeKeyEvent(&event, keyEntry);
            event.setFlags(event.getFlags() | AKEY_EVENT_FLAG_CANCELED);

            mLock.unlock();
            //继续分发事件

            mPolicy->dispatchUnhandledKey(connection->inputChannel->getToken(),
                                          &event, keyEntry->policyFlags, &event);

          ...............

}

android\frameworks\base\services\core\jni\com_android_server_input_InputManagerService.cpp
bool NativeInputManager::dispatchUnhandledKey(const sp<IBinder>& token,
        const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) {
  ........
    if (policyFlags & POLICY_FLAG_TRUSTED) {
    ......
        if (keyEventObj) {
        //回调到JAVA层InputManagerService.java
            jobject fallbackKeyEventObj = env->CallObjectMethod(mServiceObj,
                    gServiceClassInfo.dispatchUnhandledKey,
                    tokenObj, keyEventObj, policyFlags);
            if (checkAndClearExceptionFromCallback(env, "dispatchUnhandledKey")) {
                fallbackKeyEventObj = nullptr;
            }
      ........      
    }
    return result;
}

事件是从native层的InputDispatcher.cpp一直传到java层，在native层主要做了keyevent的封装，循环等待下一次事件的分发。

二、从native调用到java层后，我们继续看看它的数据流向是怎么调用到关机提示框的

frameworks\base\services\core\java\com\android\server\input\InputManagerService.java
//由native层com_android_server_input_InputManagerService.cpp的NativeInputManager::dispatchUnhandledKey回调
private KeyEvent dispatchUnhandledKey(IBinder focus, KeyEvent event, int policyFlags) {
    return mWindowManagerCallbacks.dispatchUnhandledKey(focus, event, policyFlags);
}

mWindowManagerCallbacks是在SystemServer.startOtherServices得到InputManagerCallback并设置的，所以dispatchUnhandledKey是在InputManagerCallback.java

frameworks\base\services\core\java\com\android\server\wm\InputManagerCallback.java
public KeyEvent dispatchUnhandledKey(
        IBinder focus, KeyEvent event, int policyFlags) {
    WindowState windowState = mService.windowForClientLocked(null, focus, false);
    //mService.mPolicy是PhoneWindowManager的实例
    return mService.mPolicy.dispatchUnhandledKey(windowState, event, policyFlags);
}

直接看它的调用栈：

PhoneWindowManager.dispatchUnhandledKey-->PhoneWindowManager.interceptFallback --> PhoneWindowManager.interceptKeyBeforeDispatching -->PhoneWindowManager.interceptPowerKeyDown -->PhoneWindowManager.powerLongPress -->PhoneWindowManager. showGlobalActionsInternal-->GlobalActions.showDialog -->LegacyGlobalActions.showDialog

最后走到LegacyGlobalActions类，该类是关机提示框的实现类，提示框的显示、逻辑处理都是在此实现，对话框显示的不仅仅是关机/重启，还有飞行模式、截图、锁定等，不同的手机开发商定制的功能也不同，对话框的创建逻辑

frameworks\base\services\core\java\com\android\server\policy\LegacyGlobalActions.java
private ActionsDialog createDialog() {
    // Simple toggle style if there's no vibrator, otherwise use a tri-state
    if (!mHasVibrator) {
        mSilentModeAction = new SilentModeToggleAction();
    } else {
        mSilentModeAction = new SilentModeTriStateAction(mContext, mAudioManager, mHandler);
    }
    //飞行模式相关
    mAirplaneModeOn = new ToggleAction(
            R.drawable.ic_lock_airplane_mode,
            R.drawable.ic_lock_airplane_mode_off,
            R.string.global_actions_toggle_airplane_mode,
            R.string.global_actions_airplane_mode_on_status,
            R.string.global_actions_airplane_mode_off_status) {
            ....................
        }

        @Override
        public boolean showDuringKeyguard() {
            return true;
        }

        @Override
        public boolean showBeforeProvisioning() {
            return false;
        }
    };
    onAirplaneModeChanged();

    mItems = new ArrayList<Action>();
    String[] defaultActions = mContext.getResources().getStringArray(
            com.android.internal.R.array.config_globalActionsList);

    ArraySet<String> addedKeys = new ArraySet<String>();
    for (int i = 0; i < defaultActions.length; i++) {
        String actionKey = defaultActions[i];
        if (addedKeys.contains(actionKey)) {
          ...................
        } else if (GLOBAL_ACTION_KEY_RESTART.equals(actionKey)) {
            mItems.add(new RestartAction(mContext, mWindowManagerFuncs));//把重启添加到列表
        } else {
            Log.e(TAG, "Invalid global action key " + actionKey);
        }
        // Add here so we don't add more than one.
        addedKeys.add(actionKey);
    }

    ...............
    ActionsDialog dialog = new ActionsDialog(mContext, params);
    dialog.setCanceledOnTouchOutside(false); // Handled by the custom class.

    dialog.getListView().setItemsCanFocus(true);
    dialog.getListView().setLongClickable(true);
    dialog.getListView().setOnItemLongClickListener(//对话框长按事件
            new AdapterView.OnItemLongClickListener() {
                @Override
                public boolean onItemLongClick(AdapterView<?> parent, View view, int position,
                        long id) {
                    final Action action = mAdapter.getItem(position);
                    if (action instanceof LongPressAction) {
                        return ((LongPressAction) action).onLongPress();
                    }
                    return false;
                }
    });
    dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);

    dialog.setOnDismissListener(this);

    return dialog;
}

对话框Item的点击事件，点击事件后的onPress()是RestartAction里的onPress()

frameworks\base\services\core\java\com\android\server\policy\LegacyGlobalActions.java
@Override
public void onClick(DialogInterface dialog, int which) {
    if (!(mAdapter.getItem(which) instanceof SilentModeTriStateAction)) {
        dialog.dismiss();
    }
    mAdapter.getItem(which).onPress();//这里会走到RestartAction.onPress())
}

在RestartAction.onPress()直接调用了mWindowManagerFuncs.reboot(false)，mWindowManagerFuncs是WindowManagerService的实例，直接看它里面的reboot函数，该函数直接调用了ShutdownThread.reboot。

三、ShutdownThread是重启/关机的类，重启/关机的逻辑主要在此类实现。

先看看此类的基本结构，此类是final类，不能被其他类继承，也不能被其他类覆盖，属于线程类，继承Thread。

ShutdownThread.reboot进入到了shutdownInner然后调用ShutdownThread.beginShutdownSequence，在这里主要做了显示关机进度对话框、保持屏幕打开，启动线程

frameworks\base\services\core\java\com\android\server\power\ShutdownThread.java
private static void beginShutdownSequence(Context context) {
  ........
  //设置关机进度对话框
    sInstance.mProgressDialog = showShutdownDialog(context);
    sInstance.mContext = context;
    sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);

    // 确保不进入休眠
    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;
    }

    //确保屏幕打开
    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;
        }
    }
 .............
    };
    sInstance.start();//启动线程
}

启动线程后，进入到run()

frameworks\base\services\core\java\com\android\server\power\ShutdownThread.java
public void run() {
    ...................
    //重启后是否进入安全模式
    if (mRebootSafeMode) {
        SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");
    }

     //检测是否有关机动画，禁止屏幕旋转
    if (checkAnimationFileExist()) {
        freeze_orien_shutdownanim();
    }

  ............
    // 发送关机广播
    mActionDone = false;
    Intent intent = new Intent(Intent.ACTION_SHUTDOWN);
    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND | Intent.FLAG_RECEIVER_REGISTERED_ONLY);
    if (checkAnimationFileExist()) {
       intent.putExtra("PLAY_SHUTDOWN_ANIMATION",1);
    }
    mContext.sendOrderedBroadcastAsUser(intent,
            UserHandle.ALL, null, br, mHandler, 0, null, null);

    //检查是否有关机动画
    if (checkAnimationFileExist()) {
        start_shutdownanim();//显示关机动画，----【见小节3.1】
        thaw_orien_shutdownanim();//解除禁止屏幕旋转
    }
   ..................
    if (am != null) {
        try {
            am.shutdown(MAX_BROADCAST_TIME);//关闭activityManager-----【见小节3.2】
        } catch (RemoteException e) {
        }
    }
   ................
    final PackageManagerService pm = (PackageManagerService)
        ServiceManager.getService("package");
    if (pm != null) {
        pm.shutdown();//关闭PackageManager ----------【见小节3.3】
    }
    ............
    shutdownRadios(MAX_RADIO_WAIT_TIME);//关闭射频
    ...........
    if (checkAnimationFileExist()) {
        wait_shutdownanim_end();//等待动画结束 -------------【见小节3.4】
    }
    mPowerManager.goToSleep(SystemClock.uptimeMillis());//关闭屏幕，进入休眠
    rebootOrShutdown(mContext, mReboot, mReason);//重启或关机 ------【见小节3.5】
}

线程run主要是对关机进度、关机动画、关闭AMS、PMS、射频等，最后等待动画结束，关闭屏幕进入休眠，真正进入重启或关机

3.1 ShutdownThread.start_shutdownanim

private static void start_shutdownanim() {
    try {
        SystemProperties.set(LOOP_COMPLETED_PROP_NAME, "false");
        SystemProperties.set("service.bootanim.exit", "0");
        SystemProperties.set("ctl.start", "shutdownanim");
    } catch (Exception e){
       Log.e(TAG,"shutdownanim command exe err!");
    }
}

这里设置了两个属性，一个标记动画是否退出，一个是显示关机动画。属性“ctrl.start”和"ctrl.stop"是用来启动和停止服务，这里表示启动关机动画，然后显示关机动画的画面

3.2 ActivityManagerService.shutdown

public boolean shutdown(int timeout) {
    //检测权限
    if (checkCallingPermission(android.Manifest.permission.SHUTDOWN)
            != PackageManager.PERMISSION_GRANTED) {
        throw new SecurityException("Requires permission "
                + android.Manifest.permission.SHUTDOWN);
    }

    final boolean timedout = mAtmInternal.shuttingDown(mBooted, timeout);//关闭activity ------【见3.2.1】

    mAppOpsService.shutdown();//关闭op的服务，其实就是把应用的操作时间、uid等保存到 /data/system/appops.xml
    if (mUsageStatsService != null) {
        mUsageStatsService.prepareShutdown();//关闭使用状态服务，把状态信息写入到/data/system/users/0/app_idle_stats.xml
    }
    mBatteryStatsService.shutdown();//关闭电池状态服务 --------【见3.2.2】
    synchronized (this) {
        mProcessStats.shutdownLocked();//保存当前进程的状态，把进程信息写入到/data/system/procstats目录下
    }

    return timedout;
}

3.2.1 ActivityTaskManagerService.ShuttingDown

public boolean shuttingDown(boolean booted, int timeout) {
    synchronized (mGlobalLock) {
        mShuttingDown = true;
        mRootActivityContainer.prepareForShutdown();//屏幕进入休眠
        updateEventDispatchingLocked(booted);//关闭触摸、按键等事件的分发
        notifyTaskPersisterLocked(null, true);//更新最近任务 移除最近应用的缩略图、保存最近应用的信息到/data/system_ce/0/recent_tasks目录下
        return mStackSupervisor.shutdownLocked(timeout);//关闭activity栈管理
    }
}

3.2.2 BatteryStatesService.shutdown

public void shutdown() {
    Slog.w("BatteryStats", "Writing battery stats before shutdown...");

    syncStats("shutdown", BatteryExternalStatsWorker.UPDATE_ALL);

    synchronized (mStats) {
        //调用到BatteryStatsImpl.shutdownLocked,保存当前电池状态到/data/system/batterystats.bin,把之前的电池状态信息保存到/data/system/battery-history目录下
        mStats.shutdownLocked();
    }
    // 关闭当前线程池
    mWorker.shutdown();
}

3.3 PackageManagerService.shutdown

public void shutdown() {
    mPackageUsage.writeNow(mPackages);//保存应用使用的数据到/data/system/package-usage.list
    mCompilerStats.writeNow();//统计文件预编译的信息并保存到/data/system/package-cstats.list
    mDexManager.writePackageDexUsageNow();//把使用了dex的应用信息保存到/data/system/package-dex-usage.list
    PackageWatchdog.getInstance(mContext).writeNow();

    // This is the last chance to write out pending restriction settings
    synchronized (mPackages) {
        if (mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
            mHandler.removeMessages(WRITE_PACKAGE_RESTRICTIONS);
            for (int userId : mDirtyUsers) {
                mSettings.writePackageRestrictionsLPr(userId);//把应用的信息保存到/data/system/users/0/package-restrictions.xml
            }
            mDirtyUsers.clear();
        }
    }
}

3.4 ShutdownThread.wait_shutdownanim_end

frameworks\base\services\core\java\com\android\server\power\ShutdownThread.java
private static final String LOOP_COMPLETED_PROP_NAME = "sys.anim_loop.completed";
private static void wait_shutdownanim_end() {
    while(!SystemProperties.get(LOOP_COMPLETED_PROP_NAME, "false").equals("true")) {
        try {
            Thread.sleep(200);
        } catch (Exception e) {
        }
    }
}

通过循环监听sys.anim_loop.completed的属性值来判断是否退出关机动画

3.5 ShutdownThread.rebootOrShutdown

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) {//如果是关机，则开启震动
        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);
        }
        try {
            Thread.sleep(SHUTDOWN_VIBRATE_MS);
        } catch (InterruptedException unused) {
        }
    }
    // 进入关机
    Log.i(TAG, "Performing low-level shutdown...");
    PowerManagerService.lowLevelShutdown(reason);
}

我们来看看进入重启lowLevelReboot函数做了什么

base/services/core/java/com/android/server/power/PowerManagerService.java
public static void lowLevelReboot(String reason) {
    if (reason == null) {
        reason = "";
    }
    //根据reason重启后进入哪一种模式
    if (reason.equals(PowerManager.REBOOT_QUIESCENT)) {
        sQuiescent = true;
        reason = "";
    } else if (reason.endsWith("," + PowerManager.REBOOT_QUIESCENT)) {
        sQuiescent = true;
        reason = reason.substring(0,
                reason.length() - PowerManager.REBOOT_QUIESCENT.length() - 1);
    }

    if (reason.equals(PowerManager.REBOOT_RECOVERY)
            || reason.equals(PowerManager.REBOOT_RECOVERY_UPDATE)) {
        reason = "recovery";
    }

    if (sQuiescent) {
        reason = reason + ",quiescent";
    }

    SystemProperties.set("sys.powerctl", "reboot," + reason);//设置sys.powerctl属性
    try {
        Thread.sleep(20 * 1000L);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    Slog.wtf(TAG, "Unexpected return from lowLevelReboot!");
}

可以看到我们可以根据参数reason来设置重启后让设备进入哪一种模式，最后把reboot和reason一起保存到属性sys.powerctl上，init进程监听到sys.powerctl被设置了，如果值是reboot则开启开机的流程。

如重启后需要进入recovery模式则只需把reason赋值为recovery，

在关机流程中，调用的是PowerManagerService.lowLevelShutdown函数，这个函数仅设置sys.powerctl的属性值为shutdown和reason。

四、为什么设置了sys.powerctl的属性设备就关机/重启了呢？继续跟随sys.powerctl的属性，看看做了哪些事情

system/core/init/propery_service.cpp
uint32_t HandlePropertySet(const std::string& name, const std::string& value,
                           const std::string& source_context, const ucred& cr,
                           SocketConnection* socket, std::string* error) {
    if (auto ret = CheckPermissions(name, value, source_context, cr, error); ret != PROP_SUCCESS) {
        return ret;
    }

    if (StartsWith(name, "ctl.")) {//以ctl.开头的属性进入另外一个分支
        return SendControlMessage(name.c_str() + 4, value, cr.pid, socket, error);
    }

    // sys.powerctl is a special property that is used to make the device reboot.  We want to log
    // any process that sets this property to be able to accurately blame the cause of a shutdown.
    if (name == "sys.powerctl") {//关注点
        std::string cmdline_path = StringPrintf("proc/%d/cmdline", cr.pid);
        std::string process_cmdline;
        std::string process_log_string;
        if (ReadFileToString(cmdline_path, &process_cmdline)) {//通过pid读取进程名
            // Since cmdline is null deliminated, .c_str() conveniently gives us just the process
            // path.
            process_log_string = StringPrintf(" (%s)", process_cmdline.c_str());
        }
        LOG(INFO) << "Received sys.powerctl='" << value << "' from pid: " << cr.pid
                  << process_log_string;
    }
    .........
    return PropertySet(name, value, error);
}

属性有改变时，就会触发property_changed

system/core/init/init.cpp
void property_changed(const std::string& name, const std::string& value) {

    if (name == "sys.powerctl") {

        shutdown_command = value;//属性值赋给shutdown_command
        do_shutdown = true;
    }

    if (property_triggers_enabled) ActionManager::GetInstance().QueuePropertyChange(name, value);

    if (waiting_for_prop) {
        if (wait_prop_name == name && wait_prop_value == value) {
            LOG(INFO) << "Wait for property '" << wait_prop_name << "=" << wait_prop_value
                      << "' took " << *waiting_for_prop;
            ResetWaitForProp();
        }
    }
}

system/core/init/init.cpp
int SecondStageMain(int argc, char** argv) {
    ............
    while (true) {
        // By default, sleep until something happens.
        auto epoll_timeout = std::optional<std::chrono::milliseconds>{};

        if (do_shutdown && !shutting_down) {
            do_shutdown = false;
            if (HandlePowerctlMessage(shutdown_command)) {//关机/重启消息---【见4.1小节】
                shutting_down = true;
            }
        }

        if (!(waiting_for_prop || Service::is_exec_service_running())) {
            am.ExecuteOneCommand();//只需命令，命令的发送是在HandlePowerctlMessage函数里封装的
        }
        if (!(waiting_for_prop || Service::is_exec_service_running())) {
            if (!shutting_down) {
                auto next_process_action_time = HandleProcessActions();

                // If there's a process that needs restarting, wake up in time for that.
                if (next_process_action_time) {
                    epoll_timeout = std::chrono::ceil<std::chrono::milliseconds>(
                            *next_process_action_time - boot_clock::now());
                    if (*epoll_timeout < 0ms) epoll_timeout = 0ms;
                }
            }

            // If there's more work to do, wake up again immediately.
            if (am.HasMoreCommands()) epoll_timeout = 0ms;
        }

        if (auto result = epoll.Wait(epoll_timeout); !result) {//进入等待，不会消耗CPU，时间到达epoll_timeout后唤醒
            LOG(ERROR) << result.error();
        }
    }

    return 0;
}

SecondStageMain是在开机阶段进行的，通过while进入死循环，epoll.wait进入等待，时间到达后唤醒

4.1小节

system/core/init/reboot.cpp
bool HandlePowerctlMessage(const std::string& command) {
    unsigned int cmd = 0;
    std::vector<std::string> cmd_params = Split(command, ",");
    std::string reboot_target = "";
    bool run_fsck = false;
    bool command_invalid = false;

    if (cmd_params.size() > 3) {
        command_invalid = true;
    } else if (cmd_params[0] == "shutdown") {
        cmd = ANDROID_RB_POWEROFF;//如果是手动关机，cmd_params.size为1
        if (cmd_params.size() == 2) {
            if (cmd_params[1] == "userrequested") {
                // The shutdown reason is PowerManager.SHUTDOWN_USER_REQUESTED.
                // Run fsck once the file system is remounted in read-only mode.
                run_fsck = true;
            } else if (cmd_params[1] == "thermal") {
                // Turn off sources of heat immediately.
                TurnOffBacklight();
                // run_fsck is false to avoid delay
                cmd = ANDROID_RB_THERMOFF;
            }
        }
    } else if (cmd_params[0] == "reboot") {
        cmd = ANDROID_RB_RESTART2;
        if (cmd_params.size() >= 2) {
            reboot_target = cmd_params[1];
            // adb reboot fastboot should boot into bootloader for devices not
            // supporting logical partitions.
            if (reboot_target == "fastboot" &&
                !android::base::GetBoolProperty("ro.boot.dynamic_partitions", false)) {
                reboot_target = "bootloader";
            }
            // When rebooting to the bootloader notify the bootloader writing
            // also the BCB.
            if (reboot_target == "bootloader") {//重启进入bootloader
                std::string err;
                if (!write_reboot_bootloader(&err)) {
                    LOG(ERROR) << "reboot-bootloader: Error writing "
                                  "bootloader_message: "
                               << err;
                }
            } else if (reboot_target == "sideload" || reboot_target == "sideload-auto-reboot" ||
                       reboot_target == "fastboot") {
                std::string arg = reboot_target == "sideload-auto-reboot" ? "sideload_auto_reboot"
                                                                          : reboot_target;
                const std::vector<std::string> options = {
                        "--" + arg,
                };
                std::string err;
                if (!write_bootloader_message(options, &err)) {
                    LOG(ERROR) << "Failed to set bootloader message: " << err;
                    return false;
                }
                reboot_target = "recovery";
            }

            // If there is an additional parameter, pass it along
            if ((cmd_params.size() == 3) && cmd_params[2].size()) {
                reboot_target += "," + cmd_params[2];
            }
        }
    } else {
        command_invalid = true;
    }
    if (command_invalid) {
        LOG(ERROR) << "powerctl: unrecognized command '" << command << "'";
        return false;
    }

    LOG(INFO) << "Clear action queue and start shutdown trigger";
    ActionManager::GetInstance().ClearQueue();
    // Queue shutdown trigger first
    ActionManager::GetInstance().QueueEventTrigger("shutdown");
    // Queue built-in shutdown_done
    auto shutdown_handler = [cmd, command, reboot_target, run_fsck](const BuiltinArguments&) {
        DoReboot(cmd, command, reboot_target, run_fsck);//做重启命令---【见4.2小节】
        return Success();
    };
    ..............
    return true;
}

4.2小节

static void DoReboot(unsigned int cmd, const std::string& reason, const std::string& rebootTarget,
                     bool runFsck) {
    ..................
    // 关闭步骤
    // 1. 关闭出关键的服务之外的所有服务
    if (shutdown_timeout > 0ms) {
        LOG(INFO) << "terminating init services";

        // Ask all services to terminate except shutdown critical ones.
        for (const auto& s : ServiceList::GetInstance().services_in_shutdown_order()) {
            if (!s->IsShutdownCritical()) s->Terminate();
        }

        int service_count = 0;
        // Only wait up to half of timeout here
        auto termination_wait_timeout = shutdown_timeout / 2;
        while (t.duration() < termination_wait_timeout) {
            ReapAnyOutstandingChildren();

            service_count = 0;
            for (const auto& s : ServiceList::GetInstance()) {
                // Count the number of services running except shutdown critical.
                // Exclude the console as it will ignore the SIGTERM signal
                // and not exit.
                // Note: SVC_CONSOLE actually means "requires console" but
                // it is only used by the shell.
                if (!s->IsShutdownCritical() && s->pid() != 0 && (s->flags() & SVC_CONSOLE) == 0) {
                    service_count++;
                }
            }

            if (service_count == 0) {
                // All terminable services terminated. We can exit early.
                break;
            }

            // Wait a bit before recounting the number or running services.
            std::this_thread::sleep_for(50ms);
        }
        LOG(INFO) << "Terminating running services took " << t
                  << " with remaining services:" << service_count;
    }

    // minimum safety steps before restarting
    // 2. 关闭出关机之外的所有服务
    for (const auto& s : ServiceList::GetInstance().services_in_shutdown_order()) {
        if (!s->IsShutdownCritical()) s->Stop();
    }
    SubcontextTerminate();
    ReapAnyOutstandingChildren();

    // 3. 关闭ROM的所有分区
    Service* voldService = ServiceList::GetInstance().FindService("vold");
    if (voldService != nullptr && voldService->IsRunning()) {
        ShutdownVold();
        voldService->Stop();
    } else {
        LOG(INFO) << "vold not running, skipping vold shutdown";
    }
    // logcat stopped here
    for (const auto& s : ServiceList::GetInstance().services_in_shutdown_order()) {
        if (kill_after_apps.count(s->name())) s->Stop();
    }
    // 4. 卸载所有硬盘分区等
    {
        Timer sync_timer;
        LOG(INFO) << "sync() before umount...";
        sync();
        LOG(INFO) << "sync() before umount took" << sync_timer;
    }
    // 5. 清除缓存，关闭Zram分区
    KillZramBackingDevice();

    UmountStat stat = TryUmountAndFsck(runFsck, shutdown_timeout - t.duration());
    // Follow what linux shutdown is doing: one more sync with little bit delay
    {
        Timer sync_timer;
        LOG(INFO) << "sync() after umount...";
        sync();
        LOG(INFO) << "sync() after umount took" << sync_timer;
    }
    if (!is_thermal_shutdown) std::this_thread::sleep_for(100ms);
    LogShutdownTime(stat, &t);
    // 重启
    RebootSystem(cmd, rebootTarget);//进入到了linux和bootable的关机流程.
    abort();
}

五、总结：

android的重启/关机流程从上到下，首先是在kernal层上报事件，frawework的native层InputRead读取到事件后分发给InputDispatcher，InputDispatcher把事件继续传递给java层，java层先做关机对话框显示，用户选择重启/关机后则进入到ShutdownThread类，重启/关机的逻辑是在该线程类里实现的，主要做了显示关机进度、关机动画、关闭屏幕、保存应用状态、保存电池信息等，然后直接通过sys.powerctl把关机/重启/重启后的进入的模式的值写入到属性值里 。在系统开机时通过死循环来来监听sys.powerctl的变化，并引入epoll.wait来挂起，等待时间到达后再唤醒，最后关闭所有服务、清除缓存、卸载分区等五个步骤后，进入linux和bootable的关机流程。可以看到，设置sys.powerctl的属性后是关机的关键，可以用这个属性避开权限的限制等。文章来源地址https://www.toymoban.com/news/detail-757327.html

到了这里，关于详解Android 关机/重启流程的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！