（android 关机/重启）Android关机/重启流程解析_performing low-level shutdown...

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.   
9.     if (mHandler == null || !ActivityManagerNative.isSystemReady()) {  
10.         throw new IllegalStateException("Too early to call reboot()");  
11.     }      
12.   
13.     final String finalReason = reason;  
14.     Runnable runnable = new Runnable() {  
15.         public void run() {  
16.             synchronized (this) {  
17.                 ShutdownThread.reboot(getUiContext(), finalReason, false);  
18.             }      
19.   
20.         }      
21.     };     
22.     // ShutdownThread must run on a looper capable of displaying the UI.  
23.     mHandler.post(runnable);  
24.   
25.     // PowerManager.reboot() is documented not to return so just wait for the inevitable.  
26.     synchronized (runnable) {  
27.         while (true) {  
28.             try {  
29.                 runnable.wait();  
30.             } catch (InterruptedException e) {   
31.             }      
32.         }      
33.     }      
34. }  

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.         if(sPreShutdownApi != null){
               try {
                   sPreShutdownApi.onPowerOff();
               } catch (RemoteException e) {
                   Log.e(TAG, "onPowerOff exception" + e.getMessage());
               }
           }else{
               Log.w(TAG, "sPreShutdownApi is null");
           }
   
           command = SystemProperties.get("sys.ipo.pwrdncap");
   
           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();
               }
           };
2.     /* 
3.      * Write a system property in case the system_server reboots before we 
4.      * get to the actual hardware restart. If that happens, we'll retry at 
5.      * the beginning of the SystemServer startup. 
6.      */   
7.     {     
8.         String reason = (mReboot ? "1" : "0") + (mRebootReason != null ? mRebootReason : "");  
9.         SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason);  
10.     }  
11.   
12.     /* 
13.      * If we are rebooting into safe mode, write a system property 
14.      * indicating so. 
15.      */   
16.     if (mRebootSafeMode) {  
17.         SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1");  
18.     }  
19.     ...  
20.     rebootOrShutdown(mReboot, mRebootReason);  
21. }   

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);  ///重启Reboot
    
13.             } catch (Exception e) {  
14.                 Log.e(TAG, "Reboot failed, will attempt shutdown instead", e);  
15.             }   
16.         } else if (SHUTDOWN_VIBRATE_MS > 0) {  ///关机的时候需要震动，就是这里了 
    
17.                                                                                //SHUTDOWN_VIBRATE_MS，默认的定义是500ms。
18.             // vibrate before shutting down  
19.             Vibrator vibrator = new SystemVibrator();  
20.             try {  
21.                 vibrator.vibrate(SHUTDOWN_VIBRATE_MS);  
22.             } catch (Exception e) {  
23.                 // Failure to vibrate shouldn't interrupt shutdown.  Just log it.  
24.                 Log.w(TAG, "Failed to vibrate during shutdown.", e);  
25.             }     
26.                   
27.             // vibrator is asynchronous so we need to wait to avoid shutting down too soon.  
28.             try {  
29.                 Thread.sleep(SHUTDOWN_VIBRATE_MS);  
30.             } catch (InterruptedException unused) {  
31.             }     
32.         }     
33.               
34.         // Shutdown power  
35.         Log.i(TAG, "Performing low-level shutdown...");  
36.         PowerManagerService.lowLevelShutdown();直接关机Shutdown
    
37.     }  
38. }  

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. /**   
13.  * Low-level function turn the device off immediately, without trying 
14.  * to be clean.  Most people should use 
15.  * {@link com.android.server.pm.internal.app.ShutdownThread} for a clean shutdown. 
16.  */  
17. public static void lowLevelShutdown() {  
18.     nativeShutdown();  
19. }   

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

        ===>>>>>android 4.4 中的lowLevelShutdown  以及  lowLevelReboot

public static void lowLevelShutdown() {
        SystemProperties.set("sys.powerctl", "shutdown");直接关机
    }

    /**
     * Low-level function to reboot the device. On success, this function
     * doesn't return. If more than 5 seconds passes from the time,
     * a reboot is requested, this method returns.
     *
     * @param reason code to pass to the kernel (e.g. "recovery"), or null.
     */
    public static void lowLevelReboot(String reason) {
        if (reason == null) {
            reason = "";
        }
        SystemProperties.set("sys.powerctl", "reboot," + reason);///重启
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

【注解：】

        关机流程中最后是通过修改Android属性进行关机操作(SystemProperties.java通过JNI调用访问系统属性)。

        当然我们也可以通过adb命令修改Android系统属性执行关机操作，例如adb shell setpro sys.powerctl shutdown。

         这里我们简单介绍下修改Android属性关机的原理或流程。

native_set()--->SystemProperties_set()

这是SystemProperties.java类中设置系统函数的方法。