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

        //接着与底层通信
    }
}

//Process
public 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<ResolveInfo> 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("<pre-initialized>");
        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);
        }
    }
}