1 參考連結

2 概念

Activity就是被用來進行與使用者互動和用來與android內部特性互動的元件，在應用程式中用到的所有activity都需要在manifest.xml檔案中進行註冊。那麼Activity又是怎樣一種元件，怎麼樣進行顯示互動的，一個activity例項是如何被管理和執行起來的，activity生命週期又是怎麼一回事？

3 Activity框架和管理結構

AcitivityManagerService是Activity系統服務核心管理類，是一個獨立的程序；
ActiveThread是每一個應用程式所在程序的主執行緒、入口函式，處理迴圈的訊息；
ActiveThread與AcitivityManagerService的通訊是屬於程序間通訊，使用binder機制；

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);
        }
    }
}