在我们每次就打开一个Activity时候，Android的源码为我们做了什么，今天就来看一下。

在我们调用startActivity（）方法的时候，调用了Activity里面的staartActivity（）方法，然后它又在它的方法里面调用了startActivityForResult（）方法。

//这里是我们在MainActivity中启动另一个Activity的代码
Intent intent =new Intent(this,SendActivity.class);

    startActivity(intent);

/*
*这个是Activity中的代码
*/
  @Override
    public void startActivity(Intent intent) {
        this.startActivity(intent, null);
    }
  @Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
    }

在startActivityForResult()方法中，有一个mInstrumentation对象去执行了execStartActivity（）这个方法，中间要传入一个Thread参数。这个参数是ActivityThread.getApplication获取的ApplicationThread。ApplicationThread中有一个scheduleLaunchActivity（）在这个方法中通过Handler的sendmessage方法去发送消息。

 @Override
        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
                CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
                int procState, Bundle state, PersistableBundle persistentState,
                List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
                boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

            updateProcessState(procState, false);

            ActivityClientRecord r = new ActivityClientRecord();

            r.token = token;
            r.ident = ident;
            r.intent = intent;
            r.referrer = referrer;
            r.voiceInteractor = voiceInteractor;
            r.activityInfo = info;
            r.compatInfo = compatInfo;
            r.state = state;
            r.persistentState = persistentState;

            r.pendingResults = pendingResults;
            r.pendingIntents = pendingNewIntents;

            r.startsNotResumed = notResumed;
            r.isForward = isForward;

            r.profilerInfo = profilerInfo;

            r.overrideConfig = overrideConfig;
            updatePendingConfiguration(curConfig);

            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

在Handler的handleMessage（）方法中调用 handleLaunchActivity(r, null)方法，在这个方法中

        Activity a = performLaunchActivity(r, customIntent);

这里去拿到一个Activity对象，看到这里，就是知道是这个performLaunchActivity返回的Activity，在看这个方法

 activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);

在合理通过newActivity返回一个Activity的对象，在看newActivity这个方法

    public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        return (Activity)cl.loadClass(className).newInstance();
    }

在这里就通过反射的方式创建出一个Activity。
在这里调用了ClassLoader的loadClass方法，最终在loadClass方法中调用了findClass方法，得到一个Class。

 protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
        Class<?> clazz = findLoadedClass(className);

        if (clazz == null) {
            ClassNotFoundException suppressed = null;
            try {
                clazz = parent.loadClass(className, false);
            } catch (ClassNotFoundException e) {
                suppressed = e;
            }

            if (clazz == null) {
                try {
                    clazz = findClass(className);
                } catch (ClassNotFoundException e) {
                    e.addSuppressed(suppressed);
                    throw e;
                }
            }
        }

        return clazz;
    }

然后去找它的findClass方法，发现他的findClass是空实现。然后我们就去找他的子类，看他子类去如何实现他这个方法的，我们找到BaseDexClassLoader中，看他的findClass

  @Override
           protected Class<?> findClass(String name) throws ClassNotFoundException {
              List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
                  Class c = pathList.findClass(name, suppressedExceptions);
               if (c == null) {
                      ClassNotFoundException cnfe = new ClassNotFoundException("Didn't find class \"" + name + "\" on path: " + pathList);
                        for (Throwable t : suppressedExceptions) {
                               cnfe.addSuppressed(t);
                         }
                       throw cnfe;
                     }
                 return c;
               }

它又掉了pathList的findClassfangfa ，我们来看这个pathList是什么类型的是DexPathList的，然后我们去看他的findClass方法。

    public Class findClass(String name, List<Throwable> suppressed) {
                 for (Element element : dexElements) {
                 DexFile dex = element.dexFile;
          
                       if (dex != null) {
                                 Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
                                 if (clazz != null) {
                                       return clazz;
                                     }
                          }
                      }
                if (dexElementsSuppressedExceptions != null) {
                           suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
                    }
                 return null;
             }

看这里它那一个dexElements遍历得到dex文件，然后去通过dex文件最终找到这个类。这样Activity就加载出来了。
在这一块我们就可以联系到热更新那一块，知道它是如何启动的，我们就能去做一些事情。在这个块它是拿到所有的dexElements，返回你需要的，通过className，在这里我们可以将自己修改过的类，拿到他的dex文件，和这个dexElements合并，将我们修改的类放出现bug的类的前面，就可以实现我们热更新的效果

其实在这一块，谁去调用的scheduleLaunchActivity，我找到调用他的类ApplicationThreadNative，这一块我还是看的不太透彻，等以后看懂了，就来继续分享这一块。