Activityは具体的にどのように作成されますか?どうやって表示されたの?

転載は出典を明記してください.http://blog.csdn.net/crazy1235/article/details/72236314

startActivity()いったい何が起こったの?

onCreate()はいつコールバックされましたか?

onResume()はいつコールバックされましたか?

なぜOnResume()をコールバックした後にインタフェースが表示されるのですか?

PhoneWindowはいつ作成されましたか?

Activity ThreadとApplicationThreadの関係は?

これらの問題を持って下を見下ろす!!!
まず大体のプログラム呼び出しフローチャートを1枚ください.

startActivity
通常、activityを起動するには、次のようにします.

startActivity(new Intent(this, MainActivity.class));

ソースを追跡します.app.Activity.java

@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 {
            startActivityForResult(intent, -1);
        }
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
    }

startActivity()を呼び出してもstartActivity ForResult()を呼び出しても、最終的には次の関数が呼び出されます!
Activity#startActivityForResult

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

このメソッド内で、InstrumentationのexecStartActivity()関数が呼び出されます!戻ってきたInstrumentationを受信します.Activity Resultオブジェクト!
返されるオブジェクトが空でない場合、Activity ThreadのsendActivity Result()を呼び出して結果を返します.
Instrumentation#execStartActivity

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        // ...
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

キーコードだけを見ます.ここにまたクラスActivityManagerNativeが現れます.
ActivityManagerNative#getDefault().startActivity

static public IActivityManager getDefault() {
        return gDefault.get();
    }

private static final Singleton gDefault = new Singleton() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            IActivityManager am = asInterface(b);
            if (false) {
                Log.v("ActivityManager", "default service = " + am);
            }
            return am;
        }
    };

Singletionはシステム内部で提供される単例のパッケージクラスです!
get()メソッドを最初に呼び出すとcreate()にコールバックしてオブジェクトが作成され、シーケンス呼び出しは最初に作成したオブジェクトに直接戻ります.
この方法体から明らかな観察が可能で,これはAIDL操作である!
まずはServiceManagerからBinderオブジェクトをゲット!
その後asInterface()で判断し、呼び出し元とサービス側が同じプロセスでない場合はエージェントオブジェクトに戻ります.

static public IActivityManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }

        return new ActivityManagerProxy(obj);
    }

asInterface()は、サービス側のBinderオブジェクトをクライアントに変換するために必要なAIDLインタフェースタイプのオブジェクトです.クライアントとサービス側が同じプロセスにある場合は、サービス側のIActivityManagerオブジェクトを返します.そうでない場合は、プロキシオブジェクトを返します.
エージェントオブジェクトはActivityManagerProxyです.
ここを見ると、典型的なAIDLモードであることがわかります!
ただここにはxxxはありません.aidlファイル!

IActivityManager.JAvaはaidlをコンパイル後に生成するクラスファイルに相当し、Iinterfaceを継承する.JAvaというインタフェース!

通常aidlファイルコンパイル生成のIxxx.JAvaファイルには、2つの内部クラスが含まれています.1つはStubで、1つはProxyです.でもここでは2つのファイルに分かれています!

ActivityManagerNative.JAvaはStubに相当し,同様にBinderクラスを継承し,IActivityManagerを実現している.通Stubクラス同様、中にはasInterface()、asBinder()、onTransact()などの関数が含まれています!

ActivityManagerProxy.JAvaはProxyに相当します(名前から明らかです).ActivityManagerNativeの内部クラスです!

ActivityManagerService.JAvaはActivityManagerNativeです.JAvaの具体的な実装.つまりAMSこそサービス側の具体的な実現です!

ActivityManagerProxy#startActivity

public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        // ...     
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0); //     ！
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

ActivityMangerService#startActivity

@Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

ActivityMangerService # startActivityAsUser()

@Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
        enforceNotIsolatedCaller("startActivity");
        userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
                userId, false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null);
    }

ActivityStarterはactivityを起動するために使用されます!
ActivirtyStarter # startActivityMayWait

final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, IActivityManager.WaitResult outResult, Configuration config,
            Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask) {

           // ... 

            final ActivityRecord[] outRecord = new ActivityRecord[1];
            int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                    inTask);

            // ... 

            final ActivityRecord launchedActivity = mReusedActivity != null
                    ? mReusedActivity : outRecord[0];
            mSupervisor.mActivityMetricsLogger.notifyActivityLaunched(res, launchedActivity);
            return res;
        }
    }

ActivirtyStarter # startActivityLocked

final int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask) {

        int err = ActivityManager.START_SUCCESS;

        // ...

        ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
                intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
                requestCode, componentSpecified, voiceSession != null, mSupervisor, container,
                options, sourceRecord);

        // ...

        doPendingActivityLaunchesLocked(false);

        try {
            mService.mWindowManager.deferSurfaceLayout();
            // !!!

            err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                    true, options, inTask);
        } finally {
            mService.mWindowManager.continueSurfaceLayout();
        }
        postStartActivityUncheckedProcessing(r, err, stack.mStackId, mSourceRecord, mTargetStack);
        return err;
    }

この関数の内部でstartActivity Unchecked()が呼び出されました.
ActivirtyStarter # startActivityUnchecked

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {

        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                voiceInteractor);

        mIntent.setFlags(mLaunchFlags);


            mReusedActivity = setTargetStackAndMoveToFrontIfNeeded(mReusedActivity);

            if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {

                resumeTargetStackIfNeeded(); // ... 
                return START_RETURN_INTENT_TO_CALLER;
            }
            setTaskFromIntentActivity(mReusedActivity);

            if (!mAddingToTask && mReuseTask == null) {

                resumeTargetStackIfNeeded();
                return START_TASK_TO_FRONT;
            }

        //        ActivityTask
        boolean newTask = false;
        // ... 

        if (newTask) {
            EventLog.writeEvent(
                    EventLogTags.AM_CREATE_TASK, mStartActivity.userId, mStartActivity.task.taskId);
        }
        ActivityStack.logStartActivity(
                EventLogTags.AM_CREATE_ACTIVITY, mStartActivity, mStartActivity.task);
        mTargetStack.mLastPausedActivity = null;

        sendPowerHintForLaunchStartIfNeeded(false /* forceSend */);

        mTarg`private void resumeTargetStackIfNeeded() {
        if (mDoResume) {
            mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, null, mOptions);
            if (!mMovedToFront) {
                // Make sure to notify Keyguard as well if we are not running an app transition
                // later.
                mSupervisor.notifyActivityDrawnForKeyguard();
            }
        } else {
            ActivityOptions.abort(mOptions);
        }
        mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
    }`etStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);

        // ...

        mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);

        mSupervisor.handleNonResizableTaskIfNeeded(
                mStartActivity.task, preferredLaunchStackId, mTargetStack.mStackId);

        return START_SUCCESS;
    }

ActivityStackSupervisor # resumeTargetStackIfNeeded

private void resumeTargetStackIfNeeded() {
        if (mDoResume) {
            mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, null, mOptions);
            if (!mMovedToFront) {
                // Make sure to notify Keyguard as well if we are not running an app transition
                // later.
                mSupervisor.notifyActivityDrawnForKeyguard();
            }
        } else {
            ActivityOptions.abort(mOptions);
        }
        mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
    }

ActivityStackSupervisor # resumeFocusedStackTopActivityLocked

boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        }
        return false;
    }

ActivityStack # resumeTopActivityUncheckedLocked

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        // ...
        boolean result = false;
        try {
            // ...
            result = resumeTopActivityInnerLocked(prev, options); // !!!
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

ActivityStack # resumeTopActivityInnerLocked
この関数の内部でActivity StackSupervisorが呼び出されます.startSpecificActivityLocked()
ActivityStackSupervisor # startSpecificActivityLocked()

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

        r.task.stack.setLaunchTime(r);

        if (app != null && app.thread != null) {
            try {
                if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                        || !"android".equals(r.info.packageName)) {
                    //   package  
                    app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
                            mService.mProcessStats);
                }
                //     activity
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }
        }

        // ...  
    }

ActivityStackSupervisor # realStartActivityLocked()

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {

        final ActivityStack stack = task.stack;
        try {
            if (app.thread == null) {
                throw new RemoteException();
            }
            // ...

            app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

        } catch (RemoteException e) {

        }
        return true;
    }

app.threadはIApplicationThreadタイプ!

public interface IApplicationThread extends IInterface

IApplicationThreadはIinterfaceを継承!!
内部にはactivityの起動、一時停止、停止に関する多くの定義があります.サービス起動、停止の方法も!
Iinterfaceを継承している以上、AIDLタイプに違いないと思います~上のIActivityManagerのようです!
IApplicationThreadというIPCに関連するクラスは以下のいくつかあります.

IApplicationThread

ApplicationThreadProxy

ApplicationThreadNative

ApplicationThread

ApplicationThreadNativeはIApplicationThreadの実装者ですが、抽象クラスなので、そのサブクラスApplicationThreadは本当の実装者です!
ApplicationThread # scheduleLaunchActivity
ApplicationThreadはActivity Threadの内部クラスです!

@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 pendingResults, List 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処理にメッセージを送信します!
Activity Threadの内部にはandroidを継承する内部クラスHがある.os.Handler .
だからsendMessage(H.LAUNCH_ACTIVITY,r);最終的にHクラスのhandlerMessage()関数で処理します!

case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

ここでまたActivity ThreadクラスのhandleLaunchActivity()関数を呼び出します!
ActivityThread # handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {

        // 1.    WindowManagerGlobal
        WindowManagerGlobal.initialize();
        // 2.   activity
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            // 3. resume activity
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);

           // ...
    }

ActivityThread # performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

        // 1.  ActivityClientRecord      activity   
        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }

        // 2.         activity  
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader(); //       
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent); //   Activity  
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }

        try {
            // 3.   Application  
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            // ...

            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (r.overrideConfig != null) {
                    config.updateFrom(r.overrideConfig);
                }

                Window window = null;
                if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                    window = r.mPendingRemoveWindow;
                    r.mPendingRemoveWindow = null;
                    r.mPendingRemoveWindowManager = null;
                }
                // 4. Activity      
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                //  activity    
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                // 5.   activity onCreate()  ！
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;

                // 6.   Activity onStart()  
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                // 7.   Activity onRestoreInstanceState()  
                if (!r.activity.mFinished) {
                    if (r.isPersistable()) {
                        if (r.state != null || r.persistentState != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                    r.persistentState);
                        }
                    } else if (r.state != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                    }
                }
                // 8.   Activity onPostCreate()  
                if (!r.activity.mFinished) {
                    activity.mCalled = false;
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    if (!activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                    }
                }
            }
            r.paused = true;

            // 9.      ！
            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to start activity " + component
                    + ": " + e.toString(), e);
            }
        }

        return activity;
    }

Activityオブジェクトを作成するのは簡単で、システム内部はnewオブジェクトではなくクラスローダで構築されています!

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

次にmakeApplication()を見てみましょう
LoadedAPK.java

public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        //  mApplication    ，    ！
        if (mApplication != null) {
            return mApplication;
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");

        Application app = null;

        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }

        try {
            java.lang.ClassLoader cl = getClassLoader();
            if (!mPackageName.equals("android")) {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                        "initializeJavaContextClassLoader");
                initializeJavaContextClassLoader();
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            }
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            //   Application
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } catch (Exception e) {
            if (!mActivityThread.mInstrumentation.onException(app, e)) {
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                throw new RuntimeException(
                    "Unable to instantiate application " + appClass
                    + ": " + e.toString(), e);
            }
        }
        mActivityThread.mAllApplications.add(app);
        mApplication = app; //   

        if (instrumentation != null) {
            try {
                //   Application   onCreate()   
                instrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!instrumentation.onException(app, e)) {
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        }

        //...

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

        return app;
    }

上記の手順から分かるように、Applicationが作成されたら、直接戻って、新しいApplicationを作成していません!
mApplicationが空の場合はInstrumentationで作成!

public Application newApplication(ClassLoader cl, String className, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        return newApplication(cl.loadClass(className), context);
    }
static public Application newApplication(Class> clazz, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        app.attach(context);
        return app;
    }

Activityオブジェクトの作成と同様に、クラスローダによって実現されます!
アプリケーションを作成したら、callApplicationOnCreate()を呼び出します.

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

これによりアプリケーションがコールバックする.onCreate()関数!
performLaunchActivity()メソッドボディに戻ります!
ActivityとApplicationが存在し、activityが呼び出されます.attach()関数!
Activity.attach()

final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window) {
        attachBaseContext(context);

        mFragments.attachHost(null /*parent*/);

        //   PhoneWindow  
        mWindow = new PhoneWindow(this, window);
        mWindow.setWindowControllerCallback(this);
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
            mWindow.setSoftInputMode(info.softInputMode);
        }
        if (info.uiOptions != 0) {
            mWindow.setUiOptions(info.uiOptions);
        }
        mUiThread = Thread.currentThread();

        // ... 
    }

ここから、PhoneWindowはattach()関数で作成されていることがわかります!ブログ冒頭の5番目の質問に戻りました!
performLaunchActivity()関数に戻る

if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }

Instrumentationクラスに対応:

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

public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

次にActivityのメソッドを呼び出します.

final void performCreate(Bundle icicle) {
        restoreHasCurrentPermissionRequest(icicle);
        onCreate(icicle); // onCreate
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        restoreHasCurrentPermissionRequest(icicle);
        onCreate(icicle, persistentState); // onCreate
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

OK、ここまで来るとActivityのライフサイクル関数onCreate()がコールバックされていることがわかります!
onCreate()というライフサイクル関数はperformLaunchActivity()の内部でmInstrumentationを呼び出します.callActivity OnCreate()関数、さらにコールバックを行います!

 if (r.isPersistable()) {
         mInstrumentation.callActivityOnPostCreate(activity, r.state,
          r.persistentState);
 } else {
         mInstrumentation.callActivityOnPostCreate(activity, r.state)
 }

続いてcallActivity OnPostCreate()が呼び出されました

public void callActivityOnPostCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        activity.onPostCreate(icicle, persistentState);
    }

ここでちょうどライフサイクル関数onPostCreate()をコールバックしました.
OK、これでstartActivity()を呼び出してactivityが起動してonCreate()をコールバックするプロセスが分析済みです!
onRsume()
次はActivityがいつ見られるか見てみましょう!
通常、onCreate()ライフサイクルで独自のレイアウトファイルを設定します.

setContentView(R.layout.activity_test_view);

setContentView()システムの内部プロセスについて、このblog:setContentView()を参照して、いったい何をしましたか.
私たちは上でコードを分析した時、Activity Threadに分析しました.handleLaunchActivity()メソッドは、performLaunchActivity()を先に呼び出し(内部コールバックonCreate())、次にhandleResumeActivity()を呼び出します.名前を見ればonResume()と関係があることがわかります!
ActivityThread.handleResumeActivity()

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        // 1.    ActivityClientRecord   
        r = performResumeActivity(token, clearHide, reason);

        if (r != null) {
            final Activity a = r.activity;
            // ...

            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();

                //      ！
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (r.mPreserveWindow) {
                    a.mWindowAdded = true;
                    r.mPreserveWindow = false;

                    ViewRootImpl impl = decor.getViewRootImpl();
                    if (impl != null) {
                        impl.notifyChildRebuilt();
                    }
                }
                if (a.mVisibleFromClient && !a.mWindowAdded) {
                    a.mWindowAdded = true;

                    //   ViewManager 
                    wm.addView(decor, l);
                }

            } else if (!willBeVisible) {
                r.hideForNow = true;
            }

           // ...

           if (!r.activity.mFinished && willBeVisible
                    && r.activity.mDecor != null && !r.hideForNow) {
                // ...
                if (r.activity.mVisibleFromClient) {
                    r.activity.makeVisible(); //     ！
                }
            }


        } else {
            // ...
        }
    }

関数内部では、まずdecorViewをINVISIABLEに設定し、非表示状態にします!
Activityが(!r.activity.mFinished&&willBeVisible&&r.activity.mDecor!=null&&!r.hideForNow)という条件を満たしている場合、Activity.が呼び出されます.makeVisiable() .
Activity.makeVisiable()

void makeVisible() {
        if (!mWindowAdded) {
            ViewManager wm = getWindowManager();
            wm.addView(mDecor, getWindow().getAttributes());
            mWindowAdded = true;
        }
        mDecor.setVisibility(View.VISIBLE);
    }

ここでdecoerViewを表示状態に設定します!
振り返るとperformResumeActivity()

public final ActivityClientRecord performResumeActivity(IBinder token,
            boolean clearHide, String reason) {

        if (r != null && !r.activity.mFinished) {
            if (clearHide) {
                r.hideForNow = false;
                r.activity.mStartedActivity = false;
            }
            try {
                //...
                r.activity.performResume();

                //...
            } catch (Exception e) {
               //...
            }
        }
        return r;
    }

メソッドの内部呼び出しperformResume()

final void performResume() {
        // ...
        mInstrumentation.callActivityOnResume(this);
        // ... 
    }

Instrumentation.callActivityOnResume()

public void callActivityOnResume(Activity activity) {
        activity.mResumed = true;
        activity.onResume();

        // .. 
    }

ここでActivityのライフサイクル関数onResume()をコールバックします.
以上の解析から,システムコールバックonResume()の後にインタフェースが見えることが分かった!!!