基于 Android Q 10.0 系统 Activity启动流程探索

基于 Android Q 10.0 系统 Activity启动流程探索

推荐一个看Android源码的地址： Android Code Search

1 MainActivity.java

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

2 Activity.java

@Override
public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

...里面重载函数就不贴了....
  
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
  ...
  Instrumentation.ActivityResult ar =
         mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
  ...
}

3 Instrumentation.java

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
     ...
        int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
  ...
}

4 ActivityTaskManager.java

public static IActivityTaskManager getService() {
    return IActivityTaskManagerSingleton.get();
}

@UnsupportedAppUsage(trackingBug = 129726065)
 private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
            new Singleton<IActivityTaskManager>() {
                @Override
                protected IActivityTaskManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                    return IActivityTaskManager.Stub.asInterface(b);
                }
            };
//   IActivityTaskManagerSingleton.get()获取的就是ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
//通过IBinder跨进程方式调用系统服务——IActivityTaskManager是ActivityTaskManagerService代理类
public abstract class Singleton<T> {
    @UnsupportedAppUsage
    private T mInstance;

    protected abstract T create();

    @UnsupportedAppUsage
    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

5 ActivityTaskManagerService.java

@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());
}
....
//最终会走到下面这个方法中
int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
            boolean validateIncomingUser) {
       //  getActivityStartController().obtainStarte得到的是ActivityStarter，通过构造者模式填入各种属性，最终执行excute方法
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

6 ActivityStarter.java

 ActivityStarter setMayWait(int userId) {
        mRequest.mayWait = true;
        mRequest.userId = userId;
        return this;
    }
//注意这里mRequest.mayWait因为被5执行了setMayWait(userId)，到此已经为true了
int execute() {
    try {
        if (mRequest.mayWait) {
            //mRequest.mayWait=true,进入到这里
            return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                    mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
                    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,
                    mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
        } 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,
                    mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
        }
    } finally {
        onExecutionComplete();
    }
  
  //这个方法里面的代码太多了，我们只看最关键的
  private int startActivityMayWait(...){
    ...
    int res = startActivity(...);
    ...
  }
  
  ...层层找,这里找resumeFocusedStacksTopActivities是关键点
    
    startActivity()-->startActivityUnchecked()--> 
    //找到下面这段代码是至关重要的,这是整个过程最难的部分
    mRootActivityContainer.resumeFocusedStacksTopActivities(
                        mTargetStack, mStartActivity, mOptions);
   
  

7 RootActivityContainer.java

 boolean resumeFocusedStacksTopActivities() {
        return resumeFocusedStacksTopActivities(null, null, null);
    }
 ...
  focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);

8 ActivityStack.java

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    if (mInResumeTopActivity) {
        // Don't even start recursing.
        return false;
    }

    boolean result = false;
    try {
        // Protect against recursion.
        mInResumeTopActivity = true;
        result = resumeTopActivityInnerLocked(prev, options);
    } finally {
        mInResumeTopActivity = false;
    }

    return result;
}

 private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
       ...
      //这里判断是否之前的Activity已经处于Resume状态,如果有的话要执行onStop方法
      if (mResumedActivity != null) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
            pausing |= startPausingLocked(userLeaving, false, next, false);
        }
       ....
       //这里是要打开新的Activity了
         mStackSupervisor.startSpecificActivityLocked(next, true, true);
 }

9 ActivityStackSupervisor.java

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
   try {
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }
}


 boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
     ...
    // Create activity launch transaction.
    //1 构造一个信使
                final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.appToken);

   //2 封装一个消息，消息体是LaunchActivityItem
                final DisplayContent dc = r.getDisplay().mDisplayContent;
                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                        System.identityHashCode(r), r.info,
                        mergedConfiguration.getGlobalConfiguration(),
                        mergedConfiguration.getOverrideConfiguration(), r.compat,
                        r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
                        r.icicle, r.persistentState, results, newIntents,
                        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
                                r.assistToken));
     //3  发送这个消息,沿着这条路走下去
      mService.getLifecycleManager().scheduleTransaction(clientTransaction);
   ...
  
 }

Back to 5 ActivityTaskManagerService.java

ClientLifecycleManager getLifecycleManager() {
    return mLifecycleManager;
}

10 ClientLifecycleManager.java

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
  //这里的IApplicationThread是ApplicationThread的远程代理，ApplicationThread是ActivityThread的内部类
    transaction.schedule();
}

11 ClientTransaction.java

public void schedule() throws RemoteException {
  //  mClient就是上文说的ApplicationThread
    mClient.scheduleTransaction(this);
}

12 ActivityThread.java

@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    //ActivityThread中并没有这个方法，而是他的父类中的方法
    ActivityThread.this.scheduleTransaction(transaction);
}

13 ClientTransactionHandler.java

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    //既然是发送消息就必然有人接收消息
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

Back to 12 ActivityThread.java

case EXECUTE_TRANSACTION
    ...
    final ClientTransaction transaction = (ClientTransaction) msg.obj;
    mTransactionExecutor.execute(transaction);
    ...
    break;

14 TransactionExecutor.java

public void execute(ClientTransaction transaction) {
    ...
    executeCallbacks(transaction);
    executeLifecycleState(transaction);
    ...
}

public void executeCallbacks(ClientTransaction transaction) {
      for (int i = 0; i < size; ++i) {
         ...
         //这里的Item就是9中的LaunchActivityItem
         final ClientTransactionItem item = callbacks.get(i);
         item.execute(mTransactionHandler, token, mPendingActions);
         item.postExecute(mTransactionHandler, token, mPendingActions);
         ...
      }
}

15 LaunchActivityItem.java

@Override
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    ...
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    ...
}

Back to 12 ActivityThread.java

handleLaunchActivity()-->final Activity a = performLaunchActivity(r, customIntent)-->performLaunchActivity()

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

Back to 3 Instrumentation.java

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

Back to 2 Activity.java

final void performCreate(Bundle icicle) {
    performCreate(icicle, null);
}

 final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
    }