In-depth understanding of the Android Instant Run operating mechanism

Instant Run

Instant Run is a new operating mechanism added to Android Studio 2.0. It can significantly reduce the time it takes to build and deploy your current application when you are coding, developing, testing or debugging. In simple terms, when you change your code in Android Studio, Instant Run can quickly let you see the effect of your changes. Before Instant Run, a small change may take tens of seconds or even longer to see the effect of the change.

Traditional code modification and compilation deployment process

The traditional code modification and compilation process is as follows: Build the entire apk → Deploy the app → Restart the app → Restart the Activity

Instant Run compilation and deployment process

The process of building a project with Instant Run: Build the modified part → Deploy the modified dex or resources → Hot deployment, warm deployment, cold deployment

Hot plug, warm plug, cold plug

Hot plugging: Code changes are applied and projected to the app without restarting the app or rebuilding the current activity.

Scenario: Applicable to most simple changes (including modifications to some method implementations or variable values)

Warm unplug: The activity needs to be restarted to see the desired changes.

Scenario: A typical situation is that code modification involves resource files, namely resources.

Cold Unplug: The app needs to be restarted (but still does not need to be reinstalled)

Scenario: Any structural changes, such as changes to inheritance rules or method signatures.

First run of Instant Run, Gradle execution process

A new App Server class will be injected into the App to monitor code changes in conjunction with Bytecode instrumentation.

At the same time, there will be a new Application class, which has a custom class loader injected into it. This Application class will start the newly injected App Server we need. Therefore, the Manifest will be modified to ensure that our application can use this new Application class. (Here you don’t have to worry about inheriting and defining the Application class yourself. The new Application class added by Instant Run will proxy your custom Application class)

At this point, Instant Run is ready to run. When we use it, it will help us greatly shorten the time to build the program by making decisions and making reasonable use of hot and cold plug-ins.

Before Instant Run runs, Android Studio checks whether it can connect to the App Server. And makes sure that the App Server is what Android Studio needs. This also ensures that the app is in the foreground.

Hot Swap

Android Studio monitors: Running Gradle tasks to generate incremental .dex files (this dex file corresponds to the modified classes in development) Android Studio will extract these .dex files and send them to the App Server, and then deploy them to the App (the principle of Gradle modifying classes, please click the link).

App Server will keep monitoring whether the class file needs to be rewritten. If necessary, the task will be executed immediately. New changes can be responded to immediately. We can check it by setting breakpoints.

Warm plug and unplug

Warm plug and unplug requires restarting the Activity, because the resource files are loaded when the Activity is created, so the Activity must be restarted to reload the resource files.

Currently, any modification of resource files will result in repackaging and sending to the APP. However, Google's development team is working on developing an incremental package that will only package the modified resource files and can be deployed to the current APP.

Therefore, warm plugging can only handle a few situations, and it cannot cope with changes in the application's architecture and structure.

Note: The resource file modifications involved in warm plugging are invalid in the manifest (invalid here means that Instant Run will not be started), because the manifest value is read when the APK is installed. Therefore, if you want the resource modifications under the manifest to take effect, you also need to trigger a complete application build and deployment.

Cold plug

When deploying an application, the project will be split into ten parts, each with its own .dex file, and all classes will be assigned to the corresponding .dex file according to the package name. When cold plugging is turned on, the .dex files corresponding to the modified classes will be reorganized into new .dex files and then deployed to the device.

The reason why this can be done is to rely on Android's ART mode, which allows loading multiple .dex files. ART mode was added in Android 4.4 (API-19), but Dalvik is still the first choice. In Android 5.0 (API-21), ART mode became the system default choice, so Instant Run can only run on API-21 and above.

Some notes on using Instant Run

Instant Run is controlled by Android Studio. So we can only start it through the IDE. If we start the application through the device, Instant Run will have abnormal behavior. When using Instant Run to start an Android app, you should pay attention to the following points:

If the minSdkVersion of the application is less than 21, most of the Instant Run features may fail. Here is a solution. Use product flavor to create a new branch with a minSdkVersion greater than 21 for debugging.

Instant Run can currently only run in the main process. If the application is multi-process, like WeChat, and the webView is extracted into a separate process, hot and warm plug-ins will be downgraded to cold plug-ins.

Under Windows, Windows Defender Real-Time Protection may cause Instant Run to crash, which can be solved by adding a whitelist.

There is currently no support for the Jack compiler, Instrumentation Tests, or deploying to multiple devices simultaneously.

Combined with Demo in-depth understanding

To make it easier for everyone to understand, we create a new project without writing any logical functions, and only make a modification to the application:

First, let's decompile the structure of APK using the tools: d2j-dex2jar and jd-gui.

The startup information we want to see is in this instant-run.zip file. Unzip instant-run.zip and we will find that our real business code is here.

From the instant-run file, we guess that BootstrapApplication replaces our application. The Instant-Run code acts as a host program and loads the app as a resource dex.

So how does InstantRun run the business code?

How to launch an app using Instant Run

According to our above conjecture about the instant-run operation mechanism, let's first look at the analysis of appliaction's attachBaseContext and onCreate methods.

attachBaseContext()

 protected void attachBaseContext(Context context) {
       if (!AppInfo.usingApkSplits) {
            String apkFile = context.getApplicationInfo().sourceDir;
            long apkModified = apkFile != null ? new File(apkFile).lastModified() : 0L;
            createResources(apkModified);
            setupClassLoaders(context, context.getCacheDir().getPath(), apkModified);
 }
       createRealApplication();
       super.attachBaseContext(context);
       if (this.realApplication != null ) {
 try {
                 Method attachBaseContext = ContextWrapper.class.getDeclaredMethod( "attachBaseContext" , new Class[] { Context.class });
                 attachBaseContext.setAccessible( true );
                 attachBaseContext.invoke(this.realApplication, new Object[] { context });
            } catch (Exception e) {
                 throw new IllegalStateException(e);
 }
 }
 }

The methods we need to focus on in turn are:

createResources → setupClassLoaders → createRealApplication → call the attachBaseContext method of realApplication

createResources()

 private void createResources(long apkModified) {
       FileManager.checkInbox();
       File file = FileManager.getExternalResourceFile();
       this.externalResourcePath = (file != null ? file.getPath() : null );
       if (Log.isLoggable( "InstantRun" , 2)) {
            Log.v( "InstantRun" , "Resource override is " + this.externalResourcePath);
 }
 if (file != null ) {
 try {
                 long resourceModified = file.lastModified();
                 if (Log.isLoggable( "InstantRun" , 2)) {
                      Log.v( "InstantRun" , "Resource patch last modified: " + resourceModified);
                      Log.v( "InstantRun" , "APK last modified: " + apkModified
                           + " "  
                           + (apkModified > resourceModified ? ">" : "<" )
                           + "resource patch" );
 }
                 if ((apkModified == 0L) || (resourceModified <= apkModified)) {
                      if (Log.isLoggable( "InstantRun" , 2)) {
                            Log.v( "InstantRun" , "Ignoring resource file, older than APK" );
 }
                      this.externalResourcePath = null ;
 }
          } catch (Throwable t) {
                 Log.e( "InstantRun" , "Failed to check patch timestamps" , t);
 }
 }
 }

Description: This method mainly determines whether the resource resource.ap_ has changed, and then saves the path of resource.ap_ to externalResourcePath.

setupClassLoaders()

 private static void setupClassLoaders(Context context, String codeCacheDir, long apkModified) {
       List dexList = FileManager.getDexList(context, apkModified);
       Class server = Server.class;
       Class patcher = MonkeyPatcher.class;
       if (!dexList.isEmpty()) {
            if (Log.isLoggable( "InstantRun" , 2)) {
                 Log.v( "InstantRun" , "Bootstrapping class loader with dex list " + join ( '\n' , dexList));
 }
            ClassLoader classLoader = BootstrapApplication.class.getClassLoader();
            String nativeLibraryPath;
 try {
                  nativeLibraryPath = (String) classLoader.getClass().getMethod( "getLdLibraryPath" , new Class[0]).invoke(classLoader, new Object[0]);
                  if (Log.isLoggable( "InstantRun" , 2)) {
                       Log.v( "InstantRun" , "Native library path: " + nativeLibraryPath);
 }
            } catch (Throwable t) {
            Log.e( "InstantRun" , "Failed to determine native library path " + t.getMessage());
            nativeLibraryPath = FileManager.getNativeLibraryFolder().getPath();
 }
      IncrementalClassLoader.inject(classLoader, nativeLibraryPath, codeCacheDir, dexList);
 }
 }

Description: This method initializes a ClassLoaders and calls IncrementalClassLoader.

The source code of IncrementalClassLoader is as follows:

 public class IncrementalClassLoader extends ClassLoader {
 public   static final boolean DEBUG_CLASS_LOADING = false ;
      private final DelegateClassLoader delegateClassLoader;
 public IncrementalClassLoader(ClassLoader original, String nativeLibraryPath, String codeCacheDir, List dexes) {
           super(original.getParent());
           this.delegateClassLoader = createDelegateClassLoader(nativeLibraryPath, codeCacheDir, dexes, original);
 } 
 
 public Class findClass(String className) throws ClassNotFoundException {
 try {
 return this.delegateClassLoader.findClass(className);
     } catch (ClassNotFoundException e) {
 throw e;
 }
 }
 private static class DelegateClassLoader extends BaseDexClassLoader {
     private DelegateClassLoader(String dexPath, File optimizedDirectory, String libraryPath, ClassLoader parent) {
          super(dexPath, optimizedDirectory, libraryPath, parent);
 } 
 
 public Class findClass(String name ) throws ClassNotFoundException {
 try {
 return super.findClass( name );
          } catch (ClassNotFoundException e) {
 throw e;
 }
 }
 } 
 
 private static DelegateClassLoader createDelegateClassLoader(String nativeLibraryPath, String codeCacheDir, List dexes,
 ClassLoader original) {
      String pathBuilder = createDexPath(dexes);
 return new DelegateClassLoader(pathBuilder, new File(codeCacheDir), nativeLibraryPath, original);
 }
 private static String createDexPath(List dexes) {
      StringBuilder pathBuilder = new StringBuilder();
 boolean first = true ;
 for (String dex : dexes) {
 if ( first ) {
 first = false ;
 } else {
                 pathBuilder.append(File.pathSeparator);
 }
           pathBuilder.append(dex);
 }
      if (Log.isLoggable( "InstantRun" , 2)) {
           Log.v( "InstantRun" , "Incremental dex path is " + BootstrapApplication. join ( '\n' , dexes));
 }
 return pathBuilder.toString();
 }
 private static void setParent(ClassLoader classLoader, ClassLoader newParent) {
 try {
          Field parent = ClassLoader.class.getDeclaredField( "parent" );
          parent.setAccessible( true );
          parent.set (classLoader, newParent);
     } catch (IllegalArgumentException e) {
          throw new RuntimeException(e);
     } catch (IllegalAccessException e) {
          throw new RuntimeException(e);
     } catch (NoSuchFieldException e) {
          throw new RuntimeException(e);
 }
 }
 public   static ClassLoader inject(ClassLoader classLoader,
     String nativeLibraryPath, String codeCacheDir, List dexes) {
     IncrementalClassLoader incrementalClassLoader = new IncrementalClassLoader(classLoader, nativeLibraryPath, codeCacheDir, dexes);
     setParent(classLoader, incrementalClassLoader);
 return incrementalClassLoader;
 }
 }

The inject method is used to set the parent-child order of classloader, and use IncrementalClassLoader to load dex. Due to the parent delegation mode of ClassLoader, that is, entrusting the parent class to load the class, if it is not found in the parent class, it will be searched in the current ClassLoader.

The effect diagram of the call is as follows:

To facilitate our understanding of the mechanism of delegated parent class loading, we can do an experiment and do some logs in our application.

 @Override
 public void onCreate() {
 super.onCreate();
 try{
           Log.d(TAG, "###onCreate in myApplication" );
           String classLoaderName = getClassLoader().getClass().getName();
           Log.d(TAG, "###onCreate in myApplication classLoaderName = " +classLoaderName);
           String parentClassLoaderName = getClassLoader().getParent().getClass().getName();
           Log.d(TAG, "###onCreate in myApplication parentClassLoaderName = " +parentClassLoaderName);
           String pParentClassLoaderName = getClassLoader().getParent().getParent().getClass().getName();
           Log.d(TAG, "###onCreate in myApplication pParentClassLoaderName = " +pParentClassLoaderName);
 }catch (Exception e){
           e.printStackTrace();
 }
 }

Output:

 03-20 10:43:42.475 27307-27307/mobctrl.net.testinstantrun D/MyApplication: ###onCreate in myApplication classLoaderName = dalvik.system.PathClassLoader
 03-20 10:43:42.475 27307-27307/mobctrl.net.testinstantrun D/MyApplication: ###onCreate in myApplication parentClassLoaderName = com.android.tools.fd.runtime.IncrementalClassLoader
 03-20 10:43:42.475 27307-27307/mobctrl.net.testinstantrun D/MyApplication: ###onCreate in myApplication pParentClassLoaderName = java.lang.BootClassLoader

From this, we know that the current PathClassLoader delegates IncrementalClassLoader to load dex.

We continue to analyze attachBaseContext():

 attachBaseContext.invoke(this.realApplication, new Object[] { context });

createRealApplication

 private void createRealApplication() {
      if (AppInfo.applicationClass != null ) {
           if (Log.isLoggable( "InstantRun" , 2)) {
                Log.v( "InstantRun" , "About to create real application of class name = " + AppInfo.applicationClass);
 }
 try {
               Class realClass = (Class) Class.forName(AppInfo.applicationClass);
               if (Log.isLoggable( "InstantRun" , 2)) {
                    Log.v( "InstantRun" , "Created delegate app class successfully : "  
                    + realClass + " with class loader "  
                    + realClass.getClassLoader());
 }
               Constructor constructor = realClass.getConstructor(new Class[0]);
               this.realApplication = ((Application) constructor.newInstance(new Object[0]));
               if (Log.isLoggable( "InstantRun" , 2)) {
                    Log.v( "InstantRun" , "Created real app instance successfully :" + this.realApplication);
 }
          } catch (Exception e) {
               throw new IllegalStateException(e);
 }
 } else {
          this.realApplication = new Application();
 }
 }

This method uses the real application of the app stored in the applicationClass constant of the AppInfo class in classes.dex. From the analysis of the example, we can know that applicationClass is com.xzh.demo.MyApplication. Through reflection, the real application is created.

After reading attachBaseContext, let's continue to look at BootstrapApplication();

BootstrapApplication()

Let's first look at the onCreate method:

onCreate()

 public void onCreate() {
      if (!AppInfo.usingApkSplits) {
           MonkeyPatcher.monkeyPatchApplication(this, this, this.realApplication, this.externalResourcePath);
           MonkeyPatcher.monkeyPatchExistingResources(this, this.externalResourcePath, null );
 } else {
           MonkeyPatcher.monkeyPatchApplication(this, this, this.realApplication, null );
 }
 super.onCreate();
      if (AppInfo.applicationId != null ) {
 try {
                boolean foundPackage = false ;
 int pid = Process.myPid();
                ActivityManager manager = (ActivityManager) getSystemService( "activity" );
                List processes = manager.getRunningAppProcesses();
                boolean startServer = false ;
                if ((processes != null ) && (processes. size () > 1)) {
 for (ActivityManager.RunningAppProcessInfo processInfo : processes) {
                           if (AppInfo.applicationId.equals(processInfo.processName)) {
                                 foundPackage = true ;
                                 if (processInfo.pid == pid) {
                                       startServer = true ;
                                       break;
                                 }
 }
 }
                      if ((!startServer) && (!foundPackage)) {
                           startServer = true ;
                           if (Log.isLoggable( "InstantRun" , 2)) {
                                 Log.v( "InstantRun" , "Multiprocess but didn't find process with package: starting server anyway" );
 }
 }
 } else {
                      startServer = true ;
 }
                if (startServer) {
                      Server.create (AppInfo.applicationId, this);
 }
           } catch (Throwable t) {
                if (Log.isLoggable( "InstantRun" , 2)) {
                      Log.v( "InstantRun" , "Failed during multi process check" , t);
 }
                Server.create (AppInfo.applicationId, this);
 }
 }
      if (this.realApplication != null ) {
            this.realApplication.onCreate();
 }
 }

In onCreate() we need to pay attention to the following methods:

monkeyPatchApplication → monkeyPatchExistingResources → Server startup → call realApplication's onCreate method

monkeyPatchApplication

 public   static void monkeyPatchApplication(Context context, Application bootstrap, Application realApplication, String externalResourceFile) {
 try {
           Class activityThread = Class.forName( "android.app.ActivityThread" );
           Object currentActivityThread = getActivityThread(context, activityThread);
           Field mInitialApplication = activityThread.getDeclaredField( "mInitialApplication" );
           mInitialApplication.setAccessible( true );
           Application initialApplication = (Application) mInitialApplication.get(currentActivityThread);
           if ((realApplication != null ) && (initialApplication == bootstrap)) {
                 mInitialApplication.set (currentActivityThread, realApplication);
 }
           if (realApplication != null ) {
                Field mAllApplications = activityThread.getDeclaredField( "mAllApplications" );
                mAllApplications.setAccessible( true );
                List allApplications = (List) mAllApplications.get(currentActivityThread);
 for ( int i = 0; i < allApplications. size (); i++) {
                     if (allApplications.get(i) == bootstrap) {
                          allApplications.set ( i, realApplication);
 }
 }
 }
            Class loadedApkClass;
 try {
                  loadedApkClass = Class.forName( "android.app.LoadedApk" );
            } catch (ClassNotFoundException e) {
                  loadedApkClass = Class.forName( "android.app.ActivityThread$PackageInfo" );
 }
            Field mApplication = loadedApkClass.getDeclaredField( "mApplication" );
            mApplication.setAccessible( true );
            Field mResDir = loadedApkClass.getDeclaredField( "mResDir" );
            mResDir.setAccessible( true );
            Field mLoadedApk = null ;
 try {
                  mLoadedApk = Application.class.getDeclaredField( "mLoadedApk" );
            } catch (NoSuchFieldException e) {
 }
 for (String fieldName : new String[] { "mPackages" , "mResourcePackages" }) {
                 Field field = activityThread.getDeclaredField(fieldName);
                 field.setAccessible( true );
                 Object value = field.get(currentActivityThread);
 for (Map.Entry> entry : ((Map>) value).entrySet()) {
                       Object loadedApk = ((WeakReference) entry.getValue()).get();
                       if (loadedApk != null ) {
                             if (mApplication.get(loadedApk) == bootstrap) {
                                   if (realApplication != null ) {
                                         mApplication.set (loadedApk, realApplication);
                                   }
                                   if (externalResourceFile != null ) {
                                         mResDir.set (loadedApk, externalResourceFile);
                                   }
                                   if ((realApplication != null ) && (mLoadedApk != null )) {
                                         mLoadedApk.set (realApplication, loadedApk);
                                   }
                             }
 }
 }
 }
        } catch (Throwable e) {
             throw new IllegalStateException(e);
 }
 }

Description: This method replaces all current app's application with realApplication.

The replacement process is as follows:

1. Replace ActivityThread's mInitialApplication with realApplication

2. Replace all Application in mAllApplications with realApplication

3. Replace the application in mLoaderApk in mPackages and mResourcePackages of ActivityThread with realApplication.

monkeyPatchExistingResources

 public   static void monkeyPatchExistingResources(Context context, String externalResourceFile, Collection activities) {
      if (externalResourceFile == null ) {
 return ;
 }
 try {
           AssetManager newAssetManager = (AssetManager) AssetManager.class.getConstructor(new Class[0]).newInstance(new Object[0]);
 Method mAddAssetPath = AssetManager.class.getDeclaredMethod(
 "addAssetPath" , new Class[] { String.class });
           mAddAssetPath.setAccessible( true );
           if ((( Integer ) mAddAssetPath.invoke(newAssetManager, new Object[] { externalResourceFile })).intValue() == 0) {
 throw new IllegalStateException(
 "Could not create new AssetManager" );
 }
           Method mEnsureStringBlocks = AssetManager.class.getDeclaredMethod( "ensureStringBlocks" , new Class[0]);
           mEnsureStringBlocks.setAccessible( true );
           mEnsureStringBlocks.invoke(newAssetManager, new Object[0]);
           if (activities != null ) {
 for (Activity activity : activities) {
                      Resources resources = activity.getResources();
 try {
                            Field mAssets = Resources.class.getDeclaredField( "mAssets" );
                            mAssets.setAccessible( true );
                            mAssets.set (resources, newAssetManager);
                      } catch (Throwable ignore ) {
                            Field mResourcesImpl = Resources.class.getDeclaredField( "mResourcesImpl" );
                            mResourcesImpl.setAccessible( true );
                            Object resourceImpl = mResourcesImpl.get(resources);
                            Field implAssets = resourceImpl.getClass().getDeclaredField( "mAssets" );
                            implAssets.setAccessible( true );
                            implAssets.set (resourceImpl, newAssetManager);
 }
                      Resources.Theme theme = activity.getTheme();
 try {
                            try {
                                 Field ma = Resources.Theme.class.getDeclaredField( "mAssets" );
                                 ma.setAccessible( true );
                                 ma.set (theme, newAssetManager);
                            } catch (NoSuchFieldException ignore ) {
                                 Field themeField = Resources.Theme.class.getDeclaredField( "mThemeImpl" );
                                 themeField.setAccessible( true );
                                 Object impl = themeField.get(theme);
                                 Field ma = impl.getClass().getDeclaredField( "mAssets" );
                                 ma.setAccessible( true );
                                 ma.set (impl, newAssetManager);
 }
                                 Field mt = ContextThemeWrapper.class.getDeclaredField( "mTheme" );
                                 mt.setAccessible( true );
                                 mt.set (activity, null );
                                 Method mtm = ContextThemeWrapper.class.getDeclaredMethod( "initializeTheme" , new Class[0]);
                                 mtm.setAccessible( true );
                                 mtm.invoke(activity, new Object[0]);
                                 Method mCreateTheme = AssetManager.class.getDeclaredMethod( "createTheme" , new Class[0]);
                                 mCreateTheme.setAccessible( true );
                                 Object internalTheme = mCreateTheme.invoke(newAssetManager, new Object[0]);
                                 Field mTheme = Resources.Theme.class.getDeclaredField( "mTheme" );
                                 mTheme.setAccessible( true );
                                 mTheme.set (theme, internalTheme);
                         } catch (Throwable e) {
                                 Log.e( "InstantRun" , "Failed to update existing theme for activity " + activity, e);
 }
                         pruneResourceCaches(resources);
 }
 }
           Collection> references ;
           if (Build.VERSION.SDK_INT >= 19) {
                 Class resourcesManagerClass = Class.forName( "android.app.ResourcesManager" );
                 Method mGetInstance = resourcesManagerClass.getDeclaredMethod( "getInstance" , new Class[0]);
                 mGetInstance.setAccessible( true );
                 Object resourcesManager = mGetInstance.invoke( null , new Object[0]);
 try {
                      Field fMActiveResources = resourcesManagerClass.getDeclaredField( "mActiveResources" );
                      fMActiveResources.setAccessible( true );
                      <ArrayMap> arrayMap = (ArrayMap) fMActiveResources.get(resourcesManager);
 references = arrayMap. values ​​();
                 } catch (NoSuchFieldException ignore ) {
                      Field mResourceReferences = resourcesManagerClass.getDeclaredField( "mResourceReferences" );
                      mResourceReferences.setAccessible( true );
 references = (Collection) mResourceReferences.get(resourcesManager);
 }
 } else {
                 Class activityThread = Class.forName( "android.app.ActivityThread" );
                 Field fMActiveResources = activityThread.getDeclaredField( "mActiveResources" );
                 fMActiveResources.setAccessible( true );
                 Object thread = getActivityThread(context, activityThread);
                 <HashMap> map = (HashMap) fMActiveResources.get(thread);
 references = map.values () ;
 }
 for (WeakReference wr : references ) {
                 Resources resources = (Resources) wr.get();
                 if (resources != null ) {
 try {
                            Field mAssets = Resources.class.getDeclaredField( "mAssets" );
                            mAssets.setAccessible( true );
                            mAssets.set (resources, newAssetManager);
                      } catch (Throwable ignore ) {
                            Field mResourcesImpl = Resources.class.getDeclaredField( "mResourcesImpl" );
                            mResourcesImpl.setAccessible( true );
                            Object resourceImpl = mResourcesImpl.get(resources);
                            Field implAssets = resourceImpl.getClass().getDeclaredField( "mAssets" );
                            implAssets.setAccessible( true );
                            implAssets.set (resourceImpl, newAssetManager);
 }
                      resources.updateConfiguration(resources.getConfiguration(), resources.getDisplayMetrics());
 }
 }
 } catch (Throwable e) {
        throw new IllegalStateException(e);
 }
 }

Description: This method replaces all mAssets of the current app with newAssetManager.

The process of monkeyPatchExistingResources is as follows:

1. If the resource.ap_ file has changed, create a new AssetManager object newAssetManager, and then replace all current mAssets member variables of Resource and Resource.Theme with the newAssetManager object.

2. If an Activity is already started, you also need to replace the mAssets member variables in all Activities

Determine whether the Server has been started. If not, start the Server. Then call the onCreate method of realApplication to delegate the life cycle of realApplication.

Next, let's analyze the issues that the Server is responsible for, such as **hot deployment**, **warm deployment**, and **cold deployment**.

Server hot deployment, warm deployment and cold deployment

First, focus on the internal class SocketServerReplyThread of Server.

SocketServerReplyThread

 private class SocketServerReplyThread extends Thread {
    private final LocalSocket mSocket; 
 
    SocketServerReplyThread(LocalSocket socket) {
        this.mSocket = socket;
 } 
 
 public void run() {
 try {
            DataInputStream input = new DataInputStream(this.mSocket.getInputStream());
            DataOutputStream output = new DataOutputStream(this.mSocket.getOutputStream());
 try {
                handle(input, output );
 finally
 try {
                    input.close ();
                } catch (IOException ignore ) {
 }
 try {
 output . close ();
                } catch (IOException ignore ) {
 }
 }
 return ;
        } catch (IOException e) {
            if (Log.isLoggable( "InstantRun" , 2)) {
                Log.v( "InstantRun" , "Fatal error receiving messages" , e);
 }
 }
 } 
 
    private void handle(DataInputStream input, DataOutputStream output ) throws IOException {
        long magic = input.readLong();
        if (magic != 890269988L) {
            Log.w( "InstantRun" , "Unrecognized header format " + Long.toHexString(magic));
 return ;
 }
 int version = input.readInt();
 output .writeInt(4);
 if (version != 4) {
            Log.w( "InstantRun" , "Mismatched protocol versions; app is using version 4 and tool is using version " + version);
 } else {
 int message;
 for (; ; ) {
                message = input.readInt();
                switch (message) {
 case 7:
                        if (Log.isLoggable( "InstantRun" , 2)) {
                            Log.v( "InstantRun" , "Received EOF from the IDE" );
 }
 return ;
 case 2:
                        boolean active = Restarter.getForegroundActivity(Server.this.mApplication) != null ;
 output .writeBoolean(active);
                        if (Log.isLoggable( "InstantRun" , 2)) {
                            Log.v( "InstantRun" , "Received Ping message from the IDE; returned active = " + active);
 }
                        break;
 case 3:
                        String path = input.readUTF();
                        long size = FileManager.getFileSize(path);
 output .writeLong( size );
                        if (Log.isLoggable( "InstantRun" , 2)) {
                            Log.v( "InstantRun" , "Received path-exists(" + path + ") from the " + "IDE; returned size=" + size );
 }
                        break;
 case 4:
                        long begin = System.currentTimeMillis();
                        path = input.readUTF();
                        byte[] checksum = FileManager.getCheckSum(path);
                        if (checksum != null ) {
 output .writeInt(checksum.length);
 output .write(checksum);
                            if (Log.isLoggable( "InstantRun" , 2)) {
                                long end = System.currentTimeMillis();
                                String hash = new BigInteger(1, checksum)
                                        .toString(16);
                                Log.v( "InstantRun" , "Received checksum(" + path
                                        + ") from the " + "IDE: took "  
                                        + ( end - begin ) + "ms to compute "  
                                        + hash);
 }
                        } else {
 output .writeInt(0);
                            if (Log.isLoggable( "InstantRun" , 2)) {
                                Log.v( "InstantRun" , "Received checksum(" + path
                                        + ") from the "  
                                        + "IDE: returning " );
 }
 }
                        break;
 case 5:
                        if (!authenticate(input)) {
 return ;
 }
                        Activity activity = Restarter
                                .getForegroundActivity(Server.this.mApplication);
                        if (activity != null ) {
                            if (Log.isLoggable( "InstantRun" , 2)) {
                                Log.v( "InstantRun" ,
 "Restarting activity per user request" );
 }
                            Restarter.restartActivityOnUiThread(activity);
 }
                        break;
 case 1:
                        if (!authenticate(input)) {
 return ;
 }
                        List changes = ApplicationPatch
                                .read (input);
                        if (changes != null ) {
                            boolean hasResources = Server.hasResources(changes);
 int updateMode = input.readInt();
                            updateMode = Server.this.handlePatches(changes,
                                    hasResources, updateMode);
                            boolean showToast = input.readBoolean();
 output .writeBoolean( true );
                            Server.this.restart(updateMode, hasResources,
                                    showToast);
 }
                        break;
 case 6:
                        String text = input.readUTF();
                        Activity foreground = Restarter
                                .getForegroundActivity(Server.this.mApplication);
                        if (foreground != null ) {
                            Restarter.showToast(foreground, text);
                        } else if (Log.isLoggable( "InstantRun" , 2)) {
                            Log.v( "InstantRun" ,
 "Couldn't show toast (no activity) : "  
                                            + text);
 }
                        break;
 }
 }
 }
 }
 }

Note: After the socket is opened, it starts reading data. When it reads 1, it obtains the ApplicationPatch list of code changes, and then calls handlePatches to handle the code changes.

handlePatches

 private int handlePatches(List changes,
                          boolean hasResources, int updateMode) {
 if (hasResources) {
        FileManager.startUpdate();
 }
 for (ApplicationPatch change : changes) {
        String path = change.getPath();
        if (path.endsWith( ".dex" )) {
            handleColdSwapPatch(change);
            boolean canHotSwap = false ;
 for (ApplicationPatch c : changes) {
                if (c.getPath().equals( "classes.dex.3" )) {
                    canHotSwap = true ;
 break;
 }
 }
            if (!canHotSwap) {
                updateMode = 3;
 }
        } else if (path.equals( "classes.dex.3" )) {
            updateMode = handleHotSwapPatch(updateMode, change);
        } else if (isResourcePath(path)) {
            updateMode = handleResourcePatch(updateMode, change, path);
 }
 }
 if (hasResources) {
        FileManager.finishUpdate( true );
 }
 return updateMode;
 }

Note: This method mainly determines the mode (hot deployment, warm deployment or cold deployment) by judging the content of Change.

• If the suffix is ​​".dex", cold deployment handles handleColdSwapPatch
• If the suffix is ​​"classes.dex.3", hot deployment handles handleHotSwapPatch
• In other cases, warm deployment, handle resource handleResourcePatch

handleColdSwapPatchCold deployment

 private static void handleColdSwapPatch(ApplicationPatch patch) {
    if (patch.path.startsWith( "slice-" )) {
        File file = FileManager.writeDexShard(patch.getBytes(), patch.path);
        if (Log.isLoggable( "InstantRun" , 2)) {
            Log.v( "InstantRun" , "Received dex shard " + file);
 }
 }
 }

Note: This method writes the dex file to a private directory and waits for the entire app to restart. After restarting, use the IncrementalClassLoader mentioned above to load dex.

handleHotSwapPatch hot deployment

 private int handleHotSwapPatch( int updateMode, ApplicationPatch patch) {
    if (Log.isLoggable( "InstantRun" , 2)) {
        Log.v( "InstantRun" , "Received incremental code patch" );
 }
 try {
        String dexFile = FileManager.writeTempDexFile(patch.getBytes());
        if (dexFile == null ) {
            Log.e( "InstantRun" , "No file to write the code to" );
 return updateMode;
 }
        if (Log.isLoggable( "InstantRun" , 2)) {
            Log.v( "InstantRun" , "Reading live code from " + dexFile);
 }
        String nativeLibraryPath = FileManager.getNativeLibraryFolder()
 .getPath();
        DexClassLoader dexClassLoader = new DexClassLoader(dexFile,
                this.mApplication.getCacheDir().getPath(),
                nativeLibraryPath, getClass().getClassLoader());
        Class aClass = Class.forName(
 "com.android.tools.fd.runtime.AppPatchesLoaderImpl" , true ,
                dexClassLoader);
 try {
            if (Log.isLoggable( "InstantRun" , 2)) {
                Log.v( "InstantRun" , "Got the patcher class " + aClass);
 }
            PatchesLoader loader = (PatchesLoader) aClass.newInstance();
            if (Log.isLoggable( "InstantRun" , 2)) {
                Log.v( "InstantRun" , "Got the patcher instance " + loader);
 }
            String[] getPatchedClasses = (String[]) aClass
                    .getDeclaredMethod( "getPatchedClasses" , new Class[0])
                    .invoke(loader, new Object[0]);
            if (Log.isLoggable( "InstantRun" , 2)) {
                Log.v( "InstantRun" , "Got the list of classes " );
 for (String getPatchedClass : getPatchedClasses) {
                    Log.v( "InstantRun" , "class " + getPatchedClass);
 }
 }
            if (!loader. load ()) {
                updateMode = 3;
 }
        } catch (Exception e) {
            Log.e( "InstantRun" , "Couldn't apply code changes" , e);
            e.printStackTrace();
 updateMode = 3;
 }
 } catch (Throwable e) {
        Log.e( "InstantRun" , "Couldn't apply code changes" , e);
 updateMode = 3;
 }
 return updateMode;
 }

Description: This method writes the patch dex file to a temporary directory, and then uses DexClassLoader to load dex. Then it reflects and calls the load method of the AppPatchesLoaderImpl class.

It should be emphasized that AppPatchesLoaderImpl inherits from the abstract class AbstractPatchesLoaderImpl and implements the abstract method: getPatchedClasses. The code of the AbstractPatchesLoaderImpl abstract class is as follows:

 public abstract class AbstractPatchesLoaderImpl implements PatchesLoader {
 public abstract String[] getPatchedClasses();
 public boolean load () {
 try {
 for (String className : getPatchedClasses()) {
                       ClassLoader cl = getClass().getClassLoader();
                       Class aClass = cl.loadClass(className + "$override" );
                       Object o = aClass.newInstance();
                       Class originalClass = cl.loadClass(className);
                       Field changeField = originalClass.getDeclaredField( "$change" );
                       changeField.setAccessible( true );
                       Object previous = changeField.get( null );
                       if (previous != null ) {
                            Field isObsolete = previous.getClass().getDeclaredField( "$obsolete" );
                            if (isObsolete != null ) {
                                 isObsolete.set ( null , Boolean.valueOf( true )) ;
 }
 }
                       changeField.set ( null , o);
                       if ((Log.logging != null ) && (Log.logging.isLoggable( Level .FINE))) {
                            Log.logging.log( Level .FINE, String.format( "patched %s" , new Object[] { className }));
 }
 }
            } catch (Exception e) {
                  if (Log.logging != null ) {
                         Log.logging.log( Level .SEVERE, String.format( "Exception while patching %s" , new Object[] { "foo.bar" }), e);
 }
 return   false ;
 }
 return   true ;
 }
 }

Instant Run Hot Deployment Principle

Based on the above code analysis, we can analyze the process of Instant Run as follows:

1. When building apk for the first time, a member variable of $change is injected into each class. It implements the IncrementalChange interface and inserts a similar piece of logic into each method.

 IncrementalChange localIncrementalChange = $change;
 if (localIncrementalChange != null ) {
     localIncrementalChange.access$dispatch( "onCreate.(Landroid/os/Bundle;)V" , new Object[] { this, ... });
 return ;
 }

When $change is not empty, execute the IncrementalChange method.

2. After we modify the implementation of the method in the code, click InstantRun, which will generate the corresponding patch file to record the content you modified. The replacement class in the patch file is to append $override to the modified class name and implement the IncrementalChange interface.

3. Generate the AppPatchesLoaderImpl class, inherit from AbstractPatchesLoaderImpl, and implement the getPatchedClasses method to record which classes have been modified.

4. After calling the load method, load the corresponding $override class according to the list of modified classes returned by getPatchedClasses, and then set the $change of the original class to the corresponding $override class that implements the IncrementalChange interface.

Summary of Instant Run Operation Mechanism

The Instant Run operation mechanism mainly involves hot deployment, warm deployment and cold deployment, mainly during the first run, during the app run, when there is code modification.

First time compilation

1. Package Instant-Run.jar and instant-Run-bootstrap.jar into the main dex

2. Replace the application configuration in AndroidManifest.xml

3. Use the asm tool, add $change to each class, and add logic before each method.

4. Compile the source code into dex and store it in the compressed package instant-run.zip

App runtime

1. Get the path to resource resource.ap_ after the change

2. Set ClassLoader. setupClassLoader:

Use IncrementalClassLoader to load the apk code, and change the original BootClassLoader → PathClassLoader to BootClassLoader → IncrementalClassLoader → PathClassLoader inheritance relationship.

3.createRealApplication:

Create apk real application

4.monkeyPatchApplication

Reflection replaces various Application member variables in ActivityThread

5.monkeyPatchExistingResource

Reflection replaces all existing AssetManager objects

6. Call the onCreate method of realApplication

7. Start Server and Socket receives patch list

When there is code modification

1. Generate the corresponding $override class

2. Generate the AppPatchesLoaderImpl class and record the modified class list

3. Package it into patch and pass it to the app through socket

4. After the app server receives the patch, it waits for the patch to be processed according to handleColdSwapPatch, handleHotSwapPatch, handleResourcePatch.

5. Restart makes patch effective

In Android plug-in, Android hot repair, and apk shelling/unshelling, we borrowed the Instant Run running mechanism, so understanding the Instant Run running mechanism is very helpful for deeper research and is also reference for our own writing framework.