1. /**
2. * Reboot the device.  Will not return if the reboot is
3. * successful.  Requires the {@link android.Manifest.permission#REBOOT}
4. * permission.
5. *
6. * @param reason code to pass to the kernel (e.g., "recovery") to
7. *               request special boot modes, or null.
8. */
9. public void reboot(String reason)
10. {
11. try {
12. mService.reboot(reason);
13. } catch (RemoteException e) {
14. }
15. }

1. /**
2. * {@hide}
3. */
4. public PowerManager(IPowerManager service, Handler handler)
5. {
6. mService = service;
7. mHandler = handler;
8. }

1. interface IPowerManager
2. {
3. ...
4. void reboot(String reason);
5. ...
6. }

1. /**
2. * Reboot the device immediately, passing 'reason' (may be null)
3. * to the underlying __reboot system call.  Should not return.
4. */
5. public void reboot(String reason)
6. {
7. mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null);
8. if (mHandler == null || !ActivityManagerNative.isSystemReady()) {
9. throw new IllegalStateException("Too early to call reboot()");
10. }
11. final String finalReason = reason;
12. Runnable runnable = new Runnable() {
13. public void run() {
14. synchronized (this) {
15. ShutdownThread.reboot(getUiContext(), finalReason, false);
16. }
17. }
18. };
19. // ShutdownThread must run on a looper capable of displaying the UI.
20. mHandler.post(runnable);
21. // PowerManager.reboot() is documented not to return so just wait for the inevitable.
22. synchronized (runnable) {
23. while (true) {
24. try {
25. runnable.wait();
26. } catch (InterruptedException e) {
27. }
28. }
29. }
30. }

1. /**
2. * Request a clean shutdown, waiting for subsystems to clean up their
3. * state etc.  Must be called from a Looper thread in which its UI
4. * is shown.
5. *
6. * @param context Context used to display the shutdown progress dialog.
7. * @param reason code to pass to the kernel (e.g. "recovery"), or null.
8. * @param confirm true if user confirmation is needed before shutting down.
9. */
10. public static void reboot(final Context context, String reason, boolean confirm) {
11. mReboot = true;
12. mRebootSafeMode = false;
13. mRebootReason = reason;
14. shutdownInner(context, confirm);
15. }

1. /**
2. * Makes sure we handle the shutdown gracefully.
3. * Shuts off power regardless of radio and bluetooth state if the alloted time has passed.
4. */
5. public void run() {
6. BroadcastReceiver br = new BroadcastReceiver() {
7. @Override public void onReceive(Context context, Intent intent) {
8. // We don't allow apps to cancel this, so ignore the result.
9. actionDone();
10. }
11. };
12. /*
13. * Write a system property in case the system_server reboots before we
14. * get to the actual hardware restart. If that happens, we'll retry at
15. * the beginning of the SystemServer startup.
16. */
17. {
18. String reason = (mReboot ? "1" : "0") + (mRebootReason != null ? mRebootReason : "");
19. SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason);
20. }
21. /*
22. * If we are rebooting into safe mode, write a system property
23. * indicating so.
24. */
25. if (mRebootSafeMode) {
26. SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");
27. }
28. ...
29. rebootOrShutdown(mReboot, mRebootReason);
30. }

1. /**
2. * Do not call this directly. Use {@link #reboot(Context, String, boolean)}
3. * or {@link #shutdown(Context, boolean)} instead.
4. *
5. * @param reboot true to reboot or false to shutdown
6. * @param reason reason for reboot
7. */
8. public static void rebootOrShutdown(boolean reboot, String reason) {
9. if (reboot) {
10. Log.i(TAG, "Rebooting, reason: " + reason);
11. try {
12. PowerManagerService.lowLevelReboot(reason);
13. } catch (Exception e) {
14. Log.e(TAG, "Reboot failed, will attempt shutdown instead", e);
15. }
16. } else if (SHUTDOWN_VIBRATE_MS > 0) {
17. // vibrate before shutting down
18. Vibrator vibrator = new SystemVibrator();
19. try {
20. vibrator.vibrate(SHUTDOWN_VIBRATE_MS);
21. } catch (Exception e) {
22. // Failure to vibrate shouldn't interrupt shutdown.  Just log it.
23. Log.w(TAG, "Failed to vibrate during shutdown.", e);
24. }
25. // vibrator is asynchronous so we need to wait to avoid shutting down too soon.
26. try {
27. Thread.sleep(SHUTDOWN_VIBRATE_MS);
28. } catch (InterruptedException unused) {
29. }
30. }
31. // Shutdown power
32. Log.i(TAG, "Performing low-level shutdown...");
33. PowerManagerService.lowLevelShutdown();
34. }
35. }

1. /**
2. * Request a clean shutdown, waiting for subsystems to clean up their
3. * state etc.  Must be called from a Looper thread in which its UI
4. * is shown.
5. *
6. * @param context Context used to display the shutdown progress dialog.
7. * @param confirm true if user confirmation is needed before shutting down.
8. */
9. public static void shutdown(final Context context, boolean confirm) {
10. mReboot = false;
11. mRebootSafeMode = false;
12. shutdownInner(context, confirm);
13. }

1. /**
2. * Low-level function to reboot the device.
3. *
4. * @param reason code to pass to the kernel (e.g. "recovery"), or null.
5. * @throws IOException if reboot fails for some reason (eg, lack of
6. *         permission)
7. */
8. public static void lowLevelReboot(String reason) throws IOException {
9. nativeReboot(reason);
10. }
11. /**
12. * Low-level function turn the device off immediately, without trying
13. * to be clean.  Most people should use
14. * {@link com.android.server.pm.internal.app.ShutdownThread} for a clean shutdown.
15. */
16. public static void lowLevelShutdown() {
17. nativeShutdown();
18. }

1. private static native void nativeShutdown();
2. private static native void nativeReboot(String reason) throws IOException;

1. static JNINativeMethod gPowerManagerServiceMethods[] = {
2. /* name, signature, funcPtr */
3. ...
4. { "nativeShutdown", "()V",
5. (void*) nativeShutdown },
6. { "nativeReboot", "(Ljava/lang/String;)V",
7. (void*) nativeReboot },
8. ...
9. };

1. static void nativeShutdown(JNIEnv *env, jobject clazz) {
2. android_reboot(ANDROID_RB_POWEROFF, 0, 0);
3. }
4. static void nativeReboot(JNIEnv *env, jobject clazz, jstring reason) {
5. if (reason == NULL) {
6. android_reboot(ANDROID_RB_RESTART, 0, 0);
7. } else {
8. const char *chars = env->GetStringUTFChars(reason, NULL);
9. android_reboot(ANDROID_RB_RESTART2, 0, (char *) chars);
10. env->ReleaseStringUTFChars(reason, chars);  // In case it fails.
11. }
12. jniThrowIOException(env, errno);
13. }

1. int android_reboot(int cmd, int flags, char *arg)
2. {
3. int ret = 0;
4. int reason = -1;
5. #ifdef RECOVERY_PRE_COMMAND
6. if (cmd == (int) ANDROID_RB_RESTART2) {
7. if (arg && strlen(arg) > 0) {
8. char cmd[PATH_MAX];
9. sprintf(cmd, RECOVERY_PRE_COMMAND " %s", arg);
10. system(cmd);
11. }
12. }
13. #endif
14. if (!(flags & ANDROID_RB_FLAG_NO_SYNC))
15. sync();
16. if (!(flags & ANDROID_RB_FLAG_NO_REMOUNT_RO))
17. remount_ro();
18. switch (cmd) {
19. case ANDROID_RB_RESTART:
20. reason = RB_AUTOBOOT;
21. break;
22. case ANDROID_RB_POWEROFF:
23. ret = reboot(RB_POWER_OFF);
24. return ret;
25. case ANDROID_RB_RESTART2:
26. // REBOOT_MAGIC
27. break;
28. default:
29. return -1;
30. }
31. #ifdef RECOVERY_PRE_COMMAND_CLEAR_REASON
32. reason = RB_AUTOBOOT;
33. #endif
34. if (reason != -1)
35. ret = reboot(reason);
36. else
37. ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
38. LINUX_REBOOT_CMD_RESTART2, arg);
39. return ret;
40. }

1. #define RB_AUTOBOOT     LINUX_REBOOT_CMD_RESTART
2. #define RB_HALT_SYSTEM  LINUX_REBOOT_CMD_HALT
3. #define RB_ENABLE_CAD   LINUX_REBOOT_CMD_CAD_ON
4. #define RB_DISABLE_CAD  LINUX_REBOOT_CMD_CAD_OFF
5. #define RB_POWER_OFF    LINUX_REBOOT_CMD_POWER_OFF

1. #define LINUX_REBOOT_MAGIC1 0xfee1dead
2. #define LINUX_REBOOT_MAGIC2 672274793
3. /* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
4. #define LINUX_REBOOT_MAGIC2A 85072278
5. #define LINUX_REBOOT_MAGIC2B 369367448
6. #define LINUX_REBOOT_MAGIC2C 537993216
7. #define LINUX_REBOOT_CMD_RESTART 0x01234567
8. /* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
9. #define LINUX_REBOOT_CMD_HALT 0xCDEF0123
10. #define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF
11. #define LINUX_REBOOT_CMD_CAD_OFF 0x00000000
12. #define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC
13. /* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
14. #define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
15. #define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2
16. #define LINUX_REBOOT_CMD_KEXEC 0x45584543

1. int reboot (int  mode)
2. {
3. return __reboot( LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, mode, NULL );
4. }

1. ENTRY(__reboot)
2. .save   {r4, r7}
3. stmfd   sp!, {r4, r7}
4. ldr     r7, =__NR_reboot
5. swi     #0
6. ldmfd   sp!, {r4, r7}
7. movs    r0, r0
8. bxpl    lr
9. b       __set_syscall_errno
10. END(__reboot)

1. #define __NR_reboot                       (__NR_SYSCALL_BASE + 88)

1. /* kernel/sys.c */
2. #define __NR_setpriority 140
3. __SYSCALL(__NR_setpriority, sys_setpriority)
4. #define __NR_getpriority 141
5. __SYSCALL(__NR_getpriority, sys_getpriority)
6. #define __NR_reboot 142
7. __SYSCALL(__NR_reboot, sys_reboot)

1. asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd,
2. void __user *arg);

1. #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
2. #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
3. #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
4. #define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
5. #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
6. #define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
7. ...
8. #define SYSCALL_DEFINEx(x, sname, ...)              \
9. __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
10. ...
11. #define __SYSCALL_DEFINEx(x, name, ...)                 \
12. asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))

1. #define SYSCALL_DEFINE4(name, ...) \
2. asmlinkage long sys##_name(__SC_DECL##4(__VA_ARGS__))

1. /*
2. * Reboot system call: for obvious reasons only root may call it,
3. * and even root needs to set up some magic numbers in the registers
4. * so that some mistake won't make this reboot the whole machine.
5. * You can also set the meaning of the ctrl-alt-del-key here.
6. *
7. * reboot doesn't sync: do that yourself before calling this.
8. */
9. SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
10. void __user *, arg)
11. {
12. char buffer[256];
13. int ret = 0;
14. /* We only trust the superuser with rebooting the system. */
15. if (!capable(CAP_SYS_BOOT))
16. return -EPERM;
17. /* For safety, we require "magic" arguments. */
18. if (magic1 != LINUX_REBOOT_MAGIC1 ||
19. (magic2 != LINUX_REBOOT_MAGIC2 &&
20. magic2 != LINUX_REBOOT_MAGIC2A &&
21. magic2 != LINUX_REBOOT_MAGIC2B &&
22. magic2 != LINUX_REBOOT_MAGIC2C))
23. return -EINVAL;
24. /* Instead of trying to make the power_off code look like
25. * halt when pm_power_off is not set do it the easy way.
26. */
27. if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
28. cmd = LINUX_REBOOT_CMD_HALT;
29. mutex_lock(&reboot_mutex);
30. switch (cmd) {
31. case LINUX_REBOOT_CMD_RESTART:
32. kernel_restart(NULL);
33. break;
34. case LINUX_REBOOT_CMD_CAD_ON:
35. C_A_D = 1;
36. break;
37. case LINUX_REBOOT_CMD_CAD_OFF:
38. C_A_D = 0;
39. break;
40. case LINUX_REBOOT_CMD_HALT:
41. kernel_halt();
42. do_exit(0);
43. panic("cannot halt");
44. case LINUX_REBOOT_CMD_POWER_OFF:
45. kernel_power_off();
46. do_exit(0);
47. break;
48. case LINUX_REBOOT_CMD_RESTART2:
49. if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
50. ret = -EFAULT;
51. break;
52. }
53. buffer[sizeof(buffer) - 1] = '\0';
54. kernel_restart(buffer);
55. break;
56. #ifdef CONFIG_KEXEC
57. case LINUX_REBOOT_CMD_KEXEC:
58. ret = kernel_kexec();
59. break;
60. #endif
61. #ifdef CONFIG_HIBERNATION
62. case LINUX_REBOOT_CMD_SW_SUSPEND:
63. ret = hibernate();
64. break;
65. #endif
66. default:
67. ret = -EINVAL;
68. break;
69. }
70. mutex_unlock(&reboot_mutex);
71. return ret;
72. }

1. /* We only trust the superuser with rebooting the system. */
2. if (!capable(CAP_SYS_BOOT))
3. return -EPERM;

1. /* For safety, we require "magic" arguments. */
2. if (magic1 != LINUX_REBOOT_MAGIC1 ||
3. (magic2 != LINUX_REBOOT_MAGIC2 &&
4. magic2 != LINUX_REBOOT_MAGIC2A &&
5. magic2 != LINUX_REBOOT_MAGIC2B &&
6. magic2 != LINUX_REBOOT_MAGIC2C))
7. return -EINVAL;

1. /* Instead of trying to make the power_off code look like
2. * halt when pm_power_off is not set do it the easy way.
3. */
4. if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
5. cmd = LINUX_REBOOT_CMD_HALT;

1. /*
2. * Function pointers to optional machine specific functions
3. */
4. void (*pm_power_off)(void);
5. EXPORT_SYMBOL(pm_power_off);

1. pm_power_off = msm_pm_power_off;

1. /*
2. * Commands accepted by the _reboot() system call.
3. *
4. * RESTART     Restart system using default command and mode.
5. * HALT        Stop OS and give system control to ROM monitor, if any.
6. * CAD_ON      Ctrl-Alt-Del sequence causes RESTART command.
7. * CAD_OFF     Ctrl-Alt-Del sequence sends SIGINT to init task.
8. * POWER_OFF   Stop OS and remove all power from system, if possible.
9. * RESTART2    Restart system using given command string.
10. * SW_SUSPEND  Suspend system using software suspend if compiled in.
11. * KEXEC       Restart system using a previously loaded Linux kernel
12. */
13. #define LINUX_REBOOT_CMD_RESTART    0x01234567
14. #define LINUX_REBOOT_CMD_HALT       0xCDEF0123
15. #define LINUX_REBOOT_CMD_CAD_ON     0x89ABCDEF
16. #define LINUX_REBOOT_CMD_CAD_OFF    0x00000000
17. #define LINUX_REBOOT_CMD_POWER_OFF  0x4321FEDC
18. #define LINUX_REBOOT_CMD_RESTART2   0xA1B2C3D4
19. #define LINUX_REBOOT_CMD_SW_SUSPEND 0xD000FCE2
20. #define LINUX_REBOOT_CMD_KEXEC      0x45584543

1. /**
2. *  kernel_power_off - power_off the system
3. *
4. *  Shutdown everything and perform a clean system power_off.
5. */
6. void kernel_power_off(void)
7. {
8. kernel_shutdown_prepare(SYSTEM_POWER_OFF);
9. if (pm_power_off_prepare)
10. pm_power_off_prepare();
11. disable_nonboot_cpus();
12. syscore_shutdown();
13. printk(KERN_EMERG "Power down.\n");
14. kmsg_dump(KMSG_DUMP_POWEROFF);
15. machine_power_off();
16. }
17. EXPORT_SYMBOL_GPL(kernel_power_off);

1. void machine_power_off(void)
2. {
3. machine_shutdown();
4. if (pm_power_off)
5. pm_power_off();
6. }

1. /**
2. *  kernel_restart - reboot the system
3. *  @cmd: pointer to buffer containing command to execute for restart
4. *      or %NULL
5. *
6. *  Shutdown everything and perform a clean reboot.
7. *  This is not safe to call in interrupt context.
8. */
9. void kernel_restart(char *cmd)
10. {
11. kernel_restart_prepare(cmd);
12. if (!cmd)
13. printk(KERN_EMERG "Restarting system.\n");
14. else
15. printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
16. kmsg_dump(KMSG_DUMP_RESTART);
17. machine_restart(cmd);
18. }
19. EXPORT_SYMBOL_GPL(kernel_restart);

1. void machine_restart(char *cmd)
2. {
3. machine_shutdown();
4. arm_pm_restart(reboot_mode, cmd);
5. }
6. ...
7. void (*arm_pm_restart)(char str, const char *cmd) = arm_machine_restart;
8. EXPORT_SYMBOL_GPL(arm_pm_restart);

1. arm_pm_restart = msm_pm_restart;

1. late_initcall_sync(msm_pm_init);

1. static void msm_pm_restart(char str, const char *cmd)
2. {
3. msm_rpcrouter_close();
4. msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0);
5. for (;;)
6. ;
7. }

1. void kernel_restart_prepare(char *cmd)
2. {
3. blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
4. system_state = SYSTEM_RESTART;
5. usermodehelper_disable();
6. device_shutdown();
7. syscore_shutdown();
8. }

1. static int msm_reboot_call
2. (struct notifier_block *this, unsigned long code, void *_cmd)
3. {
4. if ((code == SYS_RESTART) && _cmd) {
5. char *cmd = _cmd;
6. if (!strcmp(cmd, "bootloader")) {
7. restart_reason = 0x77665500;
8. } else if (!strcmp(cmd, "recovery")) {
9. restart_reason = 0x77665502;
10. } else if (!strcmp(cmd, "eraseflash")) {
11. restart_reason = 0x776655EF;
12. } else if (!strncmp(cmd, "oem-", 4)) {
13. unsigned code = simple_strtoul(cmd + 4, 0, 16) & 0xff;
14. restart_reason = 0x6f656d00 | code;
15. } else {
16. restart_reason = 0x77665501;
17. }
18. }
19. return NOTIFY_DONE;
20. }
21. static struct notifier_block msm_reboot_notifier = {
22. .notifier_call = msm_reboot_call,
23. };
24. ...
25. static int __init msm_pm_init(void)
26. {
27. ...
28. register_reboot_notifier(&msm_reboot_notifier);
29. ...
30. }

本文的分析是由Android给出的reboot接口开始的，但是分析来分析去，回头想一想会发现，Android给出的接口reboot就真的只能重启而已，不能进行关机操作，可以在跟踪这个流程的过程中会发现，确实是有存在关机的相关接口的。那么关机该怎么用呢？

frameworks/base/services/java/com/android/serverBatteryService.java

这样就可以了，不用多说了吧。