Android源码分析 —— Activity栈管理(基于Android8)

news/2024/3/29 16:49:27/文章来源:https://blog.csdn.net/weixin_43093006/article/details/129210275

0. 写在前面

本文基于 Android8.0源码,和Android9.0大同小异,但和Android10.0差别非常大!新版改用ATM来管理Activity的启动,Activity的生命周期也通过XXXItem来管理。由于我分析的Activity启动流程就是基于Android8/9的,所以本文仍然使用Android8源码来探索 Activity 栈管理。后续有时间再学习整理Android10.0的内容。

1. 前置知识

1.1 Activity栈管理相关类

ActivityStackSupervisor

Activity栈的管理人

ActivityDisplay

表示一个屏幕,Android支持三种屏幕,主屏幕,外接屏幕,虚拟屏幕(投屏)【这个介绍是从其他地方看来的,并不确定】。一般在手机上只有主屏幕,此时ActivityStackSupervisor与ActivityDisplay都是系统唯一的

TaskRecord

是ActivityTask的记录,TaskRecord是Activity栈的重要管理单元。形象一点理解,记得启动模式的 singleTask 吧?意思就是让这个Activity在单独的TaskRecord中启动。“Task":任务。

ActivityRecord

记录着每个Activity的信息,ActivityRecord和Activity一一对应。

ActivityStack

是ActivityRecord和TaskRecord两者的统一上司,记录着ActivityRecord和TaskRecord的状态。

如果在只有主屏幕的设备上,他们之间的关系大概是这样子的:

请添加图片描述

可以理解为一个屏幕上,可能会有很多个APP进程,每个APP进程对应一个ActivityStack,也就是activity栈,其中由于Activity的启动模式不同,又形成了若干个TaskRecord,其中包含着若干个ActivityRecord。

1.2 Activity 的四种启动模式,以及启动标识符

Standard

标准启动模式,启动Activity的时候向发起人的Task顶直接添加即可,返回时依次退出。

SingleTop

栈顶唯一,如果栈顶Activity不是要启动的Activity,则会创建一个新的Activity实例,但如果栈顶Activity就是我们要启动的Activity,就只会调用onNewIntent,而不去再重新创建一个实例。相比Standard,Standard不论如何,都会创建一个新的实例。

SingleTask

栈内唯一。如果发起启动的ActivityRecord所在的TaskRecord中,有要启动的Activity对应的ActivityRecord,则首先将TaskRecord中,目标Activity之上的所有ActivityRecord全都弹出,然后将所在TaskRecord变为ActivityStack的栈顶。

如果发起启动的ActivityRecord所在的TaskRecord中,没有要启动的Activity对应的ActivityRecord,则会在栈顶新建一个TaskRecord,并向其中实例化一个需要启动的Activity对应的ActivityRecord。

SingleInstance

独占一个TaskRecord。启动时,在ActivityStack中查找是否有相同的Activity,如果有,则用这个独占TaskRecord的ActivityRecord对应的Activity。否则新建一个TaskRecord,里面只有它存在。由singleInstance发起的启动,不论是谁,都会在另一个task中启动。

Activity的Flags标志位

  • FLAG_ACTIVITY_NEW_TASK,作用为指定 singleTask 启动模式
  • FLAG_ACTIVITY_SINGLE_TOP,作用为指定 singleTop 启动模式
  • FLAG_ACTIVITY_CLEAR_TOPFLAG_ACTIVITY_NEW_TASK连用,主要用在复用Activity上,在TaskRecord中,复用的ActivityRecord之上的所有AR都要退出
  • FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS,具有这个标志位的Activity将不会出现在历史列表中。

2. 定位到AMS进行栈管理的代码

AMS接收到启动Activity的请求时,将实际Activity的启动任务分配给了ActivityStarter来处理,最后是通过ActivityStarter.startActivityUnchecked()与ActivityStackSupervisor合作完成的Activity栈管理。我们大概的来跟踪一遍这部分代码:

ActivityManagerService

binder通信告知ActivityManagerService需要启动activity。回顾binder通信的知识,需要注意的是 ActivityManagerService 是一个binder实体,是一个服务IActivityManager.Stub,它对外提供的方法都是由IActivityManager接口定义好的,所以我们能看到这些方法上加了 @Override 注解。AMS调用到了startActivity方法:

@Override
public final int startActivity(...) {return startActivityAsUser(...);
}
@Override
public final int startActivityAsUser(...) {//进入到了ActivityStarterreturn mActivityStarter.startActivityMayWait(...);
}

ActivityStarter

在startActivityMayWait()中,对intent做了一些处理,然后逐层调用重载的几个startActivity()方法:

//1.对intent做一些处理
final int startActivityMayWait(){startActivityLocked();
}
//2.继续往里调用
int startActivityLocked(){startActivity();
}
//3.做一些权限判断,在这里,new了一个ActivityRecord,为要启动的activity提前创造好了空壳ActivityRecord
int startActivity(){return startActivity();
}
//4.继续调用
int startActivity(){startActivityUnchecked();
}
//5.来到核心
int startActivityUncheckd(){//这会根据各种启动模式设定,进行activity的启动
}

在具体分析代码之前,我们来看一下startActivityUnchecked()最开头的 computeLaunchingTaskFlags(),看看启动模式标志位的设计,然后再分析后续代码。

private void computeLaunchingTaskFlags() { //mSourceRecord:当前Activity是被它发起启动的//mInTask:所在TaskRecord//mInTask.getStack()为这个TaskRecord所在的ActivityStackif (mSourceRecord == null && mInTask != null && mInTask.getStack() != null) {final Intent baseIntent = mInTask.getBaseIntent();final ActivityRecord root = mInTask.getRootActivity();//一些错误终止if (root == null) {//如果TaskRecord是空的final int flagsOfInterest = FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK| FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_RETAIN_IN_RECENTS;mLaunchFlags = (mLaunchFlags & ~flagsOfInterest)| (baseIntent.getFlags() & flagsOfInterest);//将flags整合起来,放到MIntent中mIntent.setFlags(mLaunchFlags);mInTask.setIntent(mStartActivity);mAddingToTask = true;} else if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {//如果TaskRecord非空,而且标志位为 FLAG_ACTIVITY_NEW_TASK//那么新的ActivityRecord应当在新的TaskRecord中建立,所以mAddingToTask = falsemAddingToTask = false;} else {//如果要在当前的TaskRecord中建立,mAddingToTask = truemAddingToTask = true;}mReuseTask = mInTask;} else {mInTask = null;//如果是这是个起源任务,也就是最初的一个task。换句话说,这个activity是第一个activityif ((mStartActivity.isResolverActivity() || mStartActivity.noDisplay) && mSourceRecord != null&& mSourceRecord.isFreeform())  {mAddingToTask = true;}}//如果这个Activity就是第一个Activityif (mInTask == null) {if (mSourceRecord == null) {//这个activity不可能是被其他activity唤起的,例如app进程启动后的第一个activity。那么他的启动必然是在新的task中的。if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {Slog.w(TAG, "startActivity called from non-Activity context; forcing " +"Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;}} else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {//如果发起者的启动模式是singleInstance,那么由它启动的activity都应当在一个新的TaskRecord中mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;} else if (mLaunchSingleInstance || mLaunchSingleTask) {// 如果要启动的Activity的启动模式是singleInstance或者singleTask,且当前环境下是没有一个所在TaskRecord,那么就应当新建一个Task。mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;}}
}

我们再来看一下 startActivityUnchecked()中,getReusableIntentActivity()是如何获取一个可复用的Activity的:

private ActivityRecord getReusableIntentActivity() {// 新的ActivityRecord是否要放到现存的TaskRecord中呢?根据标志位做一些判断boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&(mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)|| mLaunchSingleInstance || mLaunchSingleTask;putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;//接下来就尝试获取一个目标ActivityActivityRecord intentActivity = null;if (mOptions != null && mOptions.getLaunchTaskId() != -1) {//指定一个TaskRecord,获取这个TaskRecord的顶部Activity来复用,可能是nullfinal TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());intentActivity = task != null ? task.getTopActivity() : null;} else if (putIntoExistingTask) {//如果没有指定,但是确实要放到一个现存的TaskRecord中,就需要看情况了:if (mLaunchSingleInstance) {//1.如果新Activity的启动模式为 singleInstance,那么就要在已存在的所有TaskRecord中,找找它是否存在,如果存在,则复用。(和singleInstance的基础介绍保持一致)intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,mStartActivity.isHomeActivity());} else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {//2.如果启动标志位为:FLAG_ACTIVITY_LAUNCH_ADJACENT,这个比较特殊,是多窗口启动ActivityintentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,!mLaunchSingleTask);} else {// 否则,寻找一个合适的TaskRecord来放入intentActivity = mSupervisor.findTaskLocked(mStartActivity, mSourceDisplayId);}}return intentActivity;
}

3. 根据不同的启动模式,来分析代码逻辑

3.1 Standard

1. standard

普通启动模式,需要注意,如果是第一个Activity,它一定是new_task标志位,也就是即使在xml设置了standard,它也是new_task启动。那么如果一个Activity是以Standard模式启动的,它一定有mSourceRecord,即发起它启动的Activity。

在 startActivityUnchecked() 中一路跳过if()判断,来到这个方法的最后:

private int startActivityUnchecked(){computeLaunchingTaskFlags();//由于找不到一个合适的栈放入,reusedActivity = nullActivityRecord reusedActivity = getReusableIntentActivity();//...跳过了很多不通过的判断语句//1. 如果有可复用的Activity//2. 如果栈顶Activity就是自己//最终来到这里↓//到这里还是standard的启动模式,就一定有sourceActivity,而且这个sourceActivity一定不是singleInstance,否则在修正flag的时候,当前新的activity就被修正为new_task了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 {setTaskToCurrentTopOrCreateNewTask();}if (result != START_SUCCESS) {return result;}
}

我们只截取setTaskFromSourceRecord()核心代码来看:

private int setTaskFromSourceRecord(){//...//最后来到这里:// An existing activity is starting this new activity, so we want to keep the new one in// the same task as the one that is starting it.addOrReparentStartingActivity(sourceTask, "setTaskFromSourceRecord");return START_SUCCESS;
}

然后进入 addOrReparentStartingActivity()

private void addOrReparentStartingActivity(TaskRecord parent, String reason) {if (mStartActivity.getTask() == null || mStartActivity.getTask() == parent) {parent.addActivityToTop(mStartActivity);} else {//会进入到这里mStartActivity.reparent(parent, parent.mActivities.size() /* top */, reason);}
}

最后执行到 TaskRecord.addActivityAtIndex(),最后将新ActivityRecord加到了TaskRecord的mActivities([ActivityRecord集合])中去:mActivities.add(index, r);

到此,standard启动模式,就完成了入栈操作。

2. standard + Intent.FLAG_ACTIVITY_CLEAR_TOP

如果不仅是standard启动模式,还增设了一个启动标识符 Intent.FLAG_ACTIVITY_CLEAR_TOP,如果原先TaskRecord中有它存在,就会进行 singleTask 的任务,具体在 singleTask中谈到实现。

3.2 singleTop

由于singleTop启动模式的Activity也不会得到 reusableIntentActivity,所以会跳过 startActivityUnchecked()的第一个if判断。但它将进入第二个逻辑块:如果当前的activity是栈顶元素,将会复用它。当然,如果栈顶是其他activity,那么当前新activity的启动模式将会和standard一样了。

我们来看一下栈顶就是这个activity的情况,仍然看到ActivityStarter的startActivityUnchecked():

// If the activity being launched is the same as the one currently at the top, then
// we need to check if it should only be launched once.
final ActivityStack topStack = mSupervisor.mFocusedStack;
final ActivityRecord topFocused = topStack.topActivity();
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
//如果当前栈顶activity就是自己的话,就dontStart不用再start了
final boolean dontStart = top != null && mStartActivity.resultTo == null&& top.realActivity.equals(mStartActivity.realActivity)&& top.userId == mStartActivity.userId&& top.app != null && top.app.thread != null&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0|| mLaunchSingleTop || mLaunchSingleTask);
if (dontStart) {//也就是可以直接复用if (mDoResume) {//首先让windowmanager.executeAppTransition()mSupervisor.resumeFocusedStackTopActivityLocked();}//然后直接分发onNewIntent事件deliverNewIntent(top);return START_DELIVERED_TO_TOP;
}

我们来看一下deliverNewIntent()是如何把消息发给activity的:

//ActivityStarter
private void deliverNewIntent(ActivityRecord activity) {if (mIntentDelivered) {return;}ActivityStack.logStartActivity(AM_NEW_INTENT, activity, activity.getTask());//调用到ActivityRecord的deliverNewIntentLocked()activity.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,mStartActivity.launchedFromPackage);mIntentDelivered = true;
}//ActivityRecord
final void deliverNewIntentLocked(){//如果app正常app.thread.scheduleNewIntent(rintent,appToken,state==PAUSED);//如果app异常,将会把rintent记录,未来dump的时候可以获知if(unsent){addNewIntentLocked(rintent);}
}

看到这就很清晰了,就是通过binder通信,告知了app进程,现在需要处理onNewIntent任务。我们顺带简单看一下ActivityThread如何处理applicationThread这个binder实体接收到的newIntent通知:

//ApplicationThread in ActivityThread.java
public final void scheduleNewIntent(List<ReferrerIntent> intents, IBinder token, boolean andPause) {NewIntentData data = new NewIntentData();data.intents = intents;data.token = token;data.andPause = andPause;sendMessage(H.NEW_INTENT, data);
}

接着由mH来handleNewIntent()

case NEW_INTENT:Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");handleNewIntent((NewIntentData)msg.obj);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);break;

handleNewIntent(NewIntentData data)->performNewIntents()

如果这个复用的activity还是resume状态,先让他onPause(),然后再给它发送newIntent,并通知其onResume()

void performNewIntents(IBinder token, List<ReferrerIntent> intents, boolean andPause) {final ActivityClientRecord r = mActivities.get(token);if (r == null) {return;}final boolean resumed = !r.paused;if (resumed) {//如果复用的activity目前还是resume状态,先让他onPausemInstrumentation.callActivityOnPause(r.activity);}deliverNewIntents(r, intents);if (resumed) {r.activity.performResume();r.activity.mTemporaryPause = false;}if (r.paused && andPause) {// In this case the activity was in the paused state when we delivered the intent,// to guarantee onResume gets called after onNewIntent we temporarily resume the// activity and pause again as the caller wanted.performResumeActivity(token, false, "performNewIntents");performPauseActivityIfNeeded(r, "performNewIntents");}
}

其中 deliverNewIntents() 回调了activity的onNewIntent()

private void deliverNewIntents(ActivityClientRecord r, List<ReferrerIntent> intents) {final int N = intents.size();for (int i=0; i<N; i++) {ReferrerIntent intent = intents.get(i);intent.setExtrasClassLoader(r.activity.getClassLoader());intent.prepareToEnterProcess();//通知fragmentsr.activity.mFragments.noteStateNotSaved();//通知onNewIntentmInstrumentation.callActivityOnNewIntent(r.activity, intent);}
}

3.3 singleTask

“栈内唯一”的说法并不合适,实际上是TaskRecord内唯一。根据我画的这张图先来大概理解一下,再进入源码分析:

请添加图片描述

  1. 当前栈结构为最左情况,现在B_Activity要启动A_Activity,我们假定B_Activity的启动模式为standard,A_Activity的启动模式为singleTask
  2. 由于A_Activity的启动模式为singleTask,就需要尝试查找能否复用。
  3. 在ActivityStack中的所有TaskRecord中遍历查找是否存在A_Activity,发现存在于下面这个TaskRecord中。
  4. 先将该TaskRecord中,A_Activity之上其他的ActivityRecord全都弹出
  5. 然后将该TaskRecord浮动转移到所在ActivityStack的最顶端。

即使是C_Activity发起的启动A_Activity,只要ActivityStack中有一个TaskRecord存在A_Activity,就会对这个TaskRecord进行清除内部上方其他ActivityRecord的行为。流程图和上图一模一样,换一种解释,换一种解释说法:

  1. C_Activity的启动模式为 standard,A_Activity的启动模式为 singleTask
  2. 由于A_Activity的启动模式为singleTask,就需要尝试查找能否复用。
  3. 在ActivityStack中的所有TaskRecord中遍历查找是否存在A_Activity,发现存在于下面这个TaskRecord中。
  4. 先将该TaskRecord中,A_Activity之上其他的ActivityRecord全都弹出
  5. 然后将该TaskRecord浮动转移到所在ActivityStack的最顶端。
  6. C_Activity所在的TaskRecord并没有被移除,仅仅是被转移到了ActivityStack的下面而已。

继续分析源码,我们又来到了ActivityStarter的startActivityUnchecked(),首先尝试getReusableIntentActivity() 获取可复用的Activity:

private ActivityRecord getReusableIntentActivity(){boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&(mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)|| mLaunchSingleInstance || mLaunchSingleTask;//true//...else{intentActivity = mSupervisor.findTaskLocked();}return intentActivity;
}

mSupervisor.findTaskLocked()将会遍历所有的TaskRecord,查看是否有目标activity,如果有,则作为intentActivity返回出去,如果没有就是null。这两个情况都需要我们讨论。先来讨论一下有TaskRecord存在这个ActivityRecord的情况:

private int startActivityUnchecked(){//...ActivityRecord reusedActivity = getReusableIntentActivity();//由于找到了一个可复用的activity,进入到下面这个判断体内if(reusedActivity != null){//由于singleTask启动模式,所以会进到下面:if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0|| isDocumentLaunchesIntoExisting(mLaunchFlags)|| mLaunchSingleInstance || mLaunchSingleTask) {//拿到所在的TaskRecordfinal TaskRecord task = reusedActivity.getTask();//将TaskRecord中在它之上的所有ActivityRecord全都移除final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity,mLaunchFlags);if (top != null) {if (top.frontOfTask) {top.getTask().setIntent(mStartActivity);}deliverNewIntent(top);}}//之后,可能需要将这个TaskRecord转移到ActivityStack的顶部,也就是栈顶:内部调整位置的逻辑就不进去看了reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);}
}

接下来的逻辑就是发送newIntent到app进程,如果这个activity之前是pause状态的话,还会performResumeActivity(),在此之前会先行回调onNewIntent()

3.3 singleInstance

它不仅在ActivityStack栈内唯一,而且还独占一个TaskRecord。可以理解为它位分最高。它的代码逻辑很简单了,结合singleTask来看就好了。其他需要注意的地方是,如果由它启动任何一个activity,都将被设置为 flag_activity_new_task模式:

我们又回到ActivityStarter中,看到startActivityUnchecked()的computeLaunchingTaskFlags(),我们只关注singleInstance作为源sourceRecord启动别的activity的情况:

private void computeLaunchingTaskFlags() {//...if (mInTask == null) {if (mSourceRecord == null) {//...} else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {//有源,而且源是 singleInstance 的启动模式//那么不论你之前的flag是什么样的,都会被标记上 flag_activity_new_task!!mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;} else if (mLaunchSingleInstance || mLaunchSingleTask) {mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;}}
}

4. 讨论一下进程第一个Activity在这里的启动是如何表现的

其实我们之前也看了,如果没有源头mSourceRecord,也没有mInTask,这就是第一个activity,那么它的启动标识符就一定会被加上 FLAG_ACTIVITY_NEW_TASK。也就是说,他会是这个APP进程的ActivityStack的第一个TaskRecord的第一个ActivityRecord。

说到这里,我们还需要将它和之前Activity启动流程的步骤做一个整合,我们来分析一下,

我们不应该聚焦在AMS通知application初始化,而应该再往前看一点,从点击桌面图标,到打开APP进程。再点击桌面图标的时候,其实就是startActivity(),这个我们之前讨论的很全面了:

  1. AMS接收到startActivity()的通知,将任务交给了ActivityStarter

  2. ActivityStarter在不断调用startActivity()的过程中,为要启动的Activity创建了一个空壳ActivityRecord

  3. 最后ActivityStarter来到了startActivityUnchecked()由于这个ActivityRecord还没有任何绑定,所以最后进入到了ActivityStackSupervisor.resumeFocusedStackTopActivityLocked()

    boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {if (!readyToResume()) {return false;}//进入到resumeTopActivityUncheckedLocked()if (targetStack != null && isFocusedStack(targetStack)) {return //然后进入到resumeTopActivityInnerLocked()这部分代码特别长,就不贴了,在这里面会调用startSpecificActivityLocked()targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);}return false;
    }
    
  4. ActivityStackSupervisor调用到startSpecificActivityLocked(),会进行一个检查,看看这个activity的app进程是否运行了:

    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.getStack().setLaunchTime(r);//如果这个ActivityRecord的进程已经在运行了,进入这里if (app != null && app.thread != null) {}//如果没有,则先启动进程~//通过AMS的startProcessLocked()来启动进程mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,"activity", r.intent.getComponent(), false, false, true);
    }
    
  5. AMS.startProcessLocked()中间会调用到 Process.start()

    private final void startProcessLocked(...){//...startResult = Process.start(...);
    }
    
  6. 然后就是我们熟悉的zygote.fork()的任务了

然后。我们需要聚焦到AMS在通知完application初始化之后,又通知了ActivityStackSupervisor.attachApplicationLocked(),在这里面进行了栈管理。我们来到ActivityStackSupervisor:

//ActivityStackSupervisor(栈管理者)
//这里的ProcessRecord中管理着整个进程的各种信息,包括运行中的ActivityRecord,以及ServiceRecord、ConnectionRecord、ReceiverList、ContentProvider等各种信息
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {final String processName = app.processName;boolean didSomething = false;//遍历所有屏幕,我们之前谈过安卓设备可能有主屏幕、外界屏幕、虚拟屏幕,一般情况下手机就只有主屏幕。还可能有分屏。for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {//拿到一个屏幕下,所有ActivityStackArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {final ActivityStack stack = stacks.get(stackNdx);//找到当前显示的/持有焦点的ActivityStack//这个activitystack的任务是接收用户输入,或者启动另一个activityif (!isFocusedStack(stack)) {continue;}//获取所有正在运行且可见的activity,放到mTmpActivityList中stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);//获取正在运行的Activity中的最顶端ActivityRecordfinal ActivityRecord top = stack.topRunningActivityLocked();final int size = mTmpActivityList.size();for (int i = 0; i < size; i++) {final ActivityRecord activity = mTmpActivityList.get(i);//这个activity的processRecord为空,但它的processName以及有了,这是app进程初始在某个时候注册的ActivityRecordif (activity.app == null && app.uid == activity.info.applicationInfo.uid&& processName.equals(activity.processName)) {//判断活动的activity的进程是不是和我要启动的activity的进程一致,如果是,就进入到这里面来try {//开启activityif (realStartActivityLocked(activity, app,top == activity /* andResume */, true /* checkConfig */)) {didSomething = true;}} catch (RemoteException e) {Slog.w(TAG, "Exception in new application when starting activity "+ top.intent.getComponent().flattenToShortString(), e);throw e;}}}}}if (!didSomething) {ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);}return didSomething;
}

当前APP的ActivityStack有一个空的ActivityRecord,需要realStartActivityLocked()来真正启动ActivityRecord对应的activity。它这个时候还是个空壳。

进入到realStartActvitiyLocked():

//ActviityStackSupervisor
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,boolean andResume, boolean checkConfig){//这个taskrecord目前只有一个空壳activityRecordfinal TaskRecord task = r.getTask();//这个activityStack目前也只有一个TaskRecord和一个空壳activityrecordfinal ActivityStack stack = task.getStack();r.app = app;//为这个ActivityRecord绑定ProcessRecordint idx = app.activities.indexOf(r);//为ProcessRecord绑定activityRecordif (idx < 0) {app.activities.add(r);}//binder通信,通知app进程,可以启动activity。注意,这里的r是ActivityRecord,这是个空壳,但是到这里,它的意义就是APP进程的第一个activity。app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,...);}

至此,activity启动完成。

总结

从一个LauncherActivity到APP进程的activity,Activity的栈,在其中的工作大致如下:

  1. Activity的启动一般可以通过startActivity()来进行,通过Instrumentation.execStartActivity(),最终会通知到AMS来进行Activity的启动。
  2. AMS通过binder线程获知了需要启动Activity的任务,让ActivityStarter去完成activity的启动。
  3. ActivityStarter在一连串的startActivity()调用过程中,为要启动的Activity创建了一个ActivityRecord。
  4. 最后进入到startActivityUnchecked(),根据Activity的启动模式与启动标识符的不同进行不同的处理。
  5. 如果这个Activity是新进程的Activity,将会通知AMS先进行APP进程的启动,APP进程的application启动完成后,会通知AMS,application初始完成,并将APP进程的binder代理交给AMS,AMS再通过ActivityStartSupervisor来realStartActivityLocked()->app.thread.scheduleLaunchActivity()来通知APP进程,可以启动activity了。
  6. 如果这个Activity是本进程发起的启动,那么就会根据发起者Activity的启动模式以及新Activity的启动模式综合判断,是复用Activity接着调用newIntent()呢,还是新建一个Activity,然后也进入到realStartActivityLocked()->app.thread.scheduleLaunchActivity()来启动新的Activity.

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.luyixian.cn/news_show_74066.aspx

如若内容造成侵权/违法违规/事实不符,请联系dt猫网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

通用信息抽取技术UIE产业案例解析,Prompt 范式落地经验分享!

想了解用户的评价究竟是“真心夸赞”还是“阴阳怪气”&#xff1f;想快速从多角色多事件的繁杂信息中剥茧抽丝提取核心内容&#xff1f;想通过聚合相似事件准确地归纳出特征标签&#xff1f;……想了解UIE技术在产业中的实战落地经验&#xff1f;通用信息抽取技术 UIE 产业案例…

啊哈 算法读书笔记 第 2 章 栈、队列、链表

第 2 章 栈、队列、链表 目录 第 2 章 栈、队列、链表 队列&#xff1a; 解密回文——栈 纸牌游戏&#xff1a; 链表 模拟链表 队列&#xff1a; 首先将第 1 个数删除&#xff0c;紧接着将第 2 个数放到这串数的末尾&#xff0c;再将第 3 个数删除并将第 4 个数放到这串…

Mysql 语句优化 (Explain)

Mysql 语句优化 &#xff08;Explain&#xff09; 1. 概述 ​ 在 select 语句之前增加 explain 关键字&#xff0c; mysql 会在查询上设置一个标记&#xff0c;返回查询执行计划信息&#xff0c;而不是执行这条sql 字段formatjson时的名称含义idselect_id该语句的唯一标识sel…

centos7安装

centos7安装制作U盘启动盘下载镜像下载 UltralISO制作启动盘使用U盘安装系统修改模式为 UEFI调整BOOT option保存重启进入安装界面安装图形界面安装搜狗输入法制作U盘启动盘 下载镜像 去官网下载镜像&#xff0c;找到 mirrors链接&#xff08;速度快&#xff09; 选择一个中…

创客匠人直播:构建公域到私域的用户增长模型

进入知识付费直播带货时代&#xff0c;很多拥有知识技能经验的老师和培训机构吃到了流量红利。通过知识付费直播&#xff0c;老师们可以轻松实现引流、变现&#xff0c;还可以突破时间、地域的限制&#xff0c;为全国各地的学员带来优质的教学服务&#xff0c;因此越来越受到教…

使用JavaScript+Selenium玩转Web应用自动化测试

自动化测试 在软件开发过程中, 测试是功能验收的必要过程, 这个过程往往有测试人员参与, 提前编写测试用例, 然后再手动对测试用例进行测试, 测试用例都通过之后则可以认为该功能通过验收. 但是软件中多个功能之间往往存在关联或依赖关系, 某一个功能的新增或修改可能或影响到…

CTFer成长之路之反序列化漏洞

反序列化漏洞CTF 1.访问url&#xff1a; http://91a5ef16-ff14-4e0d-a687-32bdb4f61ecf.node3.buuoj.cn/ 点击下载源码 本地搭建环境并访问url&#xff1a; http://127.0.0.1/www/public/ 构造payload&#xff1a; ?sindex/index/hello&ethanwhoamiPOST的参数&#…

Redis的持久化方式

Redis支持两种方式的持久化&#xff0c;一种是RDB方式、另一种是AOF&#xff08;append-only-file&#xff09;方式&#xff0c;两种持久化方式可以单独使用其中一种&#xff0c;也可以将这两种方式结合使用。 •RDB&#xff1a;根据指定的规则“定时”将内存中的数据存储在硬…

【Virtualization】Windows11安装VMware Workstation后异常处置

安装环境 Windows 11 专业版 22H2 build 22621.1265 VMware Workstation 17 Pro 17.0.0 build-20800274 存在问题 原因分析 1、BIOS未开启虚拟化。 2、操作系统启用的虚拟化与Workstation冲突。 3、操作系统启用内核隔离-内存完整性保护。 处置思路 1、打开“资源管理器”…

6-Java中新建一个文件、目录、路径

文章目录前言1-文件、目录、路径2-在当前路径下创建一个文件3-在当前路径下创建一个文件夹&#xff08;目录&#xff09;3.1 测试1-路径已经存在3.2 测试2-路径不存在3.2 创建不存在的路径并新建文件3.3 删除已存在的文件并新建4-总结前言 学习Java中如何新建文件、目录、路径…

Fiddler报文分析-断点应用、模拟网络限速-HTTPS的 拦截

目录 一、报文分析 Statistics 请求性能数据 检查器&#xff08;Inspectors&#xff09; 自定义响应&#xff08;AutoResponder&#xff09; Composer Composer的功能就是用来创建HTTP Request然后发送请求。 允许自定义请求发送到服务器&#xff0c;即可以手动创建一个新…

大学毕业后,送了2个月外卖,哭了一整晚

先简单介绍一下自己&#xff0c;我来自湛江&#xff0c;大学学的的物流管理专业&#xff0c;现在就职于一家互联网公司&#xff0c;从事软件测试工作。 我来自湛江的一个偏远农村&#xff0c;家里兄弟姐妹多&#xff0c;父母无力负担我的学费&#xff0c;很多时候学费都是靠姐…

CHATGPT是新的“搜索引擎终结者”吗?百度是否慌了

ChatGPT 以其非凡的自然语言处理 &#xff08;NLP&#xff09; 能力和清晰的响应风靡全球&#xff0c;有望带来一场重大的技术革命。在不知不觉中&#xff0c;叙事转向了ChatGPT与百度的对决&#xff0c;因为来自OpenAI的智能和健谈的聊天机器人已经慢慢获得了“潜在的百度终结…

JS 执行机制 详解(附图)

一、JS是单线程JS语言的一大特点就是单线程&#xff0c;也就是说&#xff0c;同一个时间只能做一件事。这是JS这门脚本语言诞生的使命所致——用来处理页面中用户的交互&#xff0c;以及操作DOM而诞生的。单线程就意味着&#xff0c;所有任务需要排队&#xff0c;前一个任务结束…

自动化测试整理 --- STAF/STAX Robot Framework

题记:上周花了点时间学习开源的自动化测试框架Robot Framework,结合自己之前的自动化经验&#xff0c;就想周末写篇文章整理下。 目前&#xff0c;所在项目的自动化测试框架是基于STAF/STAX的拓展&#xff0c;围绕STAX执行引擎&#xff0c;扩展了测试用例的创建、管理&#xf…

CMake调试器出炉:调试你的CMake脚本

Visual Studio 开发团队一直和 Kitware 紧密合作&#xff0c;致力于开发一个用于调试 CMake 脚本的调试器。 我们将继续这个工作&#xff0c;以便开发人员社区可以通过添加新功能和对其他 DAP 功能的支持来共同改进它。 我们很高兴地宣布&#xff0c;CMake 调试器的预览版现在…

验证功能覆盖率收集时per_instance=1可能导致覆盖率线性增长

验证覆盖率收集时&#xff0c;发现coverage database达到了惊人的256G&#xff0c;如下&#xff1a; 进入database中的testdata目录下的用例定位发现&#xff0c;问题出在这个文件&#xff1a; testbench.inst.xml其大小基本等同于验证用例覆盖率的大小。 这个文件时怎么产…

用数据讲故事:基于分析场景的17条Python使用小结

数据科学的编程需要非常灵活的语言&#xff0c;以最少的代码处理复杂的数据建模场景。作为一名数科小白&#xff0c;我对Python的第一认知是丰富的机器学习算法&#xff0c;但Python有超过12万个第三方库&#xff0c;覆盖从数据预处理、统计分析、数据挖掘及可视化等各种日常数…

Android Studio中创建java工程

1. 前言 电脑环境: Ubuntu 18.04 开发工具环境:Android Studio 4.1.3 版本 经常要使用验证Java API, 把配置环境步骤记录一下 2. 创建步骤 2.1 新建一个Android Studio App工程 New ---> New Project ---> 选择一个Activity主题---> Finish 就创建ok 2.2 …

【模拟集成电路】分频器(DIV_TSPC)设计

分频器&#xff08;DIV_TSPC&#xff09;设计前言一、DIV工作原理二、DIV电路设计&#xff08;1&#xff09;32分频原理图&#xff08;2&#xff09;D触发器原理图&#xff08;3&#xff09;D锁存器原理图&#xff08;4&#xff09;三输入与非门原理图三、DIV仿真测试32分频器测…