Android系统分析之Activity的启动流程

1 参考链接

Android View系统分析之三Activity的启动与显示–需要进一步分析理解

Android Activity学习笔记——Activity的启动和创建

Android adb你真的会用吗?

2 概念

Activity就是被用来进行与用户交互和用来与android内部特性交互的组件，在应用程序中用到的所有activity都需要在manifest.xml文件中进行注册。那么Activity又是怎样一种组件，怎么样进行显示交互的，一个activity实例是如何被管理和运行起来的，activity生命周期又是怎么一回事？

3 Activity框架和管理结构

AcitivityManagerService是Activity系统服务核心管理类，是一个独立的进程；
ActiveThread是每一个应用程序所在进程的主线程、入口函数，处理循环的消息；
ActiveThread与AcitivityManagerService的通信是属于进程间通信，使用binder机制；

（图片来源：Android Activity学习笔记——Activity的启动和创建）

4 Activity启动过程

4.1 启动流程

以启动一个应用程序startActivity为例看一下代码执行的大概流程：

可将其分为6个过程：
（1）使用代理模式ActivityManagerNative.ActivityManagerProxy启动到ActivityManagerService中执行；
（2）ActivityStack创建ActivityRecord到历史记录中；
（3）通过Zygote创建ApplicationProcess进程，通过start()启动；
（4）通过ApplicatonThread与ActivityManagerService建立通信；
（5） ActivityManagerService通知ActiveThread启动Activity的创建；
（6）ActivityThread创建Activity加入到mActivities中并开始调度Activity执行；

4.2 详细请看下图

4.3 adnroid系统中四个重要概念：

ActivityManagerService（ActivityManagerNative）系统服务核心管理类，是一个独立的进程;

ActivityStackSupervisor 管理整个手机任务栈;

ActivityStack Activity的栈（任务栈）;

PackageManagerService(管理app的包的信息：完成组件在清单里的扫描和注册);

ActivityThread 每一个应用程序所在进程的主线程、入口函数，处理循环的消息。

5 核心源码分析（Android 7.0）

/** * Activity */public class Activity {    public void startActivity(Intent intent) {        this.startActivity(intent, null);//startActivity()    }    public void startActivity(Intent intent, @Nullable Bundle options) {        if (options != null) {            startActivityForResult(intent, -1, options);//startActivityForResult()        } else {            startActivityForResult(intent, -1);        }    }    public void startActivityForResult(Intent intent, int requestCode, Bundle options) {        if (mParent == null) {            Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), ,                    intent, requestCode, options); //Instrumentation.execStartActivity        }    }}/** * Instrumentation */public class Instrumentation {    public Instrumentation.ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, android.app.Activity target,                                                            Intent intent, int requestCode, Bundle options) {        // ActivityManagerNative.getDefault().startActivity()        int result = ActivityManagerNative.getDefault().startActivity(whoThread, who.getBasePackageName(), intent, );        return null;    }}/** * ActivityManagerNative */public abstract class ActivityManagerNative extends Binder implements IActivityManager {    static public IActivityManager getDefault() {        return gDefault.get();        //相当于        IBinder b = ServiceManager.getService("activity");//ActivityManagerNative.getDefault() == ActivityManagerService        gDefault = asInterface(b);    }    public boolean onTransact(int code, Parcel data, Parcel reply, int flags) {        switch (code) {            case START_ACTIVITY_TRANSACTION: {                int result = startActivity(app, callingPackage, intent, resolvedType,                        resultTo, resultWho, requestCode, startFlags, profilerInfo, options);                reply.writeInt(result);                return true;            }        }    }    public class ActivityManagerProxy implements IActivityManager {        public int startActivity(IApplicationThread,,,,) { //ActivityManagerService.startActivity            mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);            return result;        }    }}/** * ActivityManagerService 系统服务核心管理类 */public final class ActivityManagerService extends ActivityManagerNative implements BatteryStatsImpl.BatteryCallback {    public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent,,,,) {        return startActivityAsUser(caller, callingPackage, intent, , , , ); //startActivityAsUser()    }    public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent,,,) {        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent, , , );//ActivityStarter.startActivityMayWait()    }    //真正启动进程    final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,,,,,,,) {        return startProcessLocked(processName, info, knownToBeDead, , , , , );//startProcessLocked    }    final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,,,,,) {        startProcessLocked();    }    startProcessLocked() {        debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;//linux的Zygote进程        Process.ProcessStartResult startResult = Process.start(entryPoint, app.processName, , , , , , , );//启动进程:Process.start        //接着与底层通信    }}//Processpublic class Process {    public static final ProcessStartResult start(final String processClass, final String niceName,,,,,,) {        return startViaZygote(processClass, niceName, , , , , , , , , ); //开始一个新的进程通过Zygote机制 startViaZygote()    }}/** * ActivityStarter */class ActivityStarter {    final int startActivityMayWait(IApplicationThread caller, int callingUid, String callingPackage, Intent intent,,,,,,) {        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId); //ActivityStackSupervisor.resolveIntent()        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);//ActivityStackSupervisor.resolveActivity        int res = startActivityLocked(caller, intent, ephemeralIntent, , , , , , , ); //ActivityStarter.startActivityLocked()        return res;    }    //验证intent、Class、Permission等;保存将要启动的Activity的Record，例如：记录Activity跳转顺序.    final int startActivityLocked(IApplicationThread caller, Intent intent,,,,,,) {        ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,                intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,                requestCode, componentSpecified, voiceSession != null, mSupervisor, container,                options, sourceRecord);        err = startActivityUnchecked(r, sourceRecord, voiceSession, , startFlags, , , inTask);//startActivityUnchecked()        return err;    }    //检查将要启动的Activity的launchMode(启动模式)和启动Flag,根据launcheMode和Flag配置task.    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,, startFlags,, inTask) {        if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0 || mLaunchSingleInstance || mLaunchSingleTask) {            final ActivityRecord top = mReusedActivity.task.performClearTaskForReuseLocked(mStartActivity, mLaunchFlags);            if (top != null) {                if (top.frontOfTask) {                    top.task.setIntent(mStartActivity);                }                ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.task);                top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);            }        }        //任务栈历史栈配置        mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);//ActivityStack.startActivityLocked    }}/** * ActivityStackSupervisor 管理整个手机任务栈(ActivityStack) */public final class ActivityStackSupervisor {    //构造函数    public ActivityStackSupervisor(ActivityManagerService service) {        mHandler = new ActivityStackSupervisorHandler(mService.mHandler.getLooper());//ActivityStackSupervisorHandler()    }    private final class ActivityStackSupervisorHandler extends Handler {        void activityIdleInternal(ActivityRecord r) {            activityIdleInternalLocked(r != null ? r.appToken : null, true, null);//activityIdleInternalLocked()        }    }    final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,) {        if (activityRemoved) {            resumeFocusedStackTopActivityLocked();//esumeFocusedStackTopActivityLocked()        }    }    boolean resumeFocusedStackTopActivityLocked() {        return resumeFocusedStackTopActivityLocked(null, null, null);//resumeFocusedStackTopActivityLocked(,,)    }    boolean resumeFocusedStackTopActivityLocked(,,) {        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//ActivityStack.resumeTopActivityUncheckedLocked()        return false;    }    ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, ProfilerInfo profilerInfo, int userId) {        final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId);        return resolveActivity(intent, rInfo, startFlags, profilerInfo);    }    ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags) {        try {            //AppGlobals            return AppGlobals.getPackageManager().resolveIntent(intent, , , userId);//PackageManagerService.resolveIntent()        } catch (RemoteException e) {        }        return null;    }    //启动进程    void startSpecificActivityLocked(ActivityRecord r,                                     boolean andResume, boolean checkConfig) {        // Is this activity's application already running?        ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.info.applicationInfo.uid, true);        //真正启动进程 (AMS)ActivityManagerService.startProcessLocked()        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);    }    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {        ActivityRecord hr = stack.topRunningActivityLocked();        if (hr.app == null && app.uid == hr.info.applicationInfo.uid && processName.equals(hr.processName)) {            if (realStartActivityLocked(hr, app, true, true)) {//realStartActivityLocked()                didSomething = true;            }        }    }    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) {        app.thread.scheduleLaunchActivity(new Intent(r.intent), , , , , , );//启动activity:ActivityThread.scheduleLaunchActivity()    }}public class AppGlobals {    public static IPackageManager getPackageManager() { //IPackageManager 实现类似：PackageManagerService        return ActivityThread.getPackageManager(); //ActivityThread.getPackageManager()    }}/** * PackageManagerService 管理app的包的信息：完成组件在清单里的扫描和注册 */public class PackageManagerService extends IPackageManager.Stub {    //初始化时执行    public static PackageManagerService main(Context context, Installer installer, boolean factoryTest, boolean onlyCore) {        PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);        ServiceManager.addService("package", m); //ServiceManager添加服务        return m;    }    public ResolveInfo resolveIntent(Intent intent, String resolvedType, int flags, int userId) {        final ResolveInfo bestChoice = chooseBestActivity(intent, resolvedType, flags, query, userId); //chooseBestActivity()        return bestChoice;    }    private ResolveInfo chooseBestActivity(Intent intent, String resolvedType, int flags, List query, int userId) {        if (query != null) {            final String intentPackage = intent.getPackage(); //包名            if (!TextUtils.isEmpty(intentPackage) && allHavePackage(query, intentPackage)) {                ri.resolvePackageName = intentPackage;                // .....            }            return ri;        }    }    public final void attachApplication(IApplicationThread thread) {        attachApplicationLocked(thread, callingPid);//attachApplicationLocked()    }    //附加到Application中    private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {        // See if the top visible activity is waiting to run in this process...        if (normalMode) {            if (mStackSupervisor.attachApplicationLocked(app)) {//ActivityStackSupervisor.attachApplicationLocked()                didSomething = true;            }        }        // Find any services that should be running in this process...        if (!badApp) {            didSomething |= mServices.attachApplicationLocked(app, processName);        }    }}/** * ActivityThread 安卓java应用层的入口函数类 */public final class ActivityThread {    public static IPackageManager getPackageManager() {        IBinder b = ServiceManager.getService("package"); //ServiceManager获取服务        sPackageManager = IPackageManager.Stub.asInterface(b);        return sPackageManager;    }    public static void main(String[] args) {        Process.setArgV0("");        Looper.prepareMainLooper();        ActivityThread thread = new ActivityThread();        thread.attach(false); //attach()        if (sMainThreadHandler == null) {            sMainThreadHandler = thread.getHandler();        }        if (false) {            Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));        }        Looper.loop();    }    private void attach(boolean system) {        final IActivityManager mgr = ActivityManagerNative.getDefault();        mgr.attachApplication(mAppThread); //ActivityManagerService.attachApplication()    }    //启动Activity    public final void scheduleLaunchActivity(Intent intent,,,,) {        sendMessage(ActivityThread.H.LAUNCH_ACTIVITY, r);//LAUNCH_ACTIVITY    }    public void handleMessage(Message msg) {        case LAUNCH_ACTIVITY: {            final ActivityThread.ActivityClientRecord r = (ActivityClientRecord) msg.obj;            r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);            handleLaunchActivity(r, null, "LAUNCH_ACTIVITY"); //handleLaunchActivity()        }    }    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {        Activity a = performLaunchActivity(r, customIntent);//performLaunchActivity()        if (a != null) {            handleResumeActivity(r.token, , , , , , );            if (!r.activity.mFinished && r.startsNotResumed) {                performPauseActivityIfNeeded(r, reason);            }        } else {            ActivityManagerNative.getDefault().finishActivity(r.token, RESULT_CANCELED, null, , , );        }    }    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);    }    //Activity启动完成}/** * ActivityStack Activity的栈（任务栈） */final class ActivityStack {    //任务栈历史栈配置    final void startActivityLocked(ActivityRecord r, boolean newTask, boolean keepCurTransition, ActivityOptions options) {        if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {            insertTaskAtTop(rTask, r);            mWindowManager.moveTaskToTop(taskId);        }        ActivityRecord prev = r.task.topRunningActivityWithStartingWindowLocked();    }    //Pause过程暂时不分析    //确保活动堆栈顶部已恢复, 在ActivityStackSupervisor中调用    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {        result = resumeTopActivityInnerLocked(prev, options);//resumeTopActivityInnerLocked（）        return result;    }    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {        if (mResumedActivity != null) {            pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);//查找要进入暂停的Activity        }        if (pausing) {        }        ActivityStack lastStack = mStackSupervisor.getLastStack();        //验证该启动的Activity所在进程和app是否存在，若存在，直接启动        if (next.app != null && next.app.thread != null) {            mStackSupervisor.startSpecificActivityLocked(next, true, false);//ActivityStackSupervisor.startSpecificActivityLocked()        } else {//否则，准备创建该进程            mStackSupervisor.startSpecificActivityLocked(next, true, true);        }    }}