天天看點
傳回

安卓startActivity的流程 基于API-28的源碼解析（上）

啟動流程：
  • 點選桌面App圖示，Launcher程序采用Binder IPC向system_server程序發起startActivity請求；
  • system_server程序接收到請求後，向zygote程序發送建立程序的請求；
  • Zygote程序fork出新的子程序，即App程序；
  • App程序，通過Binder IPC向sytem_server程序發起attachApplication請求；
  • system_server程序在收到請求後，進行一系列準備工作後，再通過binder IPC向App程序發送scheduleLaunchActivity請求；
  • App程序的binder線程（ApplicationThread）在收到請求後，通過handler向主線程發送LAUNCH_ACTIVITY消息；
  • 主線程在收到Message後，通過發射機制建立目标Activity，并回調Activity.onCreate()等方法。
  • 到此，App便正式啟動，開始進入Activity生命周期，執行完onCreate/onStart/onResume方法，UI渲染結束後便可以看到App的主界面。
本文詳細startActivity的整個啟動流程，
  • 流程[1.1 ~1.3]: 運作在調用者所在程序，比如從桌面啟動Activity，則調用者所在程序為launcher程序，launcher程序利用AMS作為Binder Client，進入system_server程序(AMS相應的Server端)。
  • 流程[1.4 ~1.17]:運作在system_server系統程序，整個過程最為複雜、核心的過程，下面其中部分步驟：
  • 流程[1.18 ~1.19+]:運作在目标程序，通過Handler消息機制，該程序中的Binder線程向主線程發送H.LAUNCH_ACTIVITY，最終會通過反射建立目标Activity，然後進入onCreate()生命周期。

以API28為基礎分析startActivity的源碼

  [1.1] >> Activity.startActivity() 
@Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            >> see [1.2] <<
            startActivityForResult(intent, -1, options);
        } else {
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
    }
  [1.2] >> Activity.startActivityForResult() 
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            >> see [1.3] <<
            Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
            ...
        }
           ...
    }
     execStartActivity()方法的參數:
  • mAppThread: 資料類型為ApplicationThread，通過mMainThread.getApplicationThread()方法擷取。
  • mToken: 資料類型為IBinder.
  [1.3] >> Instrumentation.execStartActivity() 
public ActivityResult execStartActivity(...) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        ...
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            >> see [1.4] <<
            int result = ActivityManager.getService().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;
    }
  • ActivityManager.getService傳回的是ActivityManagerService對象 
   [1.4] >> ActivityManager.getService()  
public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

    private static final Singleton<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @Override
                protected IActivityManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };
  •  通過ServiceManger.getService()擷取"ACITIVITY_SERVICE"的IBinder類型的AMS的引用
  • Stub是AIDL（Android Interface Definition Language）生成的一個Binder類，将一個 IBinder 轉換為 IMyAidl，如果不在一個程序就建立一個代理
  • asInterdace()方法的作用是：将服務端的Binder對象轉換為用戶端所需要的AIDL接口類型。如果用戶端和服務端同程序則傳回Binder引用的Service對象，否則傳回Binder引用的BinderProxy對象，這個BinderProxy是存活在另一個程序中的Service在目前程序的代理。
  [1.5] >> ActivityManagerService.startActivity() 
@Override
    public final int startActivity(...) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }

    public final int startActivityAsUser(...) {
        enforceNotIsolatedCaller("startActivity");

        userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        >> see [1.6] <<
        return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

    ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }
     當程式運作到這裡時, ActivityStarter的set函數傳入的各個參數取值如下:
  • caller = ApplicationThreadProxy, 用于跟調用者程序ApplicationThread進行通信的binder代理類.
  • callingUid = -1;
  • callingPackage = ContextImpl.getBasePackageName(),擷取調用者Activity所在包名
  • intent: 這是啟動Activity時傳遞過來的參數;
  • resolvedType = intent.resolveTypeIfNeeded
  • voiceSession = null;
  • voiceInteractor = null;
  • resultTo = Activity.mToken, 其中Activity是指調用者所在Activity, mToken對象儲存自己所處的ActivityRecord資訊
  • resultWho = Activity.mEmbeddedID, 其中Activity是指調用者所在Activity
  • requestCode = -1;
  • startFlags = 0;
  • profilerInfo = null;
  • outResult = null;
  • config = null;
  • options = null;
  • ignoreTargetSecurity = false;
  • userId = AMS.handleIncomingUser, 當調用者userId跟目前處于同一個userId,則直接傳回該userId;當不相等時則根據調用者userId來決定是否需要将callingUserId轉換為mCurrentUserId.
  • iContainer = null;
  • inTask = null;
  [1.6] >> ActivityStarter.execute() 
int execute() {
        try {
            // TODO(b/64750076): Look into passing request directly to these methods to allow
            // for transactional diffs and preprocessing.
            if (mRequest.mayWait) {
            >> to see [1.7] <<
                return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                        mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                        mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                        mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                        mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                        mRequest.inTask, mRequest.reason,
                        mRequest.allowPendingRemoteAnimationRegistryLookup);
            } else {
                return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                        mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                        mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                        mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                        mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                        mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                        mRequest.outActivity, mRequest.inTask, mRequest.reason,
                        mRequest.allowPendingRemoteAnimationRegistryLookup);
            }
        } finally {
            onExecutionComplete();
        }
    }
  • execute()函數就是根據布爾值Request.mayWait() 來判斷執行startActivity() or startActivityMayWait()
  • 由startActivityAsUser()可知，obtainStarter執行了setMayWait()，是以mayWait為true，執行startActivityMayWait()方法
  [1.7] >> ActivityStarter.startActivityMayWait() 
private int startActivityMayWait(...) {
        // 提示系統準備啟動Activity
        mSupervisor.getActivityMetricsLogger().notifyActivityLaunching();

        ...
        >> to see [1.8] <<
        /*通過PMS和傳遞過來的intent去查詢目标頁面的ResolveInfo。
          這個類裡放了ActivityInfo、ServiceInfo、ProviderInfo，*/
        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0, computeResolveFilterUid(callingUid, realCallingUid, mRequest.filterCallingUid));

        ...
        //通過解析ResolveInfo，得到ActivityInfo對象
        >> to see [1.12] << 
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

        ...
        /*建立一個ActivityRecord數組，然後startActivityLocked會填充上0索引，
          以便于執行完了startActivityLocked函數後儲存對象并作後邊的處理工作*/
        final ActivityRecord[] outRecord = new ActivityRecord[1];
        >> to see [1.13] <<
        int res = startActivity(...);

        ...
        // 通知系統目标Activity已經啟動完成
        mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
        return res;
    }
  • 通過ASS.resolveIntent()來解析一個與IntentFilter對應的Intent擷取資訊，部分資訊對應于AndroidManifest的<intent>标簽
  • 通過ASS.resolveActivity()來解析一個與Intent對應的Activity資訊(從AndroidManifest中activity或者receiver節點中檢索這些資訊)
  [1.8] >> ActivityStackSupervisor.resolveIntent() 
ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags,
            int filterCallingUid) {
            ...
            try {
                return mService.getPackageManagerInternalLocked().resolveIntent(intent, resolvedType, modifiedFlags, userId, true, filterCallingUid);
            }
            ...
    }

    PackageManagerInternal getPackageManagerInternalLocked() {
        if (mPackageManagerInt == null) {
            >> to see [1.9] <<
            mPackageManagerInt = LocalServices.getService(PackageManagerInternal.class);
        }
        return mPackageManagerInt;
    }
  • 調用PackageManagerService.PackageManagerInternal()的resolveIntent()方法
  [1.9] >> PackageManagerService.PackageManagerService() 
public PackageManagerService(Context context, Installer installer, boolean factoryTest, boolean onlyCore) {
       ...
       synchronized (mPackages) {
            // Expose private service for system components to use.
            LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());
           ...
        }
} 

private class PackageManagerInternalImpl extends PackageManagerInternal {
        @Override
        public ResolveInfo resolveIntent(Intent intent, String resolvedType,
                int flags, int userId, boolean resolveForStart, int filterCallingUid) {
            return resolveIntentInternal(intent, resolvedType, flags, userId, resolveForStart, filterCallingUid);
        }
}

private ResolveInfo resolveIntentInternal(Intent intent, String resolvedType,
            int flags, int userId, boolean resolveForStart, int filterCallingUid) {
        try {
            >> see [1.10] <<
            final List<ResolveInfo> query = queryIntentActivitiesInternal(intent, resolvedType,flags, filterCallingUid, userId, resolveForStart, true);
            ...
            >> see [1.11] <<
            final ResolveInfo bestChoice = chooseBestActivity(intent, resolvedType, flags, query, userId);
            return bestChoice;
        } finally {
            Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
        }
    }
  • 可見在PMS的構造函數中将PackageManagerInternalImpl的對象put到LocalService中
  • PackageManagerInternalImpl中重寫的resolveIntent函數調用PackageManagerInternal()
  • 通過queryIntentActivitiesInternal()方法擷取符合Intent的所有目标Activity資訊
  • 将傳回的Activity資訊，再通過ChooseBestActivity()選擇最合适的Activity資訊傳回
  [1.10] >> PackageManagerService.queryIntentActivitiesInternal() 
private @NonNull List<ResolveInfo> queryIntentActivitiesInternal(Intent intent,
            String resolvedType, int flags, int filterCallingUid, int userId,
            boolean resolveForStart, boolean allowDynamicSplits) {
        ...
        // 擷取intent中的Component資訊
        ComponentName comp = intent.getComponent();
        if (comp == null) {
            if (intent.getSelector() != null) {
                intent = intent.getSelector();
                comp = intent.getComponent();
            }
        }

        flags = updateFlagsForResolve(flags, userId, intent, filterCallingUid, resolveForStart, comp != null || pkgName != null /*onlyExposedExplicitly*/);

        if (comp != null) {
            final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
            // 根據Component資訊, flag, 目标Activity的userId，擷取對應的Activity資訊
            final ActivityInfo ai = getActivityInfo(comp, flags, userId);
            ...
            return applyPostResolutionFilter(list, instantAppPkgName, allowDynamicSplits, filterCallingUid, resolveForStart, userId, intent);
        }

        ...
        // 當component未空時，通過Activity.queryIntentForPackage()擷取目标Activity的resolve資訊
        final PackageParser.Package pkg = mPackages.get(pkgName);
        result = null;
        if (pkg != null) {
           result = filterIfNotSystemUser(mActivities.queryIntentForPackage(intent, resolvedType, flags, pkg.activities, userId), userId);
        }
        if (result == null || result.size() == 0) {
           addInstant = isInstantAppResolutionAllowed(intent, null /*result*/, userId, true);
           if (result == null) {
             result = new ArrayList<>();
           }
        }

        ...
        return applyPostResolutionFilter( result, instantAppPkgName, allowDynamicSplits, filterCallingUid, resolveForStart, userId, intent);
    }
  • 擷取ActivityInfo，并通過applyPostResolutionFilter()對activity進行過濾篩選
  [1.11] >> PackageManagerService.chooseBestActivity() 
private ResolveInfo chooseBestActivity(Intent intent, String resolvedType, int flags, List<ResolveInfo> query, int userId) {
        if (query != null) {

           // 假如多個activity有相同的優先級，則讓使用者進行選擇
           ResolveInfo r0 = query.get(0);
           ResolveInfo r1 = query.get(1);

           // 假如第一個activity優先級更高或者具有不同的預設值，則優先選擇該activity
           if (r0.priority != r1.priority || r0.preferredOrder != r1.preferredOrder
                        || r0.isDefault != r1.isDefault) {
               return query.get(0);
           }

           /* 通過擷取setting中的資訊來判斷目前是否已經設定了優先項，若有則預設選擇對應的activity。 */
           ResolveInfo ri = findPreferredActivity(intent, resolvedType, flags, query, r0.priority, true, false, debug, userId);
           if (ri != null) {
               return ri;
           }

           /* 若沒有，則通過ResolverActivity的onTargetSelected函數調
              PackageManager.addPreferredActivity()來執行彈出彈框，讓使用者進行選擇*/
           ri = new ResolveInfo(mResolveInfo);
           ri.activityInfo = new ActivityInfo(ri.activityInfo);
           ri.activityInfo.labelRes = ResolverActivity.getLabelRes(intent.getAction());

           final String intentPackage = intent.getPackage();
           if (!TextUtils.isEmpty(intentPackage) && allHavePackage(query, intentPackage)) {
               final ApplicationInfo appi = query.get(0).activityInfo.applicationInfo;
               ri.resolvePackageName = intentPackage;
               if (userNeedsBadging(userId)) {
                   ri.noResourceId = true;
               } else {
                   ri.icon = appi.icon;
               }
               ri.iconResourceId = appi.icon;
               ri.labelRes = appi.labelRes;
           }

           ri.activityInfo.applicationInfo = new ApplicationInfo( ri.activityInfo.applicationInfo);
           if (userId != 0) {
              ri.activityInfo.applicationInfo.uid = UserHandle.getUid(userId,
              UserHandle.getAppId(ri.activityInfo.applicationInfo.uid));
           }

           if (ri.activityInfo.metaData == null) ri.activityInfo.metaData = new Bundle();
           ri.activityInfo.metaData.putBoolean(Intent.METADATA_DOCK_HOME, true);
           return ri;
        }

        return null;
    }
  • 當傳入的ResovleInfo List隻有一個值時，不用進行選擇
  • 當存在多個符合intent資訊的Activity的ResolveInfo， 則先判斷activity的優先級，再判斷是否有預設選項
  • 當存在多個選擇則沒有設定預設選項時，app通過ResolverActivity的onTargetSelected函數調用pm.addPreferredActivity()方法來執行彈出選擇彈框，讓使用者進行選擇
  [1.12] >> ActivityStackSupervisor.resolveActivity() 
ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags,
            ProfilerInfo profilerInfo) {
        final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null;
        if (aInfo != null) {
            //将最新的info資訊重新存儲到intent中
            intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
            ...
            final String intentLaunchToken = intent.getLaunchToken();
            if (aInfo.launchToken == null && intentLaunchToken != null) {
                aInfo.launchToken = intentLaunchToken;
            }
        }
        return aInfo;
    }
  [1.13] >> ActivityStarter.startActivity() 
private int startActivity(...) {
        int err = ActivityManager.START_SUCCESS;
        //擷取應用的程序描述類對象ProcessRecord
        ProcessRecord callerApp = null;
        if (caller != null) {
            callerApp = mService.getRecordForAppLocked(caller);
            ...
        }

        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {
            //擷取應用目前所在的ActivityRecord資訊
            sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
            if (sourceRecord != null) {
                if (requestCode >= 0 && !sourceRecord.finishing) {
           //當使用的是startActivityForResult()的話，resultRecord存的就是目前Activity
                    resultRecord = sourceRecord;
                }
            }
        }

        final int launchFlags = intent.getFlags();
        /*FLAG_ACTIVITY_FORWARD_RESULT這個标記允許我們把startActivityForResult的線路
        拉長，比如A->B->C，然後C可以直接把值傳遞到A*/
        if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {  ...  }
       
        ...
        //執行後resultStack = null
        final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();

        //ActivityController不為空的情況，比如monkey測試過程
        if (mService.mController != null) {
            try {
                // The Intent we give to the watcher has the extra data
                // stripped off, since it can contain private information.
                Intent watchIntent = intent.cloneFilter();
                abort |= !mService.mController.activityStarting(watchIntent,
                        aInfo.applicationInfo.packageName);
            } catch (RemoteException e) {
                mService.mController = null;
            }
        }
        //判斷目标Activity是否已經關閉工作或者目标application被挂起，是則攔截activity啟動
        mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage);
        if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, callingPid, callingUid, checkedOptions)) {
         ...
        }

        //判斷啟動的activity的權限是否已被允許，GRANT的話abort為false
        boolean abort = !mSupervisor.checkStartAnyActivityPermission(...);
 
        ...
        /*如果權限需要在任何應用程式運作之前進行确認，将彈出權限确認框，在确認完成後立即啟動活動。*/
        if (mService.mPermissionReviewRequired && aInfo != null) {
            if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
                    aInfo.packageName, userId)) {
                IIntentSender target = mService.getIntentSenderLocked(...);

                final int flags = intent.getFlags();
                Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
                newIntent.setFlags(...) {
                    newIntent.putExtra(Intent.EXTRA_RESULT_NEEDED, true);
                }
                intent = newIntent;
                ...
                rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0, computeResolveFilterUid(callingUid, realCallingUid, mRequest.filterCallingUid));
                aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, null);
            }
        }

        ...
        // 建立出我們的目标ActivityRecord對象，存到傳入數組0索引上
        ActivityRecord r = new ActivityRecord(...);
        if (outActivity != null) {
            outActivity[0] = r;
        }

        ...
       //檢查是否有需要延遲啟動的Activity，如果有，則啟動
        mController.doPendingActivityLaunches(false);
       >> see [1.14] <<
        return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                true /* doResume */, checkedOptions, inTask, outActivity);
    }
  • checkStartAnyActivityPermission檢測步驟：
  • （1）首先是檢測是否有root權限
  • （2）然後如果export=false，且callingUid不等于啟動的uid（不在一個程序），則不予權限。
  • （3）activity的permission與application相同，則授權。
  • （4）activity的permission為空授權；
  • （5）請求啟動的activity設定了permission，那麼檢查caller的activity中是否聲明了使用這個permission，如果聲明了授權。
  • 其中有兩個傳回值代表啟動Activity失敗：
  • START_INTENT_NOT_RESOLVED: 從Intent中無法找到相應的Component或者ActivityInfo
  • START_NOT_CURRENT_USER_ACTIVITY：該Activity對目前使用者不可見
  [1.14] >> ActivityStarter.startActivity() 
private int startActivity(...) {
        int result = START_CANCELED;
        try {
            //通知Wms（WindowManagerService）阻塞一下Surface
            mService.mWindowManager.deferSurfaceLayout();//WMS.deferSurfaceLayout
            >> see [1.15]<<
            result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, outActivity);
        } finally {
            //啟動activity失敗的話，解除activity與任務的關聯。
            final ActivityStack stack = mStartActivity.getStack();
            if (!ActivityManager.isStartResultSuccessful(result) && stack != null) {
                stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
                        null /* intentResultData */, "startActivity", true /* oomAdj */);
            }
            mService.mWindowManager.continueSurfaceLayout();
        }
        postStartActivityProcessing(r, result, mTargetStack);
        return result;
    }
  • 在執行多個更改時非常有用，但是為了優化性能，應該隻執行一次布局傳遞
  • deferSurfaceLayout可以被多次調用，當調用WMS.continueSurfaceLayout()後，将恢複布局。
  [1.15] >> ActivityStarter.startActivityUnchecked() 
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,...) {
        /*根據啟動intent識别LaunchMode，如果是startActivityForResult并且啟動模式是NEW_TASK的話，就會讓startActivityForResult的回調失效。*/
        setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,voiceInteractor);        

        //判斷啟動模式，并且在mLaunchFlags上追加對應的标記
        computeLaunchingTaskFlags();

        //擷取到Activity的啟動棧
        computeSourceStack();

        //根據上面的計算，應用識别到的flags
        mIntent.setFlags(mLaunchFlags);

        ...
        mIntent.setFlags(mLaunchFlags);
        /*決定是否應将新activity插入到現有task中。如果不是則傳回null，
          如果是則傳回包含将新activity添加到其中的task的ActivityRecord。*/
        ActivityRecord reusedActivity = getReusableIntentActivity();

        ...
        if (reusedActivity != null) {
            // 如果mStartactivity沒有與其關聯的任務，請與複用的ActivityTask關聯
            if (mStartActivity.getTask() == null && !clearTopAndResetStandardLaunchMode) 
            {
                mStartActivity.setTask(reusedActivity.getTask());
            }

            if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
                    || isDocumentLaunchesIntoExisting(mLaunchFlags)
                    || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
                final TaskRecord task = reusedActivity.getTask();

                // 在這種情況下，我們希望從task中删除除正在啟動的activity之外的所有activity。将task重置為初始狀态。
                final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity,
                        mLaunchFlags);

                // Activityrecord删除對taskRecord的引用，在後面調用setTargetStackAndMoveToFrontIfNeeded()時需要task引用。
                if (reusedActivity.getTask() == null) {
                    reusedActivity.setTask(task);
                }

                if (top != null) {
                    if (top.frontOfTask) {
                        // 将目标activityRecord傳入task棧頂
                        top.getTask().setIntent(mStartActivity);
                    }
					// 傳遞目标activity的intent，確定将會最先被執行
                    deliverNewIntent(top);
                }
            }

            reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
            if (reusedActivity != null) {
                setTaskFromIntentActivity(reusedActivity);
            }
        }


        /*接下來判斷是否需要新建立一個task出來，比如NEW_TASK
          如果不需要建立就通過setTaskFromSourceRecord()直接把目标Activity放入到對應的task内*/
        boolean newTask = false;
        final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
                ? mSourceRecord.getTask() : null;
        // Should this be considered a new task?
        int result = START_SUCCESS;
        if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
                && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
            newTask = true;
            result = setTaskFromReuseOrCreateNewTask(
                    taskToAffiliate, preferredLaunchStackId, topStack);
        } else if (mSourceRecord != null) {
            result = setTaskFromSourceRecord();
        } else if (mInTask != null) {
            result = setTaskFromInTask();
        } else {
            // This not being started from an existing activity, and not part of a new task...
            // just put it in the top task, though these days this case should never happen.
            setTaskToCurrentTopOrCreateNewTask();
        }
        if (result != START_SUCCESS) {
            return result;
        }

        //檢查是否具有contentProvider的uri通路權限
        mService.grantUriPermissionFromIntentLocked(mCallingUid, mStartActivity.packageName,mIntent, mStartActivity.getUriPermissionsLocked(), mStartActivity.userId);

        /*判斷是否需要發送警告（PowerManager實作），判斷依據是resumedActivity被回收或者是程序被殺死或者是目标Activity的程序和resumedActivity的程序不一緻的時候*/
        mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, mStartActivity);

        >> see [1.16]<<
        mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions);
        if (mDoResume) {
          >> see [1.17]<<
          mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions); 
        } 

        return START_SUCCESS;
    }
  •  r -> 準備啟動的activity， sourceRecord -> 目前的activity  
  • 假如Intent中設定的Launch資訊與Manifest有沖突，則優先選擇Manifest
  [1.16] >> ActivityStack.startActivityLocked 
void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
            boolean newTask, boolean keepCurTransition, ActivityOptions options) {
        TaskRecord rTask = r.getTask();
        final int taskId = rTask.taskId;
        // 将目标activity所在的Task放在Task棧的頂端，同時将activity對應的window置頂
        if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
            insertTaskAtTop(rTask, r);
        }
        TaskRecord task = null;

        //假如Activity還在原來的棧中運作，此時就将Activity移動到ActivityStack的頂端
        if (!newTask) {
            boolean startIt = true;
            for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
                if (task == rTask) {
                    if (!startIt) {
                        //初始化WMS的設定，将activity加入棧頂
                        r.createWindowContainer();
                        ActivityOptions.abort(options);
                        return;
                    }
                    break;
                } else if (task.numFullscreen > 0) {
                    startIt = false;
                }
            }
        }

        // 将要啟動的activity設定到Task的的棧頂
        task.setFrontOfTask();
        ...
    }
  • 主要任務是将目标Activity和Activity所在的棧都放到容器的頂端 
  [1.17] >> ActivityStack.resumeTopActivityInnerLocked() 
@GuardedBy("mService")
    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        if (!mService.mBooting && !mService.mBooted) {
            // Not ready yet!
            return false;
        }

        // 找出目前棧頂的activity，因為目标Activity已經入棧了，是以next就是目标Activity
        final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
		
        ...
        next.delayedResume = false;

        // 如果目标Activity是resume狀态，那麼直接通知Wms執行Activity的過渡
        if (mResumedActivity == next && next.isState(RESUMED)
                && mStackSupervisor.allResumedActivitiesComplete()) {
            // Make sure we have executed any pending transitions, since there
            // should be nothing left to do at this point.
            executeAppTransition(options);

            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return false;
        }

        // 如果目标Activity已經是sleep狀态，如果進入睡眠狀态Activity也會進入Pause狀态
        if (shouldSleepOrShutDownActivities()
                && mLastPausedActivity == next
                && mStackSupervisor.allPausedActivitiesComplete()) {
            // Make sure we have executed any pending transitions, since there
            // should be nothing left to do at this point.
            executeAppTransition(options);
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Going to sleep and all paused");
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return false;
        }

        ...
        // 将目前activity置為pause狀态
        boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);

        if (pausing && !resumeWhilePausing) {
            if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG_STATES,
                    "resumeTopActivityLocked: Skip resume: need to start pausing");

            if (next.app != null && next.app.thread != null) {
			    //用于更新程序的使用情況，把目标Activity的程序放在LRU清單的頂部
                mService.updateLruProcessLocked(next.app, true, null);
            }
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            if (lastResumed != null) {
                lastResumed.setWillCloseOrEnterPip(true);
            }
            return true;
        }

        /* 當most recent的Activity不是在“曆史記錄”裡，而是因為裝置進入睡眠狀态而停止，而不
           是“停止+銷毀”，因為我們正在使一個新的Activity成為最頂層，我們需要確定銷毀它。*/
        if (shouldSleepActivities() && mLastNoHistoryActivity != null &&
                !mLastNoHistoryActivity.finishing) {
            requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
                    null, "resume-no-history", false);
            mLastNoHistoryActivity = null;
        }

        // 確定啟動目标Activity的app狀态不為stop
        try {
            AppGlobals.getPackageManager().setPackageStoppedState(
                    next.packageName, false, next.userId); /* TODO: Verify if correct userid */
        } catch (RemoteException e1) {
        } catch (IllegalArgumentException e) {
            Slog.w(TAG, "Failed trying to unstop package "
                    + next.packageName + ": " + e);
        }

        // 準備開啟app的activity
        boolean anim = true;
        if (prev != null) {
            if (prev.finishing) {
                // 通知WMS進行app頁面過渡準備
                if (mStackSupervisor.mNoAnimActivities.contains(prev)) {
                    anim = false;
                    mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
                } else {
                    mWindowManager.prepareAppTransition(prev.getTask() == next.getTask()
                            ? TRANSIT_ACTIVITY_CLOSE
                            : TRANSIT_TASK_CLOSE, false);
                }
                prev.setVisibility(false);
            } else {
                if (mStackSupervisor.mNoAnimActivities.contains(next)) {
                    anim = false;
                    mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
                } else {
                    mWindowManager.prepareAppTransition(prev.getTask() == next.getTask()
                            ? TRANSIT_ACTIVITY_OPEN
                            : next.mLaunchTaskBehind
                                    ? TRANSIT_TASK_OPEN_BEHIND
                                    : TRANSIT_TASK_OPEN, false);
                }
            }
        } 
		
        ...
        // 擷取最近Foucus的TaskStack
        ActivityStack lastStack = mStackSupervisor.getLastStack();
		
        // 目标Activity所在的app程序已存在的情況下,
        if (next.app != null && next.app.thread != null) {
		
            // 目标activity正在成為可見
            if (!next.visible || next.stopped || lastActivityTranslucent) {
                    next.setVisibility(true);
                }

            // schedule launch ticks to collect information about slow apps.
            next.startLaunchTickingLocked();

            ActivityRecord lastResumedActivity = lastStack == null ? null :lastStack.mResumedActivity;
            final ActivityState lastState = next.getState();

            mService.updateCpuStats();

            if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next + " (in existing)");
            
            // 設定Activity的狀态為Resume
            next.setState(RESUMED, "resumeTopActivityInnerLocked");

            mService.updateLruProcessLocked(next.app, true, null);
            updateLRUListLocked(next);
            mService.updateOomAdjLocked();

            // Have the window manager re-evaluate the orientation of
            // the screen based on the new activity order.
            boolean notUpdated = true;
				
		    ...
            synchronized(mWindowManager.getWindowManagerLock()) {
                // This activity is now becoming visible.
                if (!next.visible || next.stopped || lastActivityTranslucent) {
                    next.setVisibility(true);
                }

                // schedule launch ticks to collect information about slow apps.
                next.startLaunchTickingLocked();

                ActivityRecord lastResumedActivity =
                        lastStack == null ? null :lastStack.mResumedActivity;
                final ActivityState lastState = next.getState();

                // 喚醒CPU
                mService.updateCpuStats();

                if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next
                        + " (in existing)");

                next.setState(RESUMED, "resumeTopActivityInnerLocked");

                // 更新目标Activity所在的程序狀态
                mService.updateLruProcessLocked(next.app, true, null);
                updateLRUListLocked(next);
                mService.updateOomAdjLocked();

                // Have the window manager re-evaluate the orientation of
                // the screen based on the new activity order.
                boolean notUpdated = true;

                /* 當目标Activity所在的Task為FocusTask時，将Task頂端的目标Activity的
                   LaunchActivityItem添加到ClientTransaction上 */
                if (mStackSupervisor.isFocusedStack(this)) {
                    notUpdated = !mStackSupervisor.ensureVisibilityAndConfig(next, mDisplayId,true /* markFrozenIfConfigChanged */, false /* deferResume */);
                }

                try {
                    final ClientTransaction transaction = ClientTransaction.obtain(next.app.thread, next.appToken);
                    // 判斷是否需要觸發onActivityResult函數
                    ArrayList<ResultInfo> a = next.results;
                    if (a != null) {
                        final int N = a.size();
                        if (!next.finishing && N > 0) {
                            if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                                    "Delivering results to " + next + ": " + a);
                            transaction.addCallback(ActivityResultItem.obtain(a));
                        }
                    }
                    // 是否需要觸發onNewIntent函數
                    if (next.newIntents != null) {
                        transaction.addCallback(NewIntentItem.obtain(next.newIntents,
                                false /* andPause */));
                    }

                    // Well the app will no longer be stopped.
                    // Clear app token stopped state in window manager if needed.
                    next.notifyAppResumed(next.stopped);

                    EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId,
                            System.identityHashCode(next), next.getTask().taskId,
                            next.shortComponentName);

                    next.sleeping = false;
                    mService.getAppWarningsLocked().onResumeActivity(next);
                    mService.showAskCompatModeDialogLocked(next);
                    next.app.pendingUiClean = true;
                    next.app.forceProcessStateUpTo(mService.mTopProcessState);
                    next.clearOptionsLocked();
					
                    // 将ResumeActivityItem添加到ClientTransaction中
                    transaction.setLifecycleStateRequest( ResumeActivityItem.obtain( next.app.repProcState, mService.isNextTransitionForward()));
                   // 執行ClientTransaction中的LaunchActivityItem，ResumeActivityItem等
                   >> see [1.18] <<
                    mService.getLifecycleManager().scheduleTransaction(transaction);

                    if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Resumed "+ next);
                } catch (Exception e) {
                    // Whoops, need to restart this activity!
                    if (DEBUG_STATES) Slog.v(TAG_STATES, "Resume failed; resetting state to "+ lastState + ": " + next);
                    next.setState(lastState, "resumeTopActivityInnerLocked");

                    // lastResumedActivity being non-null implies there is a lastStack present.
                    if (lastResumedActivity != null) {
                        lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");
                    }

                    Slog.i(TAG, "Restarting because process died: " + next);
                    if (!next.hasBeenLaunched) {
                        next.hasBeenLaunched = true;
                    } else  if (SHOW_APP_STARTING_PREVIEW && lastStack != null
                            && lastStack.isTopStackOnDisplay()) {
                        next.showStartingWindow(null /* prev */, false /* newTask */,
                                false /* taskSwitch */);
                    }
                    mStackSupervisor.startSpecificActivityLocked(next, true, false);
                    if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                    return true;
                }
            }

            // From this point on, if something goes wrong there is no way
            // to recover the activity.
            try {
                next.completeResumeLocked();
            } catch (Exception e) {
                // If any exception gets thrown, toss away this
                // activity and try the next one.
                Slog.w(TAG, "Exception thrown during resume of " + next, e);
                requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
                        "resume-exception", true);
                if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                return true;
            }
        } else {
            // Whoops, need to restart this activity!
            if (!next.hasBeenLaunched) {
                next.hasBeenLaunched = true;
            } else {
                if (SHOW_APP_STARTING_PREVIEW) {
                    next.showStartingWindow(null /* prev */, false /* newTask */,
                            false /* taskSwich */);
                }
                if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
            }
            if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
            // 當目标activity的程序不存在的時候，建立程序啟動app 
            >> see [1.19] <<
            mStackSupervisor.startSpecificActivityLocked(next, true, true);
        }

        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
        return true;
    }
  • 将目前的Activity的狀态設為Pause
  • 當目标Activity所在的程序存在的話，則将目标Activity設為Resume狀态，通過ClientLifecycleManager.scheduleTransaction()方法進行啟動app
  • 當目标Activity所在的程序不存在的話，則通過ActivityStackSupervisor.startSpecificActivityLocked()方法開啟程序，進行app啟動
  [1.18] >> ClientLifecycleManager.scheduleTransaction() 
1.
class ClientLifecycleManager {
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule(); //轉 2
        if (!(client instanceof Binder)) {
            transaction.recycle();
        }
    }
    ...
}

2.
public class ClientTransaction implements Parcelable, ObjectPoolItem {
  public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this); //轉 3
    }
  ...
}

3.
public final class ActivityThread extends ClientTransactionHandler {
    private class ApplicationThread extends IApplicationThread.Stub {
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction); // 轉 4
        }
    }
    ...
}

4.
public abstract class ClientTransactionHandler {
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
    ...
}

5.
public final class ActivityThread extends ClientTransactionHandler {
    class H extends Handler {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    mTransactionExecutor.execute(transaction);  // 轉 6
                    if (isSystem()) {
                        transaction.recycle();
                    }
                    break;
                ...
            }
       }
   }
   ...
} 

6.
public class TransactionExecutor {
    public void execute(ClientTransaction transaction) {
        final IBinder token = transaction.getActivityToken();

        executeCallbacks(transaction); //轉 6.1

        executeLifecycleState(transaction); //轉 6.2
        mPendingActions.clear();
        log("End resolving transaction");
    }
    ...
}

6.1
    /** Cycle through all states requested by callbacks and execute them at proper times. */
    @VisibleForTesting
    public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();

        ...
        final int size = callbacks.size();
        for (int i = 0; i < size; ++i) {
            final ClientTransactionItem item = callbacks.get(i);

            ...
            >> to see [1.18.1] <<
            item.execute(mTransactionHandler, token, mPendingActions);
            item.postExecute(mTransactionHandler, token, mPendingActions);
            if (r == null) {
                // Launch activity request will create an activity record.
                r = mTransactionHandler.getActivityClient(token);
            }
        }
    }

6.2
    /** Transition to the final state if requested by the transaction. */
    private void executeLifecycleState(ClientTransaction transaction) {
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();

        final IBinder token = transaction.getActivityToken();
        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

        if (r == null) {
            // Ignore requests for non-existent client records for now.
            return;
        }

        // Cycle to the state right before the final requested state.
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);

        // Execute the final transition with proper parameters.
        >> to see [1.18.2] <<
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }
  • 在ClientTransaction和ActivityThead之間繞了幾圈之後，最後通過ActivityThread的executeCallbacks()和executeLifecycleState()函數進行操作

  • 通過6.1/6.2可以看到，實際是通過執行Transaction中Callback的ClientTransactionItem

    和LifecycleItem的excute方法

  • 也就是執行之前通過transaction.setLifecycleStateRequest()添加的ResumeActivityItem.excute()和mStackSupervisor.ensureVisibilityAndConfig()添加的LaunchActivityItem.excute()方法
   [1.18.1] >> LaunchActivityItem.excute() 
public class LaunchActivityItem extends ClientTransactionItem {
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
                mPendingResults, mPendingNewIntents, mIsForward,
                mProfilerInfo, client);
        >> to see [1.18.1.1] <<
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }
    ...
}
  • 這裡就是根據傳入的參數，生成目标Activity的執行個體Record--ActivityClientRecord
  • 通過ActivityThread.handleLaunchActivity()啟動activity
  [1.18.1.1] >> ActivityThread.handleLaunchActivity() 
@Override
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        if (r.profilerInfo != null) {
            mProfiler.setProfiler(r.profilerInfo);
            mProfiler.startProfiling();
        }

        // Make sure we are running with the most recent config.
        handleConfigurationChanged(null, null);

        // Initialize before creating the activity
        if (!ThreadedRenderer.sRendererDisabled) {
            GraphicsEnvironment.earlyInitEGL();
        }
        WindowManagerGlobal.initialize();
        
        >> to see [1.18.1.2] <<
        final Activity a = performLaunchActivity(r, customIntent);

        // 當啟動App成功後，設定InstanceState
        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            if (!r.activity.mFinished && pendingActions != null) {
                pendingActions.setOldState(r.state);
                pendingActions.setRestoreInstanceState(true);
                pendingActions.setCallOnPostCreate(true);
            }
        } else {
            // If there was an error, for any reason, tell the activity manager to stop us.
            try {
                ActivityManager.getService().finishActivity(r.token, Activity.RESULT_CANCELED, null,Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
        }

        return a;
    }
  [1.18.1.2] >> ActivityThread.performLaunchActivity() 
/**  Core implementation of activity launch. */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // 擷取目标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);
        }

        //建立目标Activity的Context
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        try {
            //通過反射的方式建立activity
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {...}

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

            if (activity != null) {
                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;
                }
				
                //将context群組件資訊跟目标Activity綁定
                appContext.setOuterContext(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, r.configCallback);

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

                activity.mCalled = false;
                //啟動目标Activity，調用Activity的onCreate方法
                >> to see [1.18.1.3] <<
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }

                r.activity = activity;
            }
            r.setState(ON_CREATE);

            mActivities.put(r.token, r);
        }
        ...
        return activity;
    }
  [1.18.1.3] >> Instrumentation.callActivityOnCreate() 
/**
     * Perform calling of an activity's {@link Activity#onCreate}
     * method.  The default implementation simply calls through to that method.
     *
     * @param activity The activity being created.
     * @param icicle The previously frozen state (or null) to pass through to onCreate().
     */
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }
  • 執行目标Activity的onCreate操作，進入目标Activity的生命周期
  • 執行完了onCreate，那下一步就是onStart, 然後就是onResume了。
  [1.18.2] ResumenActivityItem.excute() 
@Override
    public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
        >> to see [1.18.2.1] <<
        client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward, "RESUME_ACTIVITY");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }
  • 執行ActivityThread.handleResumeActivity()
  [1.18.2.1] >> ActivityThread.handleResumeActivity() 
@Override
    public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward, String reason) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        // TODO Push resumeArgs into the activity for consideration
        >> to see [1.18.2.2] <<
        // 将目标Activity更新為onResume狀态
        final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);

        ...// 設定WindowManager，顯示目标Activity

        r.nextIdle = mNewActivities;
        mNewActivities = r;
        Looper.myQueue().addIdleHandler(new Idler());
    }
  [1.18.2.2] >> ActivityThread.performResumeActivity() 
@VisibleForTesting
    public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,String reason) {
        // 根據token通過IPC方式擷取對應的ActivityRecord
        final ActivityClientRecord r = mActivities.get(token);

        ...
        if (finalStateRequest) {
            r.hideForNow = false;
            r.activity.mStartedActivity = false;
        }
        try {
            r.activity.onStateNotSaved();
            r.activity.mFragments.noteStateNotSaved();
            checkAndBlockForNetworkAccess();
            if (r.pendingIntents != null) {
                deliverNewIntents(r, r.pendingIntents);
                r.pendingIntents = null;
            }
            if (r.pendingResults != null) {
                deliverResults(r, r.pendingResults, reason);
                r.pendingResults = null;
            }
            >> to see [1.18.2.3] <<
            // 将目标Activity設為onResume
            r.activity.performResume(r.startsNotResumed, reason);

            r.state = null;
            r.persistentState = null;
            r.setState(ON_RESUME);
        }
        return r;
    }
  [1.18.2.3] >> Activity.performResume() 
final void performResume(boolean followedByPause, String reason) {
        //在onResume之前先調用onStart，很符合Activity的生命周期
        >> to see [1.18.2.4] <<
        performRestart(true /* start */, reason);

        ...
        // 調用目标Activity的onResume()方法
        mInstrumentation.callActivityOnResume(this);

        // 在onResume()方法執行完畢之前，目标Activity需要完成頁面顯示動作
        // 當onResume()方法執行完畢後，調用該方法
        ...
        onPostResume();
    }
  • 在執行onResume()前，先執行onStart()
  • 頁面要在onResume()執行完之前完成顯示動作
[1.18.2.4] >> Activity.performStart() 
final void performRestart(boolean start, String reason) {

       ...
       // 調用Activity的onRestart()方法
       mInstrumentation.callActivityOnRestart(this);

       ...
       // onRestart()之後，再調用onStart()方法
       if (start) {
         performStart(reason);
       }
    }


    final void performStart(String reason) {
        ...
        // 調用Activity的onStart()方法
        mInstrumentation.callActivityOnStart(this);

        ...
        // 标志Activity已經完全啟動狀态，開始進行DecorView頁面繪制并顯示
        mActivityTransitionState.enterReady(this);
    }
  • 因為目标Activity所在的app存在于背景，根據activity的生命周期，先調用onRestart()再調用onStart()方法（resumeTopActivityInnerLocked()中可見判斷app是否存在）
  • 至此，當目标Activity所在App已經存在于背景（或者是分屏）時，其他app或adb指令通過startActivity方式啟動該目标Activity的流程已經完成。
startActivity api-28 App啟動流程
上一篇: day36_Spring學習筆記_04_SVN
下一篇: MyEclipse 打開檔案的時候會報 Error opening the editor. 錯誤的解決方法

繼續閱讀