Android performance optimization – startup process cold start thermal start

1. Start the applicationMethods

　　 Generally speaking, there are two ways to start: cold Start and warm start.

　　1. Cold start: When the application is started, there is no process of the application in the background, then the system will recreate a new one The process is assigned to the application, and the startup method is cold start.

　　2, hot start: when the application is started, there is already a process of the application in the background (for example: press the back key, the home key , Although the application will exit, the process of the application will still remain in the background and you can enter the task list to view), so in the case of an existing process, this startup will start the application from the existing process. This way Called hot start.

　　Features

　　1, cold start: cold start because the system will re-create a new process assigned to it, so it will first create and initialize the Application class, and then create and initialize the MainActivity class (including a series of measurements, layout, Draw), and finally displayed on the interface.

　　2. Hot start: Hot start will start from the existing process, so hot start will not go. Application This step is to go directly to MainActivity (including a series of measurement, layout, and drawing), so the hot start process only needs to create and initialize a MainActivity, instead of creating and initializing an Application,

　　 Because an application from the creation of a new process to the destruction of the process, the Application will only be initialized once.

2. Application startup process

　　Cold start process: When you click on the app’s start icon, the Android system forks from the Zygote process to create a new process and assign it to the application, and then it will create and initialize the application one by one

　　windowBackground and other attributes set to MainActivity and configure some attributes on the Activity level , And then inflate layout, when the onCreate/onStart/onResume method is finished, the measure/layout/draw of contentView is finally displayed on the interface, so until here,

　　 is the first launch of the application, and the interface we see at this time is the so-called first frame. So, to summarize, the application startup process is as follows:

　　Application’s constructor method——> attachBaseContext()——>onCreate()——>Activity construction method——>onCreate()——>Configure the background and other properties in the theme——>onStart()——>onResume()——>Measurement layout drawing display On the interface.

　　The general process is as follows:

　　1. Click on the desktop icon, Launcher will start the default Acticity of the program, and then start various activities according to the logic of the program

　　2, to start Activity, you need to use the ActivityManagerService service process of the application framework layer (Service is also started by the ActivityManagerService process); in the Android application framework layer, ActivityManagerService is a very important interface, < /span>

　　 It is not only responsible for starting Activity and Service, but is also responsible for managing Activity and Service .

　　　　Step 1. Whether to start the Activity through the Launcher, or to start a new one by calling the startActivity interface inside the Activity Activity, through Binder inter-process communication into the ActivityManagerService process, and call the ActivityManagerService.startActivity interface;

　　　　Step 2. ActivityManagerService call ActivityStack.startActivityMayWait to prepare the relevant information of the Activity to be started;

　　　　Step 3. ActivityStack notifies ApplicationThread to schedule Activity start , ApplicationThread here represents the process that calls the ActivityManagerService.startActivity interface. For the scenario of clicking on the application icon, this process is the Launcher,

　　　　 For the scenario of calling startActivity inside the Activity, this process is the process where the Activity is located;

　　　　Step 4. ApplicationThread does not perform the actual startup operation. It enters the ActivityManagerService process by calling the ActivityManagerService.activityPaused interface to see if a new process needs to be created to start the Activity;

　　　　Step 5. For the scenario where the Activity is started by clicking the application icon, the ActivityManagerService will call startProcessLoc in this step ked to create a new process, and for starting a new activity by calling startActivity inside the activity, this step does not need to be performed,

　　　　 because the new Activity is started in the same process as the original Activity;

　　　　Step 6. ActivityManagerServic Call the ApplicationThread.scheduleLaunchActivity interface to notify the corresponding process to perform the operation to start the Activity;

　　　　Step 7. ApplicationThread to start the Activity operation Forward to ActivityThread, ActivityThread imports the corresponding Activity class through ClassLoader, and then starts it.

3. White screen and black screen encountered during cold start and optimized startup time

　　1, white screen problem:

　　 Android Studio 2.0 is upgraded with Instant Run. In order to allow us to quickly deploy the code, Instant Run actually has a very complex logic behind it. For example, if you want to establish a server in the APK to communicate with Android Studio, and compare and replace code differences, white screen problems may occur during the development process.

　　 general release version of the program will not have this phenomenon;

　　 if it will continue If there is a white screen problem, you can view the style file

　　 has added two attributes, windowIsTranslucent and windowNoTitle, set these two attributes to true, you can make the window transparent when the program is initialized. The main interface of the program will be displayed after the end, so you can't see the white screen interface at all.

　　2. Optimization of startup time

　　 first measure the startup time of the activity-------Activity’s reportFullyDrawn( ) Method

　You need to call Activity’s reportFullyDrawn(). It will report in the log how long it took from the apk initialization (the same time as the previous Displayed) to the reportFullyDrawn() method being called.

The log displayed by the reportFullyDrawn() method is similar to this:

ActivityManager: Displayed com.Android.myexample/.StartupTiming: +768ms

on 4.4 Calling the reportFullyDrawn() method will crash (but the log can still be printed normally), prompting that the UPDATE_DEVICE_STATS permission is required, but this permission can only be authorized by the system app. The solution is to adjust it like this

　　try{

code>reportFullyDrawn();

　　}catch(SecurityException E){

　　}

　　 There is also a method to measure the startup time, which is also worth mentioning, that is the screenrecord command

　　 First start the screenrecord command with the-bugreport option (it can add a timestamp to the frames-it should be a feature in L):

　　$adbshellscreenrecord--bugreport/sdcard /launch.mp4
　　 Then click the app icon, wait for the app to display, ctrl-C screenrecord, use the adb pull command to export the file to the computer.

　　$adb pull/sdcard/launch. mp4

　　 Now you can open the recorded video to see what happened. You need a video player that can be viewed frame by frame (Quicktime on the mac is fine, it’s not clear which player is best to use on other os). Now play frame by frame, notice that there is a frame timestamp at the top of the video.

　　 keep going until you find the app icon is highlighted. At this time, the system has processed the click event on the icon, started the app, and recorded the time of this frame. Continue playing frames until you see the first frame of the entire UI of the app. According to different situations (whether there is a start window, whether there is a start screen, etc.),

　　The actual sequence of events and windows may change There are different. For a simple app, you will first see the startup window, and then gradually fade out the real UI of the app. After you see any content on the UI, you should record the first frame. At this point, the app has completed the layout and drawing and is ready to display. At the same time, the time at which this frame occurred is also recorded.

　　 now subtract these two times ((UI displayed)-(icon tapped)); get the app from clicking to drawing Ready all the time. Although this time includes the time before the process starts, at least it can be used to compare with other apps.

　　

Android cold start time optimization

Cold start time refers to the moment when the user clicks on your app until the system calls Activity.onCreate( ). During this time period, WindowManager will first load the windowBackground in the app theme style as the preview element of the app, and then actually load the activity layout

Cold start time optimization

　　 After knowing the principle of Android cold start time, you can pass some tips To optimize the cold start time, so that your app loading becomes "faster" (faster in visual experience). We can make a .9 picture of the background style to start the Activity, and then use this .9 picture as the windowBackground.

　　

　　Picture production After that, we can use it as a preview element in the cold start phase of the app, with the following settings:

• Customize a Theme for the started Activity

  1 2 3

  <style name="AppTheme.Launcher"> <item name="android:windowBackground">@drawable/window_background_statusbar_toolbar_tabitem> style>

  　　

• Apply the new Theme to settings to< code>AndroidManifest.xml

  < div id="highlighter_436631" class="syntaxhighlighter html">

  1 2 3 4 5 6 7< /span> 8 9

  <activity < /div> android :name=".MainActivity" android:theme="@style/AppTheme.Launcher"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> intent-filter code>> < code class="html keyword">activity>

  　　

< /li>

As a new Theme is set for MainActivity, this will overwrite the original Theme, so you need to set it back to the original Theme in MainActivity

public class MainActivity extends AppCompatActivity {@Override protected void onCreate(Bundle savedInstanceState) {// Make sure this line comes before calling super.onCreate( ).  setTheme(R.style.AppTheme); super.onCreate (savedInstanceState);} } 

< div>