Activity启动流程2

在应用程序内启动同进程内的Activity

1、onClick

    @Override
    public void onClick(View v) {
   
        switch (v.getId()){
   
            case R.id.btn_sub:
                Intent intent = new Intent();
                intent.setAction("com.shbj.action.action.sub1");
                startActivity(intent);
                break;

2、startActivity

3、startActivityForResult

4、execStartActivity

5、startActivity

    @Override
    public void startActivity(Intent intent) {
   
        startActivityForResult(intent, -1);//-1表示不需要知道即将启动的Activity组件的执行结果
    }

    public void startActivityForResult(Intent intent, int requestCode) {
   
        if (mParent == null) {
   
			//Instrumentation用来监控应用程序与系统之间的交互
            Instrumentation.ActivityResult ar =
            //mMainThread.getApplicationThread()得到类型为AppliactionThread的Binder本地对象，将它传递给ActivityManagerService用于进程间通信
            //mToken类型是IBinder，它是一个Binder代理对象，指向ActivityManagerService中类型为ActivityRecord的Binder本地对象，用来维护对应的Activity组件的运行状态以及信息
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode);

    public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode) {
   
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        try {
   
            int result = ActivityManagerNative.getDefault()//获得ActivityManagerService的代理对象
                .startActivity(whoThread, intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        null, 0, token, target != null ? target.mEmbeddedID : null,
                        requestCode, false, false);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
   
        }
        return null;
    }

    //(whoThread, intent,intent.resolveTypeIfNeeded(who.getContentResolver()),null, 
    //0, token, target != null ? target.mEmbeddedID : null,requestCode, false, false)
    //caller为应用进程的ApplicationThread对象，intent包含要启动的Activity组件信息，
    //resultTo指向ActivityManagerService内的一个ActivityRecord对象
    public int startActivity(IApplicationThread caller, Intent intent,
            String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
            IBinder resultTo, String resultWho,
            int requestCode, boolean onlyIfNeeded,
            boolean debug) throws RemoteException {
   
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeTypedArray(grantedUriPermissions, 0);
        data.writeInt(grantedMode);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(onlyIfNeeded ? 1 : 0);
        data.writeInt(debug ? 1 : 0);
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

以上5步是在应用程序进程中执行

6、startActivity

7、startActivityMayWait

8、startActivityLocked

    public final int startActivity(IApplicationThread caller,
            Intent intent, String resolvedType, Uri[] grantedUriPermissions,
            int grantedMode, IBinder resultTo,
            String resultWho, int requestCode, boolean onlyIfNeeded,
            boolean debug) {
   
            //mMainStack描述一个Activity组件堆栈
        return mMainStack.startActivityMayWait(caller, intent, resolvedType,
                grantedUriPermissions, grantedMode, resultTo, resultWho,
                requestCode, onlyIfNeeded, debug, null, null);
    

    final int startActivityMayWait(IApplicationThread caller,
            Intent intent, String resolvedType, Uri[] grantedUriPermissions,
            int grantedMode, IBinder resultTo,
            String resultWho, int requestCode, boolean onlyIfNeeded,
            boolean debug, WaitResult outResult, Configuration config) {
   

        boolean componentSpecified = intent.getComponent() != null;
        
        // Don't modify the client's object!
        intent = new Intent(intent);

        // Collect information about the target of the Intent.
        ActivityInfo aInfo;
        try {
   
            ResolveInfo rInfo =
                AppGlobals.getPackageManager().resolveIntent(
                        intent, resolvedType,
                        PackageManager.MATCH_DEFAULT_ONLY
                        | ActivityManagerService.STOCK_PM_FLAGS);//到Package管理服务中去解析intent的内容，以便获得更多即将启动的Activity信息
            aInfo = rInfo != null ? rInfo.activityInfo : null;
        } catch (RemoteException e) {
   
            aInfo = null;
        }

        if (aInfo != null) {
   
            // Store the found target back into the intent, because now that
            // we have it we never want to do this again.  For example, if the
            // user navigates back to this point in the history, we should
            // always restart the exact same activity.
            intent.setComponent(new ComponentName(
                    aInfo.applicationInfo.packageName, aInfo.name));
        }

        synchronized (mService) {
   
            int callingPid;
            int callingUid;
            if (caller == null) {
   
                callingPid = Binder.getCallingPid();
                callingUid = Binder.getCallingUid();
            } else {
   
                callingPid = callingUid = -1;
            }
            
            mConfigWillChange = config != null
                    && mService.mConfiguration.diff(config) != 0;
            
            final long origId = Binder.clearCallingIdentity();
            
            int res = startActivityLocked(caller, intent, resolvedType,
                    grantedUriPermissions, grantedMode, aInfo,
                    resultTo, resultWho, requestCode, callingPid, callingUid,
                    onlyIfNeeded, componentSpecified);
            
            return res;
        }
    }

    final int startActivityLocked(IApplicationThread caller,
            Intent intent, String resolvedType,
            Uri[] grantedUriPermissions,
            int grantedMode, ActivityInfo aInfo, IBinder resultTo,
            String resultWho, int requestCode,
            int callingPid, int callingUid, boolean onlyIfNeeded,
            boolean componentSpecified) {
   

        int err = START_SUCCESS;

        ProcessRecord callerApp = null;//每一个应用程序进程都是用一个ProcessRecord来描述，并保存在ActivityManagerService内部
        if (caller != null) {
   
            callerApp = mService.getRecordForAppLocked(caller);
            if (callerApp != null) {
   
                callingPid = callerApp.pid;//进程的pid
                callingUid = callerApp.info.uid;//进程的uid
            } else {
   
                Slog.w(TAG, "Unable to find app for caller " + caller
                      + " (pid=" + callingPid + ") when starting: "
                      + intent.toString());
                err = START_PERMISSION_DENIED;
            }
        }

        ActivityRecord sourceRecord = null;
        ActivityRecord resultRecord = null;
        if (resultTo != null) {