前言

从第一天接触Android开发开始，大家都知道Activity是Android中最最最重要的一个组件。既然很重要，很多在Android开发岗位工作几年了，都对Activity讲不出个所以然出来。比如：
1.Activity的创建
2.Activity生命周期函数的调用
既然这么重要，这么多问题困扰小伙伴们，希望通过本章的学习，帮助小伙伴们对Activity有个全新的认识。

众所周知，java程序想要开启需要依赖于main方法，也就是程序入口（主线程）进入。熟悉的小伙伴可能都知道在Android当中存在一个叫做ActivityThread的类，这个类代表的是Android当中的主线程，而在这个类当中会有一个比较熟悉的main方法，Android在打开app时首先调用的是ActivityThread的main方法，这也就是一个app进程的启动点。

##ActivityThread
public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
        long startSeq = 0;
        if (args != null) {
            for (int i = args.length - 1; i >= 0; --i) {
                if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                    startSeq = Long.parseLong(
                            args[i].substring(PROC_START_SEQ_IDENT.length()));
                }
            }
        }
        ActivityThread thread = new ActivityThread();  //1
        thread.attach(false, startSeq); //2
        ...
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
}

在main方法的注释1处，创建了ActivityThread，接着在注释2处，调用了attach方法，意为连接，具体连接什么，我们接着往下分析。

##ActivityThread
private void attach(boolean system, long startSeq) {
        ...
        if (!system) {
            ...
            final IActivityManager mgr = ActivityManager.getService();  //1
            try {
                mgr.attachApplication(mAppThread, startSeq);  //2
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
            ...
        } else {
            ...
        }
        ...
}

attach方法，在注释1处，通过AIDL,得到AMS的本地代理对象IActivityManager ，作用应用进程请求系统进程的接口，实现跟AMS服务跨进程间通信。这里设计到AIDL的用法，和AMS相关的基础知识，这部分内容不在本章节探讨。接着看注释2，使用IActivityManager 对象调用了attachApplication方法，主要是为了连接Application。Application这个类小伙伴们肯定是不陌生的，一般会在这个类中去初始化一些需要在Activity启动之前初始化的资源，或是配置一些整个应用需要用到的东西，让真个App（任何类中）都能访问到。那么这里跟AMS进行连接，主要让当前App跟Android系统绑定起来，方便系统管理当前App。

##ActivityManagerService
public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            //获取pid
            int callingPid = Binder.getCallingPid();  //1
            //获取uid
            final int callingUid = Binder.getCallingUid();  //2
            final long origId = Binder.clearCallingIdentity();
            //连接Application
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);  //3
            Binder.restoreCallingIdentity(origId);
        }
}

attachApplication是AMS中的一个方法，注释1和2分别获取到pid和uid(由系统创建，并分配，并且是处以没有进程使用)。这里小伙伴们可以猜想一下，获取到pid和uid肯定是把它分配到当前进程。在注释3，可以看到pid和uid传入到了attachApplicationLocked这个方法中。

##ActivityManagerService
private final boolean attachApplicationLocked(IApplicationThread thread,
                                                  int pid, int callingUid, long startSeq) {
        ProcessRecord app;  //1
        long startTime = SystemClock.uptimeMillis();
        if (pid != MY_PID && pid >= 0) {
            synchronized (mPidsSelfLocked) {
                app = mPidsSelfLocked.get(pid);  //2
            }
        } 
        ...
        if (app.instr != null) {  //当前进程是否正在活动
           thread.bindApplication(processName, appInfo, providers, app.instr.mClass,
                    profilerInfo, app.instr.mArguments, app.instr.mWatcher, app.instr.mUiAutomationConnection,
                    testMode, mBinderTransactionTrackingEnabled, enableTrackAllocation,
                    isRestrictedBackupMode || !normalMode, app.persistent, new Configuration(getGlobalConfiguration()),
                    app.compat, getCommonServicesLocked(app.isolated), mCoreSettingsObserver.getCoreSettingsLocked(),
                    buildSerial, isAutofillCompatEnabled);   //3
        } else {
            //Application 绑定到当前线程
            thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
                    null, null, null, testMode, mBinderTransactionTrackingEnabled,
                    enableTrackAllocation, isRestrictedBackupMode || !normalMode, app.persistent,
                    new Configuration(getGlobalConfiguration()), app.compat, getCommonServicesLocked(app.isolated),
                    mCoreSettingsObserver.getCoreSettingsLocked(), buildSerial, isAutofillCompatEnabled);  //4
        }
        ...
        //检测最可见的Activity是否在运行进程中等待，如果再则创建Activity
        if (mStackSupervisor.attachApplicationLocked(app)) {  //5
            didSomething = true;
        }
        ...
}

attachApplicationLocked方法中，注释1处的ProcessRecord是个进程记录类，小伙伴们可以把这个类理解成为一个javabean，用来保存当前进程先关的一些信息（如pid、uip、ApplicationInfo等），在注释2中，根据pid获取到了这个类。注释3和注释4都是为了绑定Application，调用的是IApplicationThread 中的bindApplication方法，而IApplicationThread 它是一个AIDL接口，作用是系统进程请求应用进程的接口。而它的实现类是在ActivityThread中的一个内部类ApplicationTread继承了IApplicationThread.Stub。注释5是开始创建Activity。这里我们分开来探讨绑定Application和创建Activity。

绑定Application

##ActivityThread.ApplicationThread
public final void bindApplication(String processName...boolean autofillCompatibilityEnabled) {
        ...
        setCoreSettings(coreSettings);
        AppBindData data = new AppBindData();
        data.processName = processName;  //当前进程名字
        data.appInfo = appInfo;     //app信息
        data.providers = providers; //providers
        ...
        //最后使用Handler发送消息，并携带AppBindData数据
        sendMessage(H.BIND_APPLICATION, data);
}

在ActivityThread.ApplicationTread类中，bindApplication方法携带了一系列参数，把这些数据封装成了一个AppBindData 对象，最后使用Handler发送消息，并携带AppBindData数据。H是ActivityThread中的内部类，是Handler的子类。

##ActivityThread.H
public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
            case BIND_APPLICATION:
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
                AppBindData data = (AppBindData) msg.obj;
                handleBindApplication(data);  
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                break;
            ...
        }
        ...
}

handleMessage方法是H中的方法，主要是用来处理消息。

##ActivityThread 
private void handleBindApplication(AppBindData data) {
        ...
        final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);  //1
        ...
        Application app;
        ...
        //创建Application
        app = data.info.makeApplication(data.restrictedBackupMode, null);  //2
        ...
        //调用Application中的onCreate方法
        mInstrumentation.callApplicationOnCreate(app);  //3
        ...
}

##Instrumentation
public void callApplicationOnCreate(Application app) {
        app.onCreate();
}

handleBindApplication方法中，注释1，获取Application的上下文，也就是getApplicationContext()获取到的ContextImpl ，ContextImpl 是Context的子类。注释2,通过类加载器，和反射创建出Application。注释3，接着可以看到Application的onCreate方法的调用。

小结，链接Application，可以理解为三个步骤，第一个步骤获取pid和uid，第二步通过IApplicationThread请求当前应用进程，第三步创建Application。

创建Activity

##ActivityStackSupervisor
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
        ...
        if (realStartActivityLocked(activity, app,
                top == activity /* andResume */, true /* checkConfig */)) {
            didSomething = true;
        }
        ...
}

经过一系列的检测或判断后，会realStartActivityLocked方法，真正的开始Activity的解锁（创建）。

##ActivityStackSupervisor
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                                          boolean andResume, boolean checkConfig) throws RemoteException {
        ...
        // 创建启动Activity
        final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                r.appToken);
        clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                System.identityHashCode(r), r.info,
                mergedConfiguration.getGlobalConfiguration(),
                mergedConfiguration.getOverrideConfiguration(), r.compat,
                r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                profilerInfo));  //添加LaunchActivityItem的回调
        // Set desired final state.
        final ActivityLifecycleItem lifecycleItem;
        if (andResume) {
            lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
        } else {
            lifecycleItem = PauseActivityItem.obtain();
        }
        clientTransaction.setLifecycleStateRequest(lifecycleItem);
        // 通过生命周期管理对象ClientLifecycleManager，来管理Activity的生命周期状态
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);
        ...
        return true;
}

此处，添加LaunchActivityItem。再后续的真正开始创建Activity时会用到。

##ClientLifecycleManager
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        //ClientTransaction是个javabean 实现了Parcelable 序列化。
        //schedule()方法内部，会回调到ActivityThread.ApplicationThread的scheduleTransaction（）方法
        transaction.schedule();
        if (!(client instanceof Binder)) {
            // If client is not an instance of Binder - it's a remote call and at this point it is
            // safe to recycle the object. All objects used for local calls will be recycled after
            // the transaction is executed on client in ActivityThread.
            transaction.recycle();
        }
}

接着会走到

##ActivityThread.ApplicationTread
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        //ActivityThread.this 指的是父类ClientTransactionHandler
        ActivityThread.this.scheduleTransaction(transaction);
}

##ClientTransactionHandler
void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        //发送Handler消息
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

在handleMessage方法中处理的EXECUTE_TRANSACTION这条消息。

##ActivityThread.H
public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
            ...
            case EXECUTE_TRANSACTION:
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                //开始执行
                mTransactionExecutor.execute(transaction);
                if (isSystem()) {
                    // Client transactions inside system process are recycled on the client side
                    // instead of ClientLifecycleManager to avoid being cleared before this
                    // message is handled.
                    transaction.recycle();
                }
                // TODO(lifecycler): Recycle locally scheduled transactions.
                break;
                ...
        }
        ...
}

接着看execute方法。

##TransactionExecutor
public void execute(ClientTransaction transaction) {
        final IBinder token = transaction.getActivityToken();
        log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
        executeCallbacks(transaction);  //1
        executeLifecycleState(transaction);  //5
        mPendingActions.clear();
        log("End resolving transaction");
}

##TransactionExecutor
public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();  //2
        ...
        for (int i = 0; i < size; ++i) {
            final ClientTransactionItem item = callbacks.get(i);  //3
            ...
            item.execute(mTransactionHandler, token, mPendingActions);  //4
            ...
        }
}

executeCallbacks方法，注释1执行回调。注释2获取到ClientTransaction中的ClientTransactionItem集合。注释3处理回调,这里获取到的ClientTransactionItem是LaunchActivityItem。注释4调用LaunchActivityItem中的execute方法。注释5是执行生命周期状态的改变，这里没有给小伙伴们贴出代码，感兴趣的小伙伴去看看。举个例子，比如Activity首次创建，默认的生命周期状态是ON_CREATE，再进行完onCreate方法调用结束后，生命周期状态值会往后移，也就是状态改变成ON_START，onStart方法调用结束，状态改变成ON_RESUME。

##LaunchActivityItem
public void execute(ClientTransactionHandler client, IBinder token,
                        PendingTransactionActions pendingActions) {
        ...
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);  //1
        ...
}

execute方法中，ClientTransactionHandler是个抽象类，他的子类是ActivityThread。接着调用到的是
ActivityThread中的handleLaunchActivity方法。

##ActivityThread
public Activity handleLaunchActivity(ActivityClientRecord r,
                                         PendingTransactionActions pendingActions, Intent customIntent) {
        ...
        //开始执行
        final Activity a = performLaunchActivity(r, customIntent);   //1
        ...
        return a;
}

注释1，开始执行启动Activity的创建。

##ActivityThread
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ActivityInfo aInfo = r.activityInfo;   //1
        ...
        ContextImpl appContext = createBaseContextForActivity(r);   //2
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();   //3
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);  //4
           ...
        } catch (Exception e) {
           ...
        }
        ...
        //调用Activity的OnCreate()方法
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);   //5
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);   
        }
        ...
        return activity;
}

performLaunchActivity方法中，注释1获取Activity信息。 注释2获取Activity 上下文。注释3获取到ClassLoader 类加载器对象。注释4使用ClassLoader（类加载器）加载出Activity，再使用反射new出Activity。注释5调用Activity的onCreate方法。

##Instrumentation
public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
       
        activity.performCreate(icicle);  //1
        postPerformCreate(activity);
}

注释1处，调用Activity中performCreate方法

##Activity
final void performCreate(Bundle icicle) {
        performCreate(icicle, null);
}

##Activity
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        mCanEnterPictureInPicture = true;
        restoreHasCurrentPermissionRequest(icicle);
        //onCreate 生命周期方法被调用
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
        ...
}

performCreate方法中会调用onCreate方法。到这里Activity的创建已经结束啦。

备注：文中Android源码版本9.0

作者:Alan
原创博客，请注明转载处....