Android adj调整 --- computeOomAdjLSP流程详解
- Android adj调整 --- computeOomAdjLSP流程详解
- 1. computeOomAdjLSP的参数
- 2. 是否存在循环计算
- 3. 没有ApplicationThread的时候的调整
- 4. 对ProcessStateRecord进程状态记录的一些初始化
- 5. 设置默认是否允许冻结
- 6. 获取调整之前的一些状态
- 7. system_server或者常驻进程的调整
- 8. 调整之前的一些变量的定义
- 9. top顶端app的调整
- 10. 正在播放远端动画的调整
- 11. instrumentation的调整
- 12. 正在接受广播进程的调整
- 13. 正在运行服务进程的调整
- 14. 系统在休眠时topApp的调整
- 15. 其它app的默认状态初始化
- 16. 更新foregroundActivities和mHasVisibleActivities
- 17. 更新最近使用的activity的状态
- 18. 调整前台服务或者hasOverlayUi的进程
- 19. 调整最近活跃的前台服务进程
- 20. 调整强制提升到用户可感知的进程
- 21. 调整heavy的进程
- 21. 调整桌面应用
- 22. 调整previous上一个使用的应用
- 23. 循环计算时更新procState、adj、schedGroup
- 24. 先更新一下当前计算的值到ProcessStateRecord
- 25. 设置当前adj调整的系列号
- 26. 调整backup备份的应用
- 27. service服务自身和服务依赖关系调整
- 27.1 遍历该进程的服务numberOfRunningServices
- 27.2 根据Services自身的状态进行调整
- 27.3 获取前台服务的能力capabilityFromFGS
- 27.4 遍历每个服务里面的所有链接对象
- 27.5 取出每个服务链接对象
- 27.6 只调整自身是服务，由于客户端的链接的情况
- 27.7 computeClients循环计算时，会先计算客户端的adj
- 27.8 调整前获取客户端的clientAdj和clientProcState
- 27.9 进行没有豁免优先级情况的调整
- 27.10 BIND_WAIVE_PRIORITY == true豁免优先级调整
- 27.11 绑定客户端对象是activity的调整
- 28. provider依赖关系调整
- 29. recent-provider最近使用的provider调整
- 30. 服务相关缓存进程CACHED的调整
- 31. A、B service分布调整
- 32. 更新最新的adj到mCurRawAdj中
- 33. 如果还有未处理完的getMaxAdj进程的调整
- 34. 非唤醒状态时受限制分组SCHED_GROUP_RESTRICTED调整
- 35. 更新进程的能力capability
- 36. 更新最新的状态到ProcessStateRecord，完成本次adj调整
- 37. 本次adj调整的返回值
- 38. 其它相关代码
Android adj调整 — computeOomAdjLSP流程详解
这次就先讲OomAdjuster.java中adj调整最为关键的函数computeOomAdjLSP，这个函数几乎占了adj调整代码1/3的代码量，非常重要，建议阅读之前先看一下之前的：Android S进程的adj值、Android adj调整时的各类进程状态。至于OomAdjuster.java里面的其它逻辑，下次有时间再来写吧。希望对大家有帮助
下面是各个关系对应的表格(以adj为例)
1. computeOomAdjLSP的参数
注意此处上了2把锁mService(ActivityManagerService), ActivityManagerService的mProcLock
@GuardedBy({"mService", "mProcLock"})
private boolean computeOomAdjLSP(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
//调整adj的函数（查看这个函数之前先看一下adj各个值的意思和procState各个值的含义,具体可以参考之前的文章）
//1. app是需要调整adj的进程
//2. cachedAdj是adj调整的时候的默认值(除了一些正在使用的app都是这个默认值)，默认只有一般是oldAdj或则UNKNOWN_ADJ
//3. topApp(当前最顶端activity)是从AMS的getTopApp(这个函数有点性能问题)里面拿到的(这里又是从ActivityTaskManagerService获得)
//updateTopResumedActivityIfNeeded/mRootWindowContainer.getTopDisplayFocusedRootTask/topRootTask.getResumedActivity(ActivityTaskSupervisor)
//-> updateTopApp(ActivityTaskManagerService)，大概是意思是：top的task(writeWmTaskMoved/writeWmTaskToFront)，而且是isTopActivityFocusable和可见shouldBeVisible
//注意顶端activity和顶端Window不是一个概念，如在桌面的时候下拉状态栏，此时顶端activity(topApp)是桌面，而focus Window是systemui
//4. doingAll在这里主要是用于调整A、B service，在updateOomAdjInnerLSP时fullUpdate或者computeClients为true时才有可能设置为true
//而A、B service调整除了doingAll这个参数，还跟cycleReEval有关系，也就是说实际有用到的地方只有fullUpdate为true是才会调整A、B services
//5. now是此次调整adj的当前时间
//6. cycleReEval只有在设置了setContainsCycle true(如正在计算computeOomAdjLSP的时候还没计算完又跑进来，
//如上面的mAdjSeq == state.getAdjSeq()或者(服务/provider的客户端有这种情况的时候))，
//在updateOomAdjInnerLSP会让cycleReEval=true(具体可以看上面的updateOomAdjInnerLSP，大概意思是循环计算依赖)
//7. computeClients是否需要计算当前进程的时候计算服务、provider提供者对端的adj
//8. 它的返回值state.getCurAdj() < prevAppAdj || state.getCurProcState() < prevProcState
// || state.getCurCapability() != prevCapability
//当满足当前调整的mSetAdj(函数结束的时候)比prevAppAdj(刚进入这里mSetAdj)小的时候，或者mCurProcState有变小；这些都代表优先级提升
//或者mCurCapability能力不一样才返回true，其它都是false.
//这个返回值目前只在updateOomAdjInnerLSP中的循环计算adj中使用，用于判断是否需要中断循环调整adj，其它场景都未使用
//只有true才代表循环调整成功，单个进程false代表忽略，只有全部循环调整的进程都是fasle才会跳过循环调整的重试逻辑
2. 是否存在循环计算
设置该进程是循环计算setContainsCycle(true)、将循环计算的进程进程放入mProcessesInCycle
final ProcessStateRecord state = app.mState;
//mAdjSeq在updateOomAdjInnerLSP/performUpdateOomAdjLSP有mAdjSeq++,代表是当前oom_adj调整的序列号
//如果mAdjSeq == getAdjSeq(取得的是正在处理的mAdjSeq值)，代表这个进程已经参与过本次调整
if (mAdjSeq == state.getAdjSeq()) {
//getCompletedAdjSeq是已经完成的adj值
if (state.getAdjSeq() == state.getCompletedAdjSeq()) {
// This adjustment has already been computed successfully.
// 如果该进程调整过了，而且已经完成，则直接返回，同时由于是没有调整，则返回值是false
// 只有true才代表循环调整成功，单个进程false代表忽略，
// 只有全部循环调整的进程都是fasle才会跳过循环调整的重试逻辑
// 返回值只有在重复调整的时候使用,具体请查看updateOomAdjInnerLSP的使用
return false;
} else {
// The process is being computed, so there is a cycle. We cannot
// rely on this process's state.
//由于该进程之前已经计算过，而且adj还在计算值没有计算完，则设置需要adj循环调整的标记位mContainsCycle为true
state.setContainsCycle(true);
//同时将该进程放入循环计算的list里面mProcessesInCycle，后面如果需要重新计算该进程adj的时候会从此处取回
mProcessesInCycle.add(app);
// 返回值只有在重复调整的时候使用,具体请查看updateOomAdjInnerLSP的使用
return false;
}
}
3. 没有ApplicationThread的时候的调整
进程app没有ApplicationThread(应用线程)的时候会进入
//如果app没有ApplicationThread(应用线程)，那么进入这里
if (app.getThread() == null) {
//设置当前进程的adj任务的序列号为mAdjSeq，代表正在调整该进程
state.setAdjSeq(mAdjSeq);
//设置默认cgroup为backgroud
//backgroud分组原生配置了 "HighEnergySaving"(cpuctl或者schedtune),
//"ProcessCapacityLow"(cpuset), "LowIoPriority"(blkio), "TimerSlackHigh"(timerslack_ns)
state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_BACKGROUND);
//设置当前进程状态为PROCESS_STATE_CACHED_EMPTY
state.setCurProcState(PROCESS_STATE_CACHED_EMPTY);
//设置mCurAdj为999，这是oom调整的值；
//而mSetAdj是上一次oom设置过的值（一般用的mSetAdj做为oomadj的判断, setSetAdj设置）
//applyOomAdjLSP中会调用state.setSetAdj(state.getCurAdj());
//将正在调整的mCurAdj更新到mSetAdj，同时修改ProcessList.setOomAdj(更新lmkd中的状态值)
state.setCurAdj(ProcessList.CACHED_APP_MAX_ADJ);
/*
//AndroidS\frameworks\base\services\core\java\com\android\server\am\ProcessServiceRecord.java
int modifyRawOomAdj(int adj) {
if (mHasAboveClient) {
// If this process has bound to any services with BIND_ABOVE_CLIENT,
// then we need to drop its adjustment to be lower than the service's
// in order to honor the request. We want to drop it by one adjustment
// level... but there is special meaning applied to various levels so
// we will skip some of them.
if (adj < ProcessList.FOREGROUND_APP_ADJ) {
// System process will not get dropped, ever
} else if (adj < ProcessList.VISIBLE_APP_ADJ) {
adj = ProcessList.VISIBLE_APP_ADJ;
} else if (adj < ProcessList.PERCEPTIBLE_APP_ADJ) {
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
} else if (adj < ProcessList.PERCEPTIBLE_LOW_APP_ADJ) {
adj = ProcessList.PERCEPTIBLE_LOW_APP_ADJ;
} else if (adj < ProcessList.CACHED_APP_MIN_ADJ) {
adj = ProcessList.CACHED_APP_MIN_ADJ;
} else if (adj < ProcessList.CACHED_APP_MAX_ADJ) {
adj++;
}
}
return adj;
}
state.setCurRawAdj(curEmptyAdj);//mCurRawAdj是直接设置的
state.setCurAdj(psr.modifyRawOomAdj(curEmptyAdj));//类似这里就是约束过的adj在复制给mCurAdj，而且一般都是adj调整完成后设置
*/
//mCurRawAdj是未被约束过的adj，mCurAdj可能由于依赖关系被调整过
//mCurAdj当前调整的adj值，进过约束的(如mHasAboveClient进行约束，client app进程优先级会相应降低)
//mCurRawAdj当前调整的adj值，但是未经过约束
//mSetRawAdj上一次applyOomAdjLSP后设置的mCurRawAdj值
//mSetAdj上一次applyOomAdjLSP后设置的mCurAdj值
state.setCurRawAdj(ProcessList.CACHED_APP_MAX_ADJ);
//设置已经完成了mCompletedAdjSeq为mAdjSeq（代表这个adj调整任务已经完成）
state.setCompletedAdjSeq(state.getAdjSeq());
/*
public static final int PROCESS_CAPABILITY_NONE = 0;
//进程在前台的时候可以访问location
public static final int PROCESS_CAPABILITY_FOREGROUND_LOCATION = 1 << 0;
//进程在前台的时候可以调用camera
public static final int PROCESS_CAPABILITY_FOREGROUND_CAMERA = 1 << 1;
//进程在前台的时候可以调用电话
public static final int PROCESS_CAPABILITY_FOREGROUND_MICROPHONE = 1 << 2;
//即使是功耗优化的限制，这个进程也可以访问网络
//AndroidS\frameworks\base\core\java\android\net\NetworkPolicyManager.java的
//isProcStateAllowedWhileIdleOrPowerSaveMode有下面逻辑
//procState <= FOREGROUND_THRESHOLD_STATE || (capability & ActivityManager.PROCESS_CAPABILITY_NETWORK) != 0
public static final int PROCESS_CAPABILITY_NETWORK = 1 << 3;
*/
//由于这个进程连应用线程都没有，设置该进程没有任何能力
state.setCurCapability(PROCESS_CAPABILITY_NONE);
//同时返回false，这种场景不需要考虑重复计算adj的逻辑
return false;
}
4. 对ProcessStateRecord进程状态记录的一些初始化
/*
public static final int REASON_UNKNOWN = 0;
//这个是在provider依赖关系的时候才调用，代表进程状态改变是由于provider正在使用中导致
public static final int REASON_PROVIDER_IN_USE = 1;
//这个是在service依赖关系的时候才调用，代表进程状态改变是由于service正在使用中导致
public static final int REASON_SERVICE_IN_USE = 2;
*/
//设置adj调整的大概原因，如由于service或者provider的依赖，初始化为未知
state.setAdjTypeCode(ActivityManager.RunningAppProcessInfo.REASON_UNKNOWN);
//设置adj调整时由于客户端clinet或者force-imp时由于什么对象导致进程状态调整
state.setAdjSource(null);
//设置adj调整的对象名字，如由于service或者provider的依赖关系，那么对端的service/provider的名字会被记录在这里
state.setAdjTarget(null);
//目前只有cch-empty && PROCESS_STATE_CACHED_EMPTY才会设置setEmptyd的mEmpty为true，代表空进程
state.setEmpty(false);
//这里设置mCached初始化值为false，用isCached取得mCached来判断是否缓存进程
state.setCached(false);
//设置mAllowStartFgsState(getAllowStartFgsState)为PROCESS_STATE_NONEXISTENT进程不存在
//这个目前只有在"top-activity"、常驻进程、"fg-service"、客户端是常驻进程而且设置了BIND_FOREGROUND_SERVICE、客户端是top才会设置
state.resetAllowStartFgsState();
5. 设置默认是否允许冻结
//cycleReEval只有在设置了setContainsCycle true(如正在计算computeOomAdjLSP的时候还没计算完又跑进来，
//如上面的mAdjSeq == state.getAdjSeq()或者(服务/provider的客户端有这种情况的时候))，
//在updateOomAdjInnerLSP会让cycleReEval=true(具体可以看上面的updateOomAdjInnerLSP，大概意思是循环计算依赖)
if (!cycleReEval) {
//如果是非循环遍历计算，则设置ProcessCachedOptimizerRecord的mShouldNotFreeze，这个用于冻结cached进程，
//在applyOomAdjLSP的updateAppFreezeStateLSP会进行进程冻结，主要有2个操作freezeBinder/setProcessFrozen
// Don't reset this flag when doing cycles re-evaluation.
app.mOptRecord.setShouldNotFreeze(false);
}
6. 获取调整之前的一些状态
//取得app的uid
final int appUid = app.info.uid;
//这个主要是存在OomAdjObserver的时候，发送消息reportOomAdjMessageLocked/onOomAdjMessage，
//如我们需要监控某个应用的adj调整情况，可以使用ActivityManagerShellCommand.java，只是调试功能而已
//adb shell cat /data/system/packages.list可以查看每个进程的uid
//使用方法：adb shell am watch-uids --oom +上面找出的应用的uid
//会输出adj调整日志Slog.d和在终端pw打印相关信息
final int logUid = mService.mCurOomAdjUid;
//获取调整adj前的mCurAdj(当前调整的adj，进过约束的)，保存成prevAppAdj之前的adj状态
int prevAppAdj = state.getCurAdj();
//将之前的进程状态mCurProcState保存成prevProcState
int prevProcState = state.getCurProcState();
//将之前的能力mCurCapability保存成prevCapability
int prevCapability = state.getCurCapability();
//获取ProcessServiceRecord，这个在ActiveServices的realStartServiceLocked会调用ProcessServiceRecord的startService，
//将ServiceRecord加入ProcessServiceRecord的mServices中去，主要保存的是进程服务相关信息
final ProcessServiceRecord psr = app.mServices;
7. system_server或者常驻进程的调整
//getMaxAdj拿到的是mMaxAdj，一般只有系统system_server、常驻进程PERSISTENT或者isolated的app才会设置该值
//而小于等于前台的adj，那么就只有系统system_server、常驻进程PERSISTENT、常驻服务PERSISTENT_SERVICE才会进来
//目前除了测试用例，系统默认的setMaxAdj都是会进来这里的
if (state.getMaxAdj() <= ProcessList.FOREGROUND_APP_ADJ) {
// The max adjustment doesn't allow this app to be anything
// below foreground, so it is not worth doing work for it.
// 可以看到oom的日志一般需要打开DEBUG_OOM_ADJ_REASON或者跟上面调试的logUid一致才会输出
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making fixed: " + app);
}
//设置adj类型为fixed，类似dumpsys activity p中输出的，下面括号部分打印的就是adj类型
//PERS #46: sys F/ /PER LCMN t: 0 1239:system/1000 (fixed)
state.setAdjType("fixed");
//在app中设置当前调整的adj系列为setAdjSeq
state.setAdjSeq(mAdjSeq);
//设置指定的mCurRawAdj(未被约束过的adj)为当前最大的adj
state.setCurRawAdj(state.getMaxAdj());
//暂时初始化，先标定没有前台activity
state.setHasForegroundActivities(false);
//设置当前的cgroup调度分组为SCHED_GROUP_DEFAULT默认，
//对应cgroup分组的SCHED_SP_DEFAULT(task_profiles.json), android默认只在这个分组设置了TimerSlackNormal
//TimerSlackNormal会将/proc/(pid)/timerslack_ns设置成50000ns(0.05ms,内核中断定时器最大的超时时间，
//定时器会在定时时间到超时直接范围内执行,主要为了避免频繁中断引起的性能损耗，类似于对齐)；
//于之对应的设置是TimerSlackHigh，这个android默认设置的是40000000ns=40ms，
//这个时间就很大(对于实际执行的内容会可能wait等待时间较长,导致性能问题)；
//至于其它cgroup分组节点就是默认上一次行为，本次不移动节点(只操作了timerslack_ns)
//cgroup对性能也很重要，但是不是本次重点，先带过
state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_DEFAULT);
//设置该进程拥有所有能力(只有系统system_server、常驻进程PERSISTENT才会进来，所以相对安全)
state.setCurCapability(PROCESS_CAPABILITY_ALL);
//设置当前进程的状态为PROCESS_STATE_PERSISTENT，字符串转换是"PER "
state.setCurProcState(ActivityManager.PROCESS_STATE_PERSISTENT);
// System processes can do UI, and when they do we want to have
// them trim their memory after the user leaves the UI. To
// facilitate this, here we need to determine whether or not it
// is currently showing UI.
//初始化设定当前系统进程没有ui界面
state.setSystemNoUi(true);
//如果调整的是当前应用是最顶端的activity
if (app == topApp) {
//设置这类应用是带有界面的
state.setSystemNoUi(false);
//cgroup分组标记成top app(用户后面分组切换到类似*** cgroup的分组，cpuset的分组如：/dev/cpuset/top-app)
state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_TOP_APP);
//adj类型标记成pers-top-activity
state.setAdjType("pers-top-activity");
//是否有top ui，目前只有systemui才会设置setHasTopUi(通过AMS设置)，如下拉状态栏、灭屏幕时
} else if (state.hasTopUi()) {
// sched group/proc state adjustment is below
//设置这类应用是带有界面的
state.setSystemNoUi(false);
//设置这类应用的类型是"pers-top-ui"
state.setAdjType("pers-top-ui");
//如果是有可见的activity的话
} else if (state.getCachedHasVisibleActivities()) {
//设置这类应用是带有界面的
state.setSystemNoUi(false);
}
//只有带有界面的常驻进程才会进入这里面(如systemui会灭屏幕进入；phone进程灭屏由于isSystemNoUi是true所以不进入)
if (!state.isSystemNoUi()) {
//mWakefulness获取的是当前是否唤醒状态，如亮屏是唤醒状态则是PowerManagerInternal.WAKEFULNESS_AWAKE
//isRunningRemoteAnimation代表是否播放远端动画,如锁屏动画这个也是true
//(如在WAKEFULNESS_DOZING的状态的时候，systemui的isRunningRemoteAnimation也可能是true)
if (mService.mWakefulness.get() == PowerManagerInternal.WAKEFULNESS_AWAKE
|| state.isRunningRemoteAnimation()) {
// screen on or animating, promote UI
//进程状态还是设置成PROCESS_STATE_PERSISTENT_UI ("PERU")
state.setCurProcState(ActivityManager.PROCESS_STATE_PERSISTENT_UI);
//cgroup分组标记成top app
state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_TOP_APP);
} else {
// screen off, restrict UI scheduling
//灭屏没有播放动画才进入这里，如systemui进程状态会从"PERU"切换到"BFGS"
state.setCurProcState(PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
//cgroup分组标记成限制的分组，systemui也会进入这里
state.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_RESTRICTED);
}
}
//设置mCurRawProcState为当前计算的mCurProcState的值，这个值一般都是用于计算client的mCurRawProcState状态
//相当于依赖调整后的状态
state.setCurRawProcState(state.getCurProcState());
//这种进程(系统system_server、常驻进程PERSISTENT)不需要调整adj，直接设置的是传入的max adj
state.setCurAdj(state.getMaxAdj());
//设置当前进程完成调整的adj为mAdjSeq，代表本次adj调整完成
state.setCompletedAdjSeq(state.getAdjSeq());
//更新mAllowStartFgsState，代表是否允许启动前台服务，进程状态需要不比PROCESS_STATE_BOUND_FOREGROUND_SERVICE优先级低
state.bumpAllowStartFgsState(state.getCurProcState());
// if curAdj is less than prevAppAdj, then this process was promoted
//如果当前的adj比上一次调整的adj小、或者当前的进程状态比上一次的优先，则返回true(有效调整)，其它则返回false
return state.getCurAdj() < prevAppAdj || state.getCurProcState() < prevProcState;
}
8. 调整之前的一些变量的定义
//其它的进程先预设拥有界面，初始值
state.setSystemNoUi(false);
//如果当前唤醒状态的话，getTopProcessState返回的是PROCESS_STATE_TOP，否者是PROCESS_STATE_TOP_SLEEPING
//PROCESS_STATE_CUR_TOP定义成final，代表初始化之后就不能改了，仅当次调整有效
final int PROCESS_STATE_CUR_TOP = mService.mAtmInternal.getTopProcessState();
// Determine the importance of the process, starting with most
// important to least, and assign an appropriate OOM adjustment.
//adj是准备进行调整计算进程优先级的临时变量
int adj;
//schedGroup是准备进行调整计算进程cgrup的临时变量
int schedGroup;
//procState是准备进行调整计算进程状态的临时变量
int procState;
//cachedAdjSeq是准备进行调整计算cached adj的临时变量(旧的代码，这个在这里完全没有用到，是个bug，可以提交给google)
int cachedAdjSeq;
//capability是准备进行调整计算进程能力的临时变量
int capability = 0;
//foregroundActivities(是否有前台的activity)默认设定为false
boolean foregroundActivities = false;
//hasVisibleActivities(是否有可见的activity)默认设定为false
boolean hasVisibleActivities = false;
9. top顶端app的调整
//如果当前是唤醒状态(如亮屏)，而且本次调整的进程是topApp(顶端的activity)
//当前是唤醒状态(如亮屏),PROCESS_STATE_CUR_TOP才会是PROCESS_STATE_TOP
if (PROCESS_STATE_CUR_TOP == PROCESS_STATE_TOP && app == topApp) {
// The last app on the list is the foreground app.
//设置adj是0（FOREGROUND_APP_ADJ），一般代表正在运行
adj = ProcessList.FOREGROUND_APP_ADJ;
//进程分组是top app
schedGroup = ProcessList.SCHED_GROUP_TOP_APP;
//进程状态是"top-activity"
state.setAdjType("top-activity");
//拥有前台活动对象
foregroundActivities = true;
//拥有可见的activity
hasVisibleActivities = true;
//当前进程状态是PROCESS_STATE_TOP
procState = PROCESS_STATE_CUR_TOP;
//将是否允许启动forground service的状态设置成PROCESS_STATE_TOP
//进程状态不低于PROCESS_STATE_BOUND_FOREGROUND_SERVICE即可启动前台服务
state.bumpAllowStartFgsState(PROCESS_STATE_TOP);
//打印日志或者在终端中监控某个app的时候会进去
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making top: " + app);
}
10. 正在播放远端动画的调整
//如果正在播放远端动画
} else if (state.isRunningRemoteAnimation()) {
//设置adj为100(VISIBLE_APP_ADJ)
adj = ProcessList.VISIBLE_APP_ADJ;
//进程分组是top app
schedGroup = ProcessList.SCHED_GROUP_TOP_APP;
//进程状态是"running-remote-anim"
state.setAdjType("running-remote-anim");
//当前进程状态是PROCESS_STATE_TOP(设备唤醒时)/PROCESS_STATE_TOP_SLEEPING(休眠时)
procState = PROCESS_STATE_CUR_TOP;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making running remote anim: " + app);
}
11. instrumentation的调整
//如果拥有活跃的instrumentation的时候(如自动化测试，或者qq downloader也会使用类似形式活跃在后台)
} else if (app.getActiveInstrumentation() != null) {
// Don't want to kill running instrumentation.
//设置adj是0（FOREGROUND_APP_ADJ），这种类型也认为是当前运行的进程
adj = ProcessList.FOREGROUND_APP_ADJ;
//进程分组是default默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
//adj类型是"instrumentation");
state.setAdjType("instrumentation");
//进程状态是forground service
procState = PROCESS_STATE_FOREGROUND_SERVICE;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making instrumentation: " + app);
}
12. 正在接受广播进程的调整
//如果正在接受广播
(getCurReceiverAt)或者广播挂起(mPendingBroadcast)马上会接收时
//可以看到广播adj设置优先于服务adj设置
} else if (state.getCachedIsReceivingBroadcast(mTmpBroadcastQueue)) {
// An app that is currently receiving a broadcast also
// counts as being in the foreground for OOM killer purposes.
// It's placed in a sched group based on the nature of the
// broadcast as reflected by which queue it's active in.
// adj = 0，代表正在前台运行中的进程
adj = ProcessList.FOREGROUND_APP_ADJ;
//如果接收的是前台广播队列mFgBroadcastQueue，则分组设置成SCHED_GROUP_DEFAULT，
//否者cgroup分组设置成后台SCHED_GROUP_BACKGROUND
schedGroup = (mTmpBroadcastQueue.contains(mService.mFgBroadcastQueue))
? ProcessList.SCHED_GROUP_DEFAULT : ProcessList.SCHED_GROUP_BACKGROUND;
//设置adj类型为广播"broadcast"
state.setAdjType("broadcast");
//设置当前进程状态是PROCESS_STATE_RECEIVER
procState = ActivityManager.PROCESS_STATE_RECEIVER;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making broadcast: " + app);
}
13. 正在运行服务进程的调整
//如果正在运行服务bumpServiceExecutingLocked(startExecutingService加入运行服务，stopExecutingService移除)
} else if (psr.numberOfExecutingServices() > 0) {
// An app that is currently executing a service callback also
// counts as being in the foreground.
// adj = 0，代表正在前台运行中的进程
adj = ProcessList.FOREGROUND_APP_ADJ;
//如果运行的是前台服务，则分组设置成SCHED_GROUP_DEFAULT，
//否者cgroup分组设置成后台SCHED_GROUP_BACKGROUND
schedGroup = psr.shouldExecServicesFg()
? ProcessList.SCHED_GROUP_DEFAULT : ProcessList.SCHED_GROUP_BACKGROUND;
//设置adj类型为正在运行的服务"exec-service"
state.setAdjType("exec-service");
//设置当前进程状态是PROCESS_STATE_SERVICE
procState = PROCESS_STATE_SERVICE;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making exec-service: " + app);
}
14. 系统在休眠时topApp的调整
//如果调整的是topApp，但是在休眠的时候
} else if (app == topApp) {
//adj也是调整成0
adj = ProcessList.FOREGROUND_APP_ADJ;
//只是cgroup分组设置成后台SCHED_GROUP_BACKGROUND
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
//设置adj类型为顶端，而且休眠状态"top-sleeping"
state.setAdjType("top-sleeping");
//拥有前台活动对象foregroundActivities设置成yrue, 注意此时拥有可见的activity(hasVisibleActivities)并未设置成ture
foregroundActivities = true;
//进程状态设置成PROCESS_STATE_TOP_SLEEPING
procState = PROCESS_STATE_CUR_TOP;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making top (sleeping): " + app);
}
15. 其它app的默认状态初始化
} else {
// As far as we know the process is empty. We may change our mind later.
//cgroup分组设置成后台SCHED_GROUP_BACKGROUND
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
// At this point we don't actually know the adjustment. Use the cached adj
// value that the caller wants us to.
// 其它情况，先设置成cachedAdj(oldAdj或则UNKNOWN_ADJ)，
// 初始化为是空进程adj或者上一次调整的adj值，一会在进行adj调整
adj = cachedAdj;
//进程状态设置成空的缓存进程PROCESS_STATE_CACHED_EMPTY
procState = PROCESS_STATE_CACHED_EMPTY;
//如果不是循环计算，才进入里面
if (!state.containsCycle()) {
//设置成cached缓存进程
state.setCached(true);
//设置成empty空进程
state.setEmpty(true);
//adj类型是空的缓存进程"cch-empty"
state.setAdjType("cch-empty");
}
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Making empty: " + app);
}
}
16. 更新foregroundActivities和mHasVisibleActivities
// Examine all activities if not already foreground.
//foregroundActivities目前只有top app才是true，除了了top它的值都是false
//只要进程有activity(getCachedHasActivities其实是hasActivities)，则getCachedHasActivities返回true
//如realStartActivityLocked(ActivityTaskSupervisor)通过setProcess(ActivityRecord)/addActivityIfNeeded(WindowProcessController)
//将ActivityRecord add进入mActivities，而移除也就是从mActivities移除,
//其中的一种移除情况如：ActivityRecord在destroyImmediately(events出现wm_destroy_activity的时候)
if (!foregroundActivities && state.getCachedHasActivities()) {
//通过activity不同的状态计算其adj，
//PROCESS_STATE_CUR_TOP的值是PROCESS_STATE_TOP(设备唤醒时)/PROCESS_STATE_TOP_SLEEPING(休眠时)
//一般情况procState进程状态越小越优先，adj越小越优先，cgroup分组schedGroup一般越大越优先
//1.如visable可见的activity则会通过onVisibleActivity设置adj最低是VISIBLE_APP_ADJ(其adj通过minLayer/mLayerRank会约束到100-199)
//foregroundActivities和mHasVisibleActivities都是true，procState进程状态设置成小于等于PROCESS_STATE_CUR_TOP
//cgroup分组schedGroup设置成大于等于SCHED_GROUP_DEFAULT()
//2.pausing正在暂停的activity则会通过onPausedActivity设置adj最低是PERCEPTIBLE_APP_ADJ
//foregroundActivities = true和mHasVisibleActivities是false，procState进程状态设置成小于等于PROCESS_STATE_CUR_TOP
//cgroup分组schedGroup设置成大于等于SCHED_GROUP_DEFAULT
//3.stopping正在停止的activity则会通过onStoppingActivity设置adj最低是PERCEPTIBLE_APP_ADJ
//foregroundActivities = true和mHasVisibleActivities是false，
//如果所有activity正在STOPPING都是finishing状态(如wm_finish_activity/wm_destroy_activity)，
//procState进程状态设置成小于等于PROCESS_STATE_LAST_ACTIVITY，schedGroup不变更
//4.其它状态的activity则会通过onOtherActivity，adj不更改
//foregroundActivities不变(默认foregroundActivities是false才会进来)和mHasVisibleActivities是false
//procState进程状态设置成小于等于PROCESS_STATE_CACHED_ACTIVITY,代表缓存的activity
state.computeOomAdjFromActivitiesIfNecessary(mTmpComputeOomAdjWindowCallback,
adj, foregroundActivities, hasVisibleActivities, procState, schedGroup,
appUid, logUid, PROCESS_STATE_CUR_TOP);
//将上面获取的mCachedAdj设置成当前adj
adj = state.getCachedAdj();
//将上面改变ProcessStateRecord的foregroundActivities复制给当前的foregroundActivities变量
foregroundActivities = state.getCachedForegroundActivities();
//将上面改变ProcessStateRecord的mHasVisibleActivities复制给当前的hasVisibleActivities变量
hasVisibleActivities = state.getCachedHasVisibleActivities();
//将上面的procState进程状态保存在当前的procState变量
procState = state.getCachedProcState();
//将上面的cgroup分组schedGroup状态保存在当前的schedGroup变量
schedGroup = state.getCachedSchedGroup();
}
17. 更新最近使用的activity的状态
//有activity在最近任务mRecentTasks,代表最近启动的activity，进程状态设置成小于等于PROCESS_STATE_CACHED_RECENT
if (procState > PROCESS_STATE_CACHED_RECENT && state.getCachedHasRecentTasks()) {
//进程状态最大就是PROCESS_STATE_CACHED_RECENT
procState = PROCESS_STATE_CACHED_RECENT;
//adj类型是cch-rec，缓存的最近任务
state.setAdjType("cch-rec");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise procstate to cached recent: " + app);
}
}
18. 调整前台服务或者hasOverlayUi的进程
//如果当前adj大于200(PERCEPTIBLE_APP_ADJ用户可感知的进程)
//或者当前进程状态大于PROCESS_STATE_FOREGROUND_SERVICE(前台运行的服务)
if (adj > ProcessList.PERCEPTIBLE_APP_ADJ
|| procState > PROCESS_STATE_FOREGROUND_SERVICE) {
//如果其拥有前台服务(通过AMS的updateProcessForegroundLocked设置，
//目前只有updateServiceForegroundLocked(ActiveServices)才可能设置true)
// 一般前台服务带有通知
if (psr.hasForegroundServices()) {
// 将设置成200(PERCEPTIBLE_APP_ADJ)用户可感知的级别
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
// 将进程状态设置成前台服务
procState = PROCESS_STATE_FOREGROUND_SERVICE;
// 设置是否允许启动前台服务，这里是允许的(只要小于等于PROCESS_STATE_BOUND_FOREGROUND_SERVICE都是允许)
state.bumpAllowStartFgsState(PROCESS_STATE_FOREGROUND_SERVICE);
// adj类型是"fg-service"前台服务
state.setAdjType("fg-service");
// 设置成非cached的进程
state.setCached(false);
//此时设置cgroup的分组为默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to " + state.getAdjType() + ": "
+ app + " ");
}
// hasOverlayUi是true的时候(需要设置TYPE_APPLICATION_OVERLAY，有覆盖之上的界面，类似悬浮窗)
} else if (state.hasOverlayUi()) {
// adj设置成用户可感知的优先级200
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
// 将进程状态设置成重要的前台进程
procState = PROCESS_STATE_IMPORTANT_FOREGROUND;
// 设置成非cached的进程
state.setCached(false);
// adj类型是"has-overlay-ui"拥有覆盖界面的进程
state.setAdjType("has-overlay-ui");
//此时设置cgroup的分组为默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to overlay ui: " + app);
}
}
}
19. 调整最近活跃的前台服务进程
// If the app was recently in the foreground and moved to a foreground service status,
// allow it to get a higher rank in memory for some time, compared to other foreground
// services so that it can finish performing any persistence/processing of in-memory state.
//如果有前台服务，而且adj比50(PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ最近使用的前台进程)大；
//而且是最近15s内在top级别(最前台)，或者当前进程状态起码是top
if (psr.hasForegroundServices() && adj > ProcessList.PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ
&& (state.getLastTopTime() + mConstants.TOP_TO_FGS_GRACE_DURATION > now
|| state.getSetProcState() <= PROCESS_STATE_TOP)) {
//将adj设定成50(PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ)，
//代表最近使用过的前台应用(hasForegroundServices最低是200，最近使用过的前台服务最低是50)
adj = ProcessList.PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ;
//设置adj类型为前台服务最近活跃
state.setAdjType("fg-service-act");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to recent fg: " + app);
}
}
20. 调整强制提升到用户可感知的进程
调整通过setProcessImportant来提升优先级的应用
// adj大于200(PERCEPTIBLE_APP_ADJ用户可感知的进程)，或者进程状态大于8(PROCESS_STATE_TRANSIENT_BACKGROUND后台临时状态)
if (adj > ProcessList.PERCEPTIBLE_APP_ADJ
|| procState > PROCESS_STATE_TRANSIENT_BACKGROUND) {
//如果设置了getForcingToImportant不为null（调用AMS的setProcessImportant设置），
//而且adj是用户可感知的PERCEPTIBLE_APP_ADJ，例如toasts是这种情况(NotificationManagerService中调用setProcessImportant)
//如果不想要通知又想提升优先级，setProcessImportant是个不错的选择
if (state.getForcingToImportant() != null) {
// This is currently used for toasts... they are not interactive, and
// we don't want them to cause the app to become fully foreground (and
// thus out of background check), so we yes the best background level we can.
// adj设置成200
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
// 进程状态设置成后台临时状态(PROCESS_STATE_TRANSIENT_BACKGROUND)
procState = PROCESS_STATE_TRANSIENT_BACKGROUND;
// 设置成非cached的进程
state.setCached(false);
// adj类型是"force-imp"强制设置的重要应用
state.setAdjType("force-imp");
// adj改变的原因是ImportanceToken(pid, token, reason)对象，包括提升优先级进程的pid、传递的IBinder对象token，还有原因reason
state.setAdjSource(state.getForcingToImportant());
//此时设置cgroup的分组为默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to force imp: " + app);
}
}
}
21. 调整heavy的进程
//当app无法保存状态，如AndroidManifest.xml设置了"android:cantSaveState="true""，
//同时系统配置了<feature name="android.software.cant_save_state" />这个feature
//由于其无法保存状态，故尽量不要杀死, 一般只有一个，adj类型是"heavy"
if (state.getCachedIsHeavyWeight()) {
//如果adj大于400(HEAVY_WEIGHT_APP_ADJ重要app的优先级)
if (adj > ProcessList.HEAVY_WEIGHT_APP_ADJ) {
// We don't want to kill the current heavy-weight process.
//将adj设置成400
adj = ProcessList.HEAVY_WEIGHT_APP_ADJ;
//不过将cgroup分组设置成后台的
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
// 设置成非cached的进程
state.setCached(false);
// adj类型是"heavy"(由于adj改变设置)
state.setAdjType("heavy");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to heavy: " + app);
}
}
//如果进程状态大于PROCESS_STATE_HEAVY_WEIGHT(重要应用)
if (procState > ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
//将进程状态设置成PROCESS_STATE_HEAVY_WEIGHT(起码是这个进程状态级别，mHeavyWeightProcess的级别不会比这个低)
procState = ActivityManager.PROCESS_STATE_HEAVY_WEIGHT;
// adj类型是"heavy"(由于进程状态改变设置)
state.setAdjType("heavy");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise procstate to heavy: " + app);
}
}
}
21. 调整桌面应用
//如果是桌面应用mHomeProcess
//在ActivityRecord的completeResumeLocked中会将ACTIVITY_TYPE_HOME类型的应用设置成mHomeProcess桌面应用
//(具体ACTIVITY_TYPE_HOME的设置在ActivityRecord的setActivityType)
if (state.getCachedIsHomeProcess()) {
//桌面应用的adj不能小于600(HOME_APP_ADJ)
if (adj > ProcessList.HOME_APP_ADJ) {
// This process is hosting what we currently consider to be the
// home app, so we don't want to let it go into the background.
//adj设置成600，桌面应用有点特殊，经常会返回使用，放在A、B service中间，比上一个应用稍微优先一点
adj = ProcessList.HOME_APP_ADJ;
//将cgroup分组设置成后台的
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
// 设置成非cached的进程
state.setCached(false);
// adj类型是"home"
state.setAdjType("home");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to home: " + app);
}
}
//桌面应用的进程状态不能低于PROCESS_STATE_HOME(14)
if (procState > ActivityManager.PROCESS_STATE_HOME) {
//桌面应用的进程状态设置成PROCESS_STATE_HOME(14)
procState = ActivityManager.PROCESS_STATE_HOME;
// adj类型是"home"
state.setAdjType("home");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise procstate to home: " + app);
}
}
}
22. 调整previous上一个使用的应用
//1. getCachedIsPreviousProcess: 在上一个前台进程activity stop的时候，则会将进程ActivityRecord的app(WindowProcessController)加入到mPreviousProcess，做为上一个进程
//2. getCachedHasActivities:在realStartActivityLocked()的时候将activity add进来，在detachFromProcess或者destroyImmediately()的时候移除activity，
//也就是说是否有启动过但是未destory的activity
if (state.getCachedIsPreviousProcess() && state.getCachedHasActivities()) {
//如果是上一个应用，而且activity没有销毁，那么adj最少设置成700(PREVIOUS_APP_ADJ)
if (adj > ProcessList.PREVIOUS_APP_ADJ) {
// This was the previous process that showed UI to the user.
// We want to try to keep it around more aggressively, to give
// a good experience around switching between two apps.
// adj设置成700
adj = ProcessList.PREVIOUS_APP_ADJ;
//设置cgroup的分组为默认
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
// 设置成非cached的进程
state.setCached(false);
// 设置adj类型为"previous"上一个应用
state.setAdjType("previous");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to prev: " + app);
}
}
//进程状态最少设置成PROCESS_STATE_LAST_ACTIVITY(15)
if (procState > PROCESS_STATE_LAST_ACTIVITY) {
//进程状态设置成PROCESS_STATE_LAST_ACTIVITY(15)
procState = PROCESS_STATE_LAST_ACTIVITY;
// 设置adj类型为"previous"上一个应用
state.setAdjType("previous");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise procstate to prev: " + app);
}
}
}
if (false) Slog.i(TAG, "OOM " + app + ": initial adj=" + adj
+ " reason=" + state.getAdjType());
23. 循环计算时更新procState、adj、schedGroup
循环计算时更新进程状态procState、进程优先级adj、进程分组cgroup信息schedGroup
// By default, we use the computed adjustment. It may be changed if
// there are applications dependent on our services or providers, but
// this gives us a baseline and makes sure we don't get into an
// infinite recursion. If we're re-evaluating due to cycles, use the previously computed
// values.
//cycleReEval只有在设置了setContainsCycle true(如正在计算computeOomAdjLSP的时候还没计算完又跑进来，
//如上面的mAdjSeq == state.getAdjSeq()或者(服务/provider的客户端有这种情况的时候))，
//在updateOomAdjInnerLSP会让cycleReEval=true(具体可以看上面的updateOomAdjInnerLSP，大概意思是循环计算依赖)
//如果是循环计算的话
if (cycleReEval) {
//取之前的进程状态getCurRawProcState和上面计算出来的进程状态procState的最小值，也就是去优先级大的
procState = Math.min(procState, state.getCurRawProcState());
//取之前的进程adj(getCurRawAdj)和上面计算出来的adj的最小值，也就是去优先级大的
adj = Math.min(adj, state.getCurRawAdj());
//cgroup分组也是取小的值
schedGroup = Math.max(schedGroup, state.getCurrentSchedulingGroup());
}
24. 先更新一下当前计算的值到ProcessStateRecord
先更新一下当前计算的值到ProcessStateRecord(进程状态信息记录)
//将当前adj更新到mCurRawAdj
state.setCurRawAdj(adj);
//将当前进程状态procState更新到mCurRawProcState
state.setCurRawProcState(procState);
//先默认该进程没有启动的服务，给初始化值
state.setHasStartedServices(false);
25. 设置当前adj调整的系列号
//到这里我们开始调整adj的值，设置当前进程adj调整的序列是mAdjSeq
state.setAdjSeq(mAdjSeq);
26. 调整backup备份的应用
//获取backup的目标
final BackupRecord backupTarget = mService.mBackupTargets.get(app.userId);
//如果backup app就是当前调整的app
if (backupTarget != null && app == backupTarget.app) {
// If possible we want to avoid killing apps while they're being backed up
//那么adj最小不低于300(BACKUP_APP_ADJ)
if (adj > ProcessList.BACKUP_APP_ADJ) {
if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "oom BACKUP_APP_ADJ for " + app);
//那么adj设置成300(BACKUP_APP_ADJ)
adj = ProcessList.BACKUP_APP_ADJ;
//调整adj值之后，进程状态最低不低于8(TRANSIENT_BACKGROUND)
if (procState > PROCESS_STATE_TRANSIENT_BACKGROUND) {
procState = PROCESS_STATE_TRANSIENT_BACKGROUND;
}
//adj的类型是"backup"
state.setAdjType("backup");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to backup: " + app);
}
// 设置成非cached的进程
state.setCached(false);
}
//进程状态最低不低于9(BACKUP)
if (procState > ActivityManager.PROCESS_STATE_BACKUP) {
//设置进程状态为9(BACKUP)
procState = ActivityManager.PROCESS_STATE_BACKUP;
//adj的类型是"backup"
state.setAdjType("backup");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise procstate to backup: " + app);
}
}
}
27. service服务自身和服务依赖关系调整
27.1 遍历该进程的服务numberOfRunningServices
//用于计算前台服务都拥有哪些能力
int capabilityFromFGS = 0; // capability from foreground service.
//用来用来判断分组是否需要将分组设置成top
boolean scheduleLikeTopApp = false;
//numberOfRunningServices是查看还有多少正在运行的服务(只要startService了就会放入ProcessServiceRecord的mServices中，
//stopService或者kill会从mServices移除)
//而且满足其中之一才会进来：adj需要大于0的才调整，如果是0前台或者常驻进程adj是负数，或者分组是后台，或者进程状态状态大于top
for (int is = psr.numberOfRunningServices() - 1;
is >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
is--) {
//取得保存服务的对象ServiceRecord
ServiceRecord s = psr.getRunningServiceAt(is);
27.2 根据Services自身的状态进行调整
/*
realStartServiceLocked:, ActiveServices (com.android.server.am) //psr.startService将ServiceRecord放入mServices
bringUpServiceLocked:, ActiveServices (com.android.server.am)
startServiceInnerLocked:, ActiveServices (com.android.server.am)//设置startRequested = true
startServiceLocked:, ActiveServices (com.android.server.am)
startService:, ActivityManagerService (com.android.server.am)
*/
//startRequested是在startServiceInnerLocked中设置，在realStartServiceLocked(会将service放入mServices)之前
if (s.startRequested) {
//设置有启动的服务
state.setHasStartedServices(true);
//没有stop的服务的进程，最低进程状态就是10(SERVICE)
if (procState > PROCESS_STATE_SERVICE) {
procState = PROCESS_STATE_SERVICE;
//adj类型是"started-services"
state.setAdjType("started-services");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise procstate to started service: " + app);
}
}
//如果不是config_keep_warming_services(目前这个是空的，也就是mKeepWarming是false)的服务，
//而且hasShownUi是true，且不是桌面
//hasShownUi只要该进程有onStartActivity的操作，就会设置成true，不管activity是否destroy，只要进程还在都是true
if (!s.mKeepWarming && state.hasShownUi() && !state.getCachedIsHomeProcess()) {
// If this process has shown some UI, let it immediately
// go to the LRU list because it may be pretty heavy with
// UI stuff. We'll tag it with a label just to help
// debug and understand what is going on.
//如果adj比500(SERVICE_ADJ)大(adj越大优先级越低)，SERVICE_ADJ是A services
if (adj > ProcessList.SERVICE_ADJ) {
//则将adj类型设置成"cch-started-ui-services缓存的启动了ui的服务
state.setAdjType("cch-started-ui-services");
}
} else {
//mKeepWarming都是false，而且lastActivity服务启动或者bind时间是30分钟以内
//ServiceRecord的lastActivity代表的是上一次该服务
//startServiceInnerLocked/bindServiceLocked/realStartServiceLocked的时间
if (s.mKeepWarming
|| now < (s.lastActivity + mConstants.MAX_SERVICE_INACTIVITY)) {
// This service has seen some activity within
// recent memory, so we will keep its process ahead
// of the background processes.
//如果adj比500(SERVICE_ADJ)大
if (adj > ProcessList.SERVICE_ADJ) {
//则将adj设置成500
adj = ProcessList.SERVICE_ADJ;
//adj类型也是设置成"started-services"
state.setAdjType("started-services");
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise adj to started service: " + app);
}
// 设置成非cached的进程
state.setCached(false);
}
}
// If we have let the service slide into the background
// state, still have some text describing what it is doing
// even though the service no longer has an impact.
//其它情况不调整adj，将adj类型设置成"cch-started-services"
if (adj > ProcessList.SERVICE_ADJ) {
state.setAdjType("cch-started-services");
}
}
}
27.3 获取前台服务的能力capabilityFromFGS
//启动的是前台服务的时候isForeground这个值才是true
if (s.isForeground) {
//foregroundServiceType一般是AndroidManifest中设置，也可以在startForeground的时候传入
//frameworks/base/core/res/res/values/attrs_manifest.xml的foregroundServiceType有各个类型定义
//例如下面前台服务的时候拥有dataSync、mediaPlayback、phoneCall、location、connectedDevice的(mediaProjection/camera/microphone)
//<service android:name="SchedulerService"
// android:foregroundServiceType="dataSync|mediaPlayback|phoneCall|location|connectedDevice">
final int fgsType = s.foregroundServiceType;
//mAllowWhileInUsePermissionInFgs用于是否允许前台服务使用一些权限
if (s.mAllowWhileInUsePermissionInFgs) {
//此时location的权限是否允许取决于foregroundServiceType是否有location权限(GPS、地图、导航)
capabilityFromFGS |=
(fgsType & FOREGROUND_SERVICE_TYPE_LOCATION)
!= 0 ? PROCESS_CAPABILITY_FOREGROUND_LOCATION : 0;
boolean enabled = false;
try {
/*
boolean isEnabled(ApplicationInfo app, AndroidBuildClassifier buildClassifier) {
if (app == null) {
return defaultValue();
}
if (mEvaluatedOverrides.containsKey(app.packageName)) {
return mEvaluatedOverrides.get(app.packageName);
}
if (getDisabled()) {
return false;
}
if (getEnableSinceTargetSdk() != -1) {
// If the change is gated by a platform version newer than the one currently installed
// on the device, disregard the app's target sdk version.
//Google这里的代码也有有点奇怪，app.targetSdkVersion是app的targetSdkVersion，而platformTargetSdk是
//看注释是取最小的做为compareSdk
int compareSdk = Math.min(app.targetSdkVersion, buildClassifier.platformTargetSdk());
//但是这里不等于targetSdkVersion有赋值成targetSdkVersion，那其实是一个意思
if (compareSdk != app.targetSdkVersion) {
compareSdk = app.targetSdkVersion;
}
return compareSdk >= getEnableSinceTargetSdk();
}
return true;
}
*/
//ChangeId(136219221; name=CAMERA_MICROPHONE_CAPABILITY_CHANGE_ID; enableSinceTargetSdk=30)
//获取camera，具体配置是读取/system/etc/compatconfig/services-platform-compat-config.xml进行初始话，这个是在30(android R)之后支持
//isChangeEnabled其实最终调用的是CompatChange的isEnabled，目前只是用apk的targetSdkVersion进行判断，主要大于30就返回true
enabled = getPlatformCompatCache().isChangeEnabled(
CAMERA_MICROPHONE_CAPABILITY_CHANGE_ID, s.appInfo);
} catch (RemoteException e) {
}
//Android S中，如果apk是针对S做的，一般enabled都是true
if (enabled) {
//判断foregroundServiceType是否有"camera"标签，有的话赋予访问camera的权限
capabilityFromFGS |=
(fgsType & FOREGROUND_SERVICE_TYPE_CAMERA)
!= 0 ? PROCESS_CAPABILITY_FOREGROUND_CAMERA : 0;
//判断foregroundServiceType是否有"microphone"标签，有的话赋予访问听筒的权限
capabilityFromFGS |=
(fgsType & FOREGROUND_SERVICE_TYPE_MICROPHONE)
!= 0 ? PROCESS_CAPABILITY_FOREGROUND_MICROPHONE : 0;
} else {
//如果是版本过低，这默认将camera、听筒的权限赋值给前台服务
capabilityFromFGS |= PROCESS_CAPABILITY_FOREGROUND_CAMERA
| PROCESS_CAPABILITY_FOREGROUND_MICROPHONE;
}
}
}
27.4 遍历每个服务里面的所有链接对象
//bindService就会往connections add相关的链接对象，key是IServiceConnection对象
//unbindService移除链接
ArrayMap<IBinder, ArrayList<ConnectionRecord>> serviceConnections = s.getConnections();
//遍历所有的服务，ArrayMap是按照key的hashCode/identityHashCode进行排序的，不是按照add进去的时间进行排序
//这里是从serviceConnections尾部向头部遍历(反过来其实也是一样的，可能是考虑add/remove修改数组大小的时候的健壮性才从尾部开始遍历)
//如果当前进程的adj > 0或者进程分组schedGroup是后台或者进程状态 > top，才进行调整(高优先级的不进行依赖调整，减少调整次数)
for (int conni = serviceConnections.size() - 1;
conni >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
conni--) {
//取出服务连接对象
ArrayList<ConnectionRecord> clist = serviceConnections.valueAt(conni);
27.5 取出每个服务链接对象
//取出每次链接的对象，只要（当前进程的adj > 0或者进程分组schedGroup是后台或者进程状态 > top）是非前台的都进行调整
for (int i = 0;
i < clist.size() && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
i++) {
// XXX should compute this based on the max of
// all connected clients.
//取出每一个ConnectionRecord对象
ConnectionRecord cr = clist.get(i);
27.6 只调整自身是服务，由于客户端的链接的情况
只有服务端的adj，才会由于客户端的adj提升而得到相应的提升
这里就是服务依赖关系调整的开始
//如果服务链接的客户端是当前app，则跳过，客户端的adj不会由于服务端的adj提升而升高
//只有服务端的adj，才会由于客户端的adj提升而得到相应的提升（不然会出现客户端在使用的时候服务端由于优先级低给回收掉了）
if (cr.binding.client == app) {
// Binding to oneself is not interesting.
continue;
}
27.7 computeClients循环计算时，会先计算客户端的adj
//通过mProcessStats.mTrackingAssociations.add(this);将其放入记录ProcessState列表中
//在updateOomAdjInnerLSP的updateTrackingAssociationsLocked会去更新这些add进去的进程状态
//data/system/procstats里面有保存相关数据
boolean trackedProcState = false;
//服务链接中获取绑定的客户端进程
ProcessRecord client = cr.binding.client;
//客户端的进程状态
final ProcessStateRecord cstate = client.mState;
//computeClients是否需要计算当前进程的时候计算服务、provider提供者对端client的adj
if (computeClients) {
//调整之前先计算client的adj，将client按照当前传递计算app的重新计算一次，此处就有可能循环计算，mAdjSeq目前都是一个
computeOomAdjLSP(client, cachedAdj, topApp, doingAll, now,
cycleReEval, true);
} else {
//如果不需要计算客户端的优先级，那么setCurRawAdj先将客户端当前调整的mCurAdj更新到mCurRawAdj中
//mCurAdj当前调整的adj值，进过约束的(如mHasAboveClient进行约束，client app进程优先级会相应降低)
//mCurRawAdj当前调整的adj值，但是未经过约束
//mSetRawAdj上一次applyOomAdjLSP后设置的mCurRawAdj值
//mSetAdj上一次applyOomAdjLSP后设置的mCurAdj值
cstate.setCurRawAdj(cstate.getCurAdj());
//mCurProcState是跑完一次computeOomAdjLSP的出的进程状态结果
//而mCurRawProcState是当前的进程状态，是在计算中的临时结果
//setCurRawProcState将上一次计算的进程状态mCurProcState赋值给mCurRawProcState(临时计算值)
cstate.setCurRawProcState(cstate.getCurProcState());
}
27.8 调整前获取客户端的clientAdj和clientProcState
获取客户端的clientAdj(客户端的adj)和clientProcState(客户端的进程状态procState)
//取得客户端的mCurRawAdj当前调整的adj值(未经过约束)
int clientAdj = cstate.getCurRawAdj();
//取得客户端的临时计算的最新进程状态值mCurRawProcState
int clientProcState = cstate.getCurRawProcState();
//如果进程状态比top还小，代表是起码是常驻进程，clientIsSystem标记为true
final boolean clientIsSystem = clientProcState < PROCESS_STATE_TOP;
//如果客户端mShouldNotFreeze是true，则服务端也被设置不允许冻结。
//（原生冻结有2个条件，一个是adj大于等于900，而且mShouldNotFreeze=false）
if (client.mOptRecord.shouldNotFreeze()) {
// Propagate the shouldNotFreeze flag down the bindings.
app.mOptRecord.setShouldNotFreeze(true);
}
27.9 进行没有豁免优先级情况的调整
//如果当前没有设置豁免绑定的优先级调整，一般没有设置
//则会进入根据客户端的adj去调整服务端的adj
if ((cr.flags & Context.BIND_WAIVE_PRIORITY) == 0) {
27.9.1 循环计算的时候是否需要先跳过本次计算
//判断是是否客户端adj没有计算完成，是否需要跳过本次依赖关系的计算，具体请看shouldSkipDueToCycle的解释
if (shouldSkipDueToCycle(app, cstate, procState, adj, cycleReEval)) {
continue;
}
27.9.2 能力capability初始化
//如果包含BIND_INCLUDE_CAPABILITIES，则会将客户端的能力全部赋值给服务端
if (cr.hasFlag(Context.BIND_INCLUDE_CAPABILITIES)) {
capability |= cstate.getCurCapability();
}
// If an app has network capability by default
// (by having procstate <= BFGS), then the apps it binds to will get
// elevated to a high enough procstate anyway to get network unless they
// request otherwise, so don't propagate the network capability by default
// in this case unless they explicitly request it.
//如果客户端有网络相关的能力
if ((cstate.getCurCapability() & PROCESS_CAPABILITY_NETWORK) != 0) {
//客户端的状态小于等于PROCESS_STATE_BOUND_FOREGROUND_SERVICE
if (clientProcState <= PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
//只有设置了BIND_BYPASS_POWER_NETWORK_RESTRICTIONS(power相关限制都不会阻止服务获取网络权限)
//才会给当前进程(是服务)赋予网络相关的能力
if ((cr.flags & Context.BIND_BYPASS_POWER_NETWORK_RESTRICTIONS)
!= 0) {
capability |= PROCESS_CAPABILITY_NETWORK;
}
} else {
//如果客户端优先级大于等于PROCESS_STATE_FOREGROUND_SERVICE
//则直接赋予当前进程(是服务)网络相关能力
capability |= PROCESS_CAPABILITY_NETWORK;
}
}
27.9.3 低于cached activity的进程状态clientProcState约束
//客户端的进程状态优先级低于cached activity
if (clientProcState >= PROCESS_STATE_CACHED_ACTIVITY) {
// If the other app is cached for any reason, for purposes here
// we are going to consider it empty. The specific cached state
// doesn't propagate except under certain conditions.
//客户端的进程状态优先级低于全部归类为cached empty的进程
clientProcState = PROCESS_STATE_CACHED_EMPTY;
}
27.9.4 如果进程设置了在低内存时托管给系统
如果进程设置了在低内存时托管给系统，就可以减少很多进程依赖关系的调整，
不过目前大部分应用没有使用，而且这里规则也不是很细致
// adjType先初始化为null
String adjType = null;
// 如果服务连接记录设置了BIND_ALLOW_OOM_MANAGEMENT
//这个标记位的意思是允许系统在低内存的时候会删除这个进程，或者服务长时间运行会被杀死和重启
if ((cr.flags&Context.BIND_ALLOW_OOM_MANAGEMENT) != 0) {
// Similar to BIND_WAIVE_PRIORITY, keep it unfrozen.
//如果绑定服务的客户端的adj(clientAdj)，小于900，则服务也不会进行冻结
if (clientAdj < ProcessList.CACHED_APP_MIN_ADJ) {
app.mOptRecord.setShouldNotFreeze(true);
}
// Not doing bind OOM management, so treat
// this guy more like a started service.
//如果当前调整的进程拥有界面(hasShownUi只要该进程有onStartActivity的操作，就会设置成true，不管activity是否destroy，只要进程还在都是true)
//而且不是桌面的情况下
if (state.hasShownUi() && !state.getCachedIsHomeProcess()) {
// If this process has shown some UI, let it immediately
// go to the LRU list because it may be pretty heavy with
// UI stuff. We'll tag it with a label just to help
// debug and understand what is going on.
//如果服务端的adj大于客户端clientAdj，则将adj类型设置成"cch-bound-ui-services"(缓存的拥有ui、被绑定的服务)
if (adj > clientAdj) {
adjType = "cch-bound-ui-services";
}
//设置cached为fasle，代表这个不是cached进程
state.setCached(false);
//将服务的adj赋值给clientAdj，注意一下这里的clientAdj只是用来调整服务端的adj，
//这里的意思是此时将不根据客户端的优先级调整服务端的优先级
//这样可以有效的避免互相依赖关系，这个功能还不错，只是目前大多数服务绑定时没有设置这个TAG
//而且目前该逻辑也相对简单，不太适合统一打开，需要更精细控制
clientAdj = adj;
//将服务的进程状态procState赋值给clientProcState ，跟上面是一个意思，调整adj时忽略客户端的进程状态
clientProcState = procState;
} else {
//针对没有界面服务，或者是桌面
//则看一下s.lastActivity(服务启动或者绑定的时候会设置该时间)
//是否上一次服务启动或者绑定的时间已经超过MAX_SERVICE_INACTIVITY(默认30分钟）
//30分钟以内的话不进入这里，还是会根据客户端的优先级来调整服务端的优先级，
//30分钟以内，相当于没有设置BIND_ALLOW_OOM_MANAGEMENT一样的逻辑
if (now >= (s.lastActivity
+ mConstants.MAX_SERVICE_INACTIVITY)) {
// This service has not seen activity within
// recent memory, so allow it to drop to the
// LRU list if there is no other reason to keep
// it around. We'll also tag it with a label just
// to help debug and undertand what is going on.
//如果是的话，当前服务端的adj小于clientAdj，也就是服务adj优先级没有客户端高
if (adj > clientAdj) {
//那么将adj类型设置成"cch-bound-services"（缓存的绑定服务），代表不通过客户端来调整服务端的adj
adjType = "cch-bound-services";
}
//忽略客户端adj，不管客户端adj的大小，将服务的adj赋值给clientAdj后，都将忽略clientAdj
clientAdj = adj;
}
}
}
27.9.5 如果clientAdj大于当前服务的adj，则开始adj依赖关系调整
//如果客户端的clientAdj小于当前服务的adj，
//那么将会根据客户端的clientAdj进行服务的优先级调整，我们认为这是依赖关系调整即可
if (adj > clientAdj) {
// If this process has recently shown UI, and
// the process that is binding to it is less
// important than being visible, then we don't
// care about the binding as much as we care
// about letting this process get into the LRU
// list to be killed and restarted if needed for
// memory.
//如果当前调整的进程拥有界面(hasShownUi只要该进程有onStartActivity的操作，就会设置成true，不管activity是否destroy，只要进程还在都是true)
//而且不是桌面的情况下，这里逻辑跟上面一样，不过多了一个clientAdj如果是大于用户可感知的200才会进来
//如果clientAdj小于等于200(优先级大于等于用户可感知级别的话)，那就不会进来
if (state.hasShownUi() && !state.getCachedIsHomeProcess()
&& clientAdj > ProcessList.PERCEPTIBLE_APP_ADJ) {
//注意就算是进来，也只进行了一个操作，就是当前进程的adj如果大于等于900
if (adj >= ProcessList.CACHED_APP_MIN_ADJ) {
//则将当前进程的adj类型设置成"cch-bound-ui-services"
adjType = "cch-bound-ui-services";
}
//这里少了对比上面少了state.setCached(false);clientAdj = adj;clientProcState = procState;
//isCached没有直接设置成false，isCached用的地方比较少，主要用在performUpdateOomAdjLSP
//state.setCached(false);
//这个确实没有作用了，目前已经跑完了if (adj > clientAdj)的逻辑，没有用到clientAdj的地方了，
//起码adj暂时不会由于clientAdj去调整
//clientAdj = adj;
//这个不设置是由于后面还需要用到，还会由于客户端的进程状态调整当前进程的进程状态
//clientProcState = procState;
} else {
//其它情况会根据客户端的clientAdj，看情况调整当前进程的adj
int newAdj;
//如果服务链接里面包含BIND_ABOVE_CLIENT或者BIND_IMPORTANT的时候
//BIND_ABOVE_CLIENT: 代表服务的优先级需要比客户端client的高
//BIND_IMPORTANT: 正常情况是就客户端是前台，服务端最多也只是visable，不过设置了这个，
//adj可以到0(fg)或者-700(PERSISTENT_SERVICE)
//StorageUserConnection里面bindServiceAsUser就有设置BIND_IMPORTANT
if ((cr.flags&(Context.BIND_ABOVE_CLIENT
|Context.BIND_IMPORTANT)) != 0) {
//如果客户端的adj大于等于-700，直接将客户端的clientAdj赋值给当前进程的newAdj
if (clientAdj >= ProcessList.PERSISTENT_SERVICE_ADJ) {
newAdj = clientAdj;
} else {
//如果客户端的adj是常驻进程(-800)或者系统(-900)
// make this service persistent
// 直接赋值newAdj为PERSISTENT_SERVICE_ADJ(常驻服务)级别，
//这类进程和常驻进程有区别，不需要开机之前启动，可以动态设置和关闭
newAdj = ProcessList.PERSISTENT_SERVICE_ADJ;
//cgroup分组设置成default，具体之前有解释
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
//进程状态设置成PROCESS_STATE_PERSISTENT
procState = ActivityManager.PROCESS_STATE_PERSISTENT;
//将关联关系记录的信息保存在AssociationState.SourceState中，主要是进程状态，当前调整的序列号和调整时间
cr.trackProcState(procState, mAdjSeq, now);
//标记已经记录过进程状态信息trackedProcState了，后面就不需要再做一次了
trackedProcState = true;
}
//如果服务链接里面包含BIND_NOT_PERCEPTIBLE(服务进程的优先级提升不会高于250)
//clientAdj优先级比200高(或等于PERCEPTIBLE_APP_ADJ),而且当前进程优先级小于250(PERCEPTIBLE_LOW_APP_ADJ)
} else if ((cr.flags & Context.BIND_NOT_PERCEPTIBLE) != 0
&& clientAdj <= ProcessList.PERCEPTIBLE_APP_ADJ
&& adj >= ProcessList.PERCEPTIBLE_LOW_APP_ADJ) {
//则会设置成250(PERCEPTIBLE_LOW_APP_ADJ)
newAdj = ProcessList.PERCEPTIBLE_LOW_APP_ADJ;
//如果设置了BIND_ALMOST_PERCEPTIBLE(接近是perceptible)
//而且客户端clientAdj小于200（优先级大于PERCEPTIBLE_APP_ADJ）
//而且当前进程adj大于等于225（优先级小于等于PERCEPTIBLE_MEDIUM_APP_ADJ 250）
//看逻辑貌似adj == 225的不需要将newAdj赋值成225(没用到)，这里等于还有一个含义，就是进入此处的else，不进行别的else判断
} else if ((cr.flags & Context.BIND_ALMOST_PERCEPTIBLE) != 0
&& clientAdj < ProcessList.PERCEPTIBLE_APP_ADJ
&& adj >= ProcessList.PERCEPTIBLE_MEDIUM_APP_ADJ) {
//newAdj设置成225(PERCEPTIBLE_MEDIUM_APP_ADJ)
newAdj = ProcessList.PERCEPTIBLE_MEDIUM_APP_ADJ;
//如果设置了BIND_NOT_VISIBLE(不要绑定成为visible 100进程)
//而且客户端clientAdj小于200（优先级大于PERCEPTIBLE_APP_ADJ）
//而且当前进程adj大于等于200（优先级小于等于PERCEPTIBLE_APP_ADJ）
} else if ((cr.flags&Context.BIND_NOT_VISIBLE) != 0
&& clientAdj < ProcessList.PERCEPTIBLE_APP_ADJ
&& adj >= ProcessList.PERCEPTIBLE_APP_ADJ) {
//newAdj设置成200(PERCEPTIBLE_APP_ADJ)
newAdj = ProcessList.PERCEPTIBLE_APP_ADJ;
//而且客户端clientAdj大于等于200（优先级小于等于PERCEPTIBLE_APP_ADJ）
} else if (clientAdj >= ProcessList.PERCEPTIBLE_APP_ADJ) {
//newAdj设置成客户端的优先级clientAdj
newAdj = clientAdj;
} else {
//假设你什么都没有设置，而且客户端clientAdj优先级大于200
//（那么客户端就是visible/fg/persistent/system的应用）
//如果应用进程adj优先级小于100(VISIBLE_APP_ADJ)
if (adj > ProcessList.VISIBLE_APP_ADJ) {
// TODO: Is this too limiting for apps bound from TOP?
//则新的adj由于依赖关系，最多设置成visiable级别(100)，此处是[100, 200)
newAdj = Math.max(clientAdj, ProcessList.VISIBLE_APP_ADJ);
} else {
//如果应用进程adj优先级本来就很高，如adj小于等于100，则将当前进程adj赋值给newAdj，不做adj改变
newAdj = adj;
}
}
//只要是客户端不是cached process缓存进程
if (!cstate.isCached()) {
//那么服务端也会设置成非缓存进程
state.setCached(false);
}
//只要当前adj大于新的newAdj(新的adj优先级大于当前adj的优先级)
if (adj > newAdj) {
//将新的优先级newAdj，赋值给当前进程的adj
adj = newAdj;
//将adj保存在未经过约束的mCurRawAdj中，这里保存的是比较新的值
state.setCurRawAdj(adj);
if (DEBUG_OOM_ADJ_REASON) {
//打开DEBUG_OOM_ADJ_REASON会输出adj调整的日志，此处的nowActivityTime表示是否上一次start/bind到现在超过30分钟
boolean nowActivityTime = (now > (s.lastActivity + mConstants.MAX_SERVICE_INACTIVITY));
Slog.d(TAG, "newAdjservice: " + app + ", adj = " + adj + ", client = " + client + ", client.uid = " + client.uid
+", nowActivityTime = " + nowActivityTime + ", state.hasShownUi = " + state.hasShownUi()
+ ", clientProcState =" + clientProcState + ", cr = " + cr);
}
//将adj类型设置成服务
adjType = "service";
}
}
}
27.9.6 clientProcState依赖关系调整
//如果没有设置BIND_NOT_FOREGROUND(非前台绑定)和BIND_IMPORTANT_BACKGROUND(绑定重要后台)的时候
if ((cr.flags & (Context.BIND_NOT_FOREGROUND
| Context.BIND_IMPORTANT_BACKGROUND)) == 0) {
// This will treat important bound services identically to
// the top app, which may behave differently than generic
// foreground work.
//获取客户端cgroup设置的分组信息赋值给curSchedGroup
final int curSchedGroup = cstate.getCurrentSchedulingGroup();
//如果当前curSchedGroup(客户端分组优先级)大于schedGroup(当前进程分组优先级)
if (curSchedGroup > schedGroup) {
//如果设置了BIND_IMPORTANT(重要的绑定)
if ((cr.flags&Context.BIND_IMPORTANT) != 0) {
//则将客户端的cgroup分组优先级设置给当前进程的分组信息
schedGroup = curSchedGroup;
} else {
//如果没有设置，则默认的分组先设置成defalut
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}
//如果客户端进程状态小于top(2)，也就是说客户端是常驻进程
if (clientProcState < PROCESS_STATE_TOP) {
// Special handling for above-top states (persistent
// processes). These should not bring the current process
// into the top state, since they are not on top. Instead
// give them the best bound state after that.
//如有拥有BIND_FOREGROUND_SERVICE(绑定前台服务，一般来自系统的绑定)
if (cr.hasFlag(Context.BIND_FOREGROUND_SERVICE)) {
//客户端的进程状态clientProcState设置成PROCESS_STATE_BOUND_FOREGROUND_SERVICE(5)(绑定了前台进程的服务)
//此处修改clientProcState不会直接修改客户端的进程状态，只是为了后面去修改服务端的进程状态使用
clientProcState = PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
//更新mAllowStartFgsState，最小设置成PROCESS_STATE_BOUND_FOREGROUND_SERVICE
//只要mAllowStartFgsState <= PROCESS_STATE_BOUND_FOREGROUND_SERVICE则有前台服务启动的权限
state.bumpAllowStartFgsState(
PROCESS_STATE_BOUND_FOREGROUND_SERVICE);
//其它情况，mWakefulness是唤醒状态
//而且包含BIND_FOREGROUND_SERVICE_WHILE_AWAKE(在唤醒时绑定前台服务)
} else if (mService.mWakefulness.get()
== PowerManagerInternal.WAKEFULNESS_AWAKE
&& (cr.flags & Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE)
!= 0) {
//将clientProcState设置成PROCESS_STATE_BOUND_FOREGROUND_SERVICE(5)(绑定了前台进程的服务)
clientProcState = PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
} else {
//将clientProcState设置成PROCESS_STATE_IMPORTANT_FOREGROUND(6)(重要的前台，这个进程状态级别不能启动前台服务)
clientProcState =
PROCESS_STATE_IMPORTANT_FOREGROUND;
}
//如果clientProcState是PROCESS_STATE_TOP(2)，当前顶端的Activity(非睡眠状态才会是这个级别)
} else if (clientProcState == PROCESS_STATE_TOP) {
// Go at most to BOUND_TOP, unless requested to elevate
// to client's state.
//后面用来调整当前进程的进程状态的clientProcState设置成PROCESS_STATE_BOUND_TOP(3)(绑定了前台进程)
clientProcState = PROCESS_STATE_BOUND_TOP;
//更新是否运行启动前台服务的进程状态信息mAllowStartFgsState，允许启动前台服务
state.bumpAllowStartFgsState(PROCESS_STATE_BOUND_TOP);
boolean enabled = false;
try {
//" enableAfterTargetSdk="29" id="136274596" name="PROCESS_CAPABILITY_CHANGE_ID",代表mEnableSinceTargetSdk=20
//具体配置是读取/system/etc/compatconfig/services-platform-compat-config.xml进行初始话，这个是在30(android R)之后支持
//isChangeEnabled其实最终调用的是CompatChange的isEnabled，目前只是用apk的targetSdkVersion进行判断，主要大于30就返回true
enabled = getPlatformCompatCache().isChangeEnabled(
PROCESS_CAPABILITY_CHANGE_ID, client.info);
} catch (RemoteException e) {
}
//如果sdk版本支持PROCESS_CAPABILITY_CHANGE_ID(30(android R)之后支持)
if (enabled) {
//如果包含BIND_INCLUDE_CAPABILITIES，则会将客户端的能力全部赋值给服务端
if (cr.hasFlag(Context.BIND_INCLUDE_CAPABILITIES)) {
// TOP process passes all capabilities to the service.
capability |= cstate.getCurCapability();
} else {
//否者不更改进程能力
// TOP process passes no capability to the service.
}
} else {
// TOP process passes all capabilities to the service.
//如果是旧版本sdk的apk，则将客户端的能力直接赋给服务端(也就是旧版本不约束)
capability |= cstate.getCurCapability();
}
}
//如果设置了BIND_NOT_FOREGROUND(非前台绑定)，而且没有设置BIND_IMPORTANT_BACKGROUND(绑定重要后台)的时候
} else if ((cr.flags & Context.BIND_IMPORTANT_BACKGROUND) == 0) {
//客户端进程状态clientProcState如果优先级大于PROCESS_STATE_TRANSIENT_BACKGROUND(8)
if (clientProcState <
PROCESS_STATE_TRANSIENT_BACKGROUND) {
//将clientProcState设置成PROCESS_STATE_TRANSIENT_BACKGROUND(8)
clientProcState =
PROCESS_STATE_TRANSIENT_BACKGROUND;
}
} else {
//如果设置了BIND_IMPORTANT_BACKGROUND(绑定重要后台)的时候
//客户端进程状态小于PROCESS_STATE_IMPORTANT_BACKGROUND(7),也就是起码是IMPORTANT_FOREGROUND(6)
if (clientProcState <
PROCESS_STATE_IMPORTANT_BACKGROUND) {
//将clientProcState设置成PROCESS_STATE_IMPORTANT_BACKGROUND(7)
clientProcState =
PROCESS_STATE_IMPORTANT_BACKGROUND;
}
}
//如果cgroup分组小于top(default/resticted/background)
//而且flag包含了BIND_SCHEDULE_LIKE_TOP_APP(分组就像是top一样)，如IMEs输入法在有界面的情况下
//而且客户端是系统或者常驻进程clientIsSystem=true
if (schedGroup < ProcessList.SCHED_GROUP_TOP_APP
&& (cr.flags & Context.BIND_SCHEDULE_LIKE_TOP_APP) != 0
&& clientIsSystem) {
//将分组信息设置成top app
schedGroup = ProcessList.SCHED_GROUP_TOP_APP;
//标记这种app为scheduleLikeTopApp=true
scheduleLikeTopApp = true;
}
//如果之前没有设置过trackedProcState=true(目前只有persistent service才有设置)
if (!trackedProcState) {
//则将关联关系记录的信息保存在AssociationState.SourceState中，主要是进程状态，当前调整的序列号和调整时间
cr.trackProcState(clientProcState, mAdjSeq, now);
}
//如果当前进程状态procState大于clientProcState(就是没有(准备根据客户端调整的进程状态)clientProcState优先级高)
if (procState > clientProcState) {
//更新当前进程的进程状态procState
procState = clientProcState;
//将procState赋值给mCurRawProcState(临时计算值)
state.setCurRawProcState(procState);
//如果adj类型为空，则赋值adj类型为服务
if (adjType == null) {
adjType = "service";
}
}
//如果进程状态procState小于PROCESS_STATE_IMPORTANT_BACKGROUND(7)，
//而且带有BIND_SHOWING_UI的标签
if (procState < PROCESS_STATE_IMPORTANT_BACKGROUND
&& (cr.flags & Context.BIND_SHOWING_UI) != 0) {
//而且带有BIND_SHOWING_UI的标签，则设置ProcessProfileRecord的mPendingUiClean为true
//mPendingUiClean会在更新内存等级的时候会使用，用户触发thread.scheduleTrimMemory进行应用不同级别的内存回收
app.setPendingUiClean(true);
}
27.9.7 service依赖关系原因的输出
//如果adjType不等与null，则把设置客户端setAdjSource和当前进程setAdjTarget
//如果看到只有"service"没有连接对象，其中一种情况：可能是刚进入computeOomAdjLSP调整清空了之前的对象
if (adjType != null) {
//设置adj类型
state.setAdjType(adjType);
//设置adj类型的代码mAdjTypeCode，和importanceReasonCode类似，就是优先级的原因，此处是service正在使用中
//客户端的进程在importanceReasonPid(getAdjSource)，服务端的进程在importanceReasonComponent(getAdjTarget)
state.setAdjTypeCode(ActivityManager.RunningAppProcessInfo
.REASON_SERVICE_IN_USE);
//cr.binding.client(AppBindRecord)这里是ProcessRecord，setAdjSource设置此次调整的来源：客户端ProcessRecord
state.setAdjSource(cr.binding.client);
//setAdjSourceProcState设置此次调整的进程状态来源：客户端约束后的clientProcState(不高于改值)
state.setAdjSourceProcState(clientProcState);
//setAdjTarget设置调整的原因的服务组件是instanceName(服务组件的实例)
state.setAdjTarget(s.instanceName);
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to " + adjType
+ ": " + app + ", due to " + cr.binding.client
+ " adj=" + adj + " procState="
+ ProcessList.makeProcStateString(procState)+ ", client=" + client
+ ", cr=" + cr);
}
}
27.10 BIND_WAIVE_PRIORITY == true豁免优先级调整
} else {
// 如果设置了BIND_WAIVE_PRIORITY == true，一般没有跑，此处会豁免adj优先级的调整
// BIND_WAIVE_PRIORITY bindings are special when it comes to the
// freezer. Processes bound via WPRI are expected to be running,
// but they are not promoted in the LRU list to keep them out of
// cached. As a result, they can freeze based on oom_adj alone.
// Normally, bindToDeath would fire when a cached app would die
// in the background, but nothing will fire when a running process
// pings a frozen process. Accordingly, any cached app that is
// bound by an unfrozen app via a WPRI binding has to remain
// unfrozen.
//如果客户端是非cached进程，则当前的服务进程不能被冻结
if (clientAdj < ProcessList.CACHED_APP_MIN_ADJ) {
app.mOptRecord.setShouldNotFreeze(true);
}
}
27.11 绑定客户端对象是activity的调整
//链接记录对象cr是ConnectionRecord cr = clist.get(i);如果该链接设置了BIND_TREAT_LIKE_ACTIVITY
if ((cr.flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
//服务端psr则设置setTreatLikeActivity的标记位，需要像对待activity一样对待该服务进程
psr.setTreatLikeActivity(true);
}
//获取绑定客户端对象的activity(只有客户端是activity的时候才有这个对象)
final ActivityServiceConnectionsHolder a = cr.activity;
//如果ConnectionRecord设置了BIND_ADJUST_WITH_ACTIVITY：可以根据客户端activity是否可见来调整优先级
if ((cr.flags&Context.BIND_ADJUST_WITH_ACTIVITY) != 0) {
//如果客户端activity不为null，而且当前服务adj大于0(FOREGROUND_APP_ADJ),
//而且客户端activity是可见的
if (a != null && adj > ProcessList.FOREGROUND_APP_ADJ
&& a.isActivityVisible()) {
//则直接设置服务端adj为0(FOREGROUND_APP_ADJ)
adj = ProcessList.FOREGROUND_APP_ADJ;
//将adj保存在未经过约束的mCurRawAdj中
state.setCurRawAdj(adj);
//如果标签不包含BIND_NOT_FOREGROUND(非前台绑定,不允许上升到前台分组)
if ((cr.flags&Context.BIND_NOT_FOREGROUND) == 0) {
//包含重要绑定BIND_IMPORTANT(对客户端来说非常重要，需要提升到前台)
if ((cr.flags&Context.BIND_IMPORTANT) != 0) {
//则分组cgroup直接设置成top app
schedGroup = ProcessList.SCHED_GROUP_TOP_APP_BOUND;
} else {
//否则分组cgroup设置成默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}
//设置成非cached进程
state.setCached(false);
//adj类型为服务"service"
state.setAdjType("service");
//设置adj类型的代码mAdjTypeCode(和importanceReasonCode类似，就是优先级的原因)为service正在使用中
state.setAdjTypeCode(ActivityManager.RunningAppProcessInfo
.REASON_SERVICE_IN_USE);
//setAdjSource设置此次调整的来源：客户端ActivityServiceConnectionsHolder
state.setAdjSource(a);
//setAdjSourceProcState设置此次调整的进程状态来源：procState(这里已经是调整后的进程状态值)
state.setAdjSourceProcState(procState);
//setAdjTarget设置调整的原因的服务组件是instanceName(服务组件的实例)
state.setAdjTarget(s.instanceName);
//如果打开DEBUG_OOM_ADJ_REASON、或者设置了logUid，则会打印日志
//logUid可以通过直接介绍的adb shell am watch-uids --oom + ***来设置
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
//adj调整的原因是activity
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise to service w/activity: " + app);
}
}
}
}
}
}
到这里就结束了服务依赖调整：当前是服务进程，由于客户端进程的adj和进程状态，进行服务进程的adj和进程状态调整
28. provider依赖关系调整
provider依赖关系调整：当前是provider内容提供者进程，由于客户端进程的adj和进程状态，进行provider进程的adj和进程状态调整
28.1 只有当前是provider内容提供者进程才调整
//接下去就是当前进程的mProviders(provider对象保存信息)的调整，这里逻辑相对少一点
final ProcessProviderRecord ppr = app.mProviders;
//一样是倒叙遍历每一个ContentProviderRecord(单个provider连接信息)
//如果adj大于0(非前台进程)或者分组cgroup是后台(0)或者进程状态小于PROCESS_STATE_TOP(2)满足一个才会进来
for (int provi = ppr.numberOfProviders() - 1;
provi >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
provi--) {
//取出每个保存provider连接信息的ContentProviderRecord对象
//每个包含ActivityManagerService _service（AMS对象）
//ProviderInfo _info(通过PMS的resolveContentProvider获得，provider的info信息)
//ApplicationInfo ai(provider(内容提供者)的Application的信息)
//ComponentName _name(ProviderInfo构建的组件名字)
//boolean _singleton(provider是否singleton单例模式)
ContentProviderRecord cpr = ppr.getProviderAt(provi);
//每一次provider访问调用incProviderCountLocked的时候，
//都会将ContentProviderConnection add到connections里去(cpr.connections.add(conn))
//这里还是和上面一样adj大于0(非前台进程)或者分组cgroup是后台(0)或者进程状态小于PROCESS_STATE_TOP(2)有一个满足才会进来
for (int i = cpr.connections.size() - 1;
i >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
i--) {
//获取ContentProviderConnection，其在ContentProviderHelper创建的时候的变量有
//provider当前provider的ContentProviderRecord
//client客户端调用者的ProcessRecord
//clientPackage调用者的包名(getContentProvider传入的callingPackage)
//mExpectedUserId(默认是调用者的UserId；如果uir的auth有制定uid则用auth的(getUserIdFromAuthority))
//createTime创建new ContentProviderConnection的时间
ContentProviderConnection conn = cpr.connections.get(i);
//client客户端调用者的ProcessRecord
ProcessRecord client = conn.client;
//cstate是客户端进程状态记录信息ProcessStateRecord
final ProcessStateRecord cstate = client.mState;
//如果客户端(查询者)就是当前app，则直接返回。我们只关注提供内容的provider端(内容提供者)
if (client == app) {
// Being our own client is not interesting.
continue;
}
28.2 循环计算computeClients和判断是否需要跳过本次计算shouldSkipDueToCycle
//computeClients是否需要计算当前进程的时候计算服务、provider提供者对端client的adj。和上面服务端计算依赖关系是一样的
if (computeClients) {
//调整之前先计算client的adj，将client按照当前传递计算app的重新计算一次，此处就有可能循环计算，mAdjSeq目前都是一个
computeOomAdjLSP(client, cachedAdj, topApp, doingAll, now, cycleReEval, true);
} else {
//如果不需要计算客户端的优先级，那么setCurRawAdj先将客户端当前调整的mCurAdj更新到mCurRawAdj中
//mCurAdj当前调整的adj值，进过约束的(如mHasAboveClient进行约束，client app进程优先级会相应降低)
//mCurRawAdj当前调整的adj值，但是未经过约束
//mSetRawAdj上一次applyOomAdjLSP后设置的mCurRawAdj值
//mSetAdj上一次applyOomAdjLSP后设置的mCurAdj值
cstate.setCurRawAdj(cstate.getCurAdj());
//mCurProcState是跑完一次computeOomAdjLSP的出的进程状态结果
//而mCurRawProcState是当前的进程状态，是在计算中的临时结果
//setCurRawProcState将上一次计算的进程状态mCurProcState赋值给mCurRawProcState(临时计算值)
cstate.setCurRawProcState(cstate.getCurProcState());
}
//判断是是否客户端adj没有计算完成，是否需要跳过本次依赖关系的计算，具体请看shouldSkipDueToCycle的解释
if (shouldSkipDueToCycle(app, cstate, procState, adj, cycleReEval)) {
continue;
}
28.3 调整前客户端的clientAdj、clientProcState的记录
//取得客户端的mCurRawAdj当前调整的adj值(未经过约束)
int clientAdj = cstate.getCurRawAdj();
//取得客户端的临时计算的最新进程状态值mCurRawProcState
int clientProcState = cstate.getCurRawProcState();
//客户端的进程状态优先级低于cached activity
if (clientProcState >= PROCESS_STATE_CACHED_ACTIVITY) {
// If the other app is cached for any reason, for purposes here
// we are going to consider it empty.
//客户端的进程状态优先级低于全部归类为cached empty的进程
clientProcState = PROCESS_STATE_CACHED_EMPTY;
}
//如果客户端mShouldNotFreeze是true，则服务端也被设置不允许冻结。
//（原生冻结有2个条件，一个是adj大于等于900，而且mShouldNotFreeze=false）
if (client.mOptRecord.shouldNotFreeze()) {
// Propagate the shouldNotFreeze flag down the bindings.
app.mOptRecord.setShouldNotFreeze(true);
}
28.4 clientAdj大于provider的adj才进行adj依赖关系调整
//新建adjType(adj类型)，初始值是null
String adjType = null;
//如果客户端的clientAdj小于provider的adj
//开始针对provider端的进程优先级adj进行依赖调整（主要依据是客户端clientAdj的情况）
if (adj > clientAdj) {
//如果该进程有界面的，而且不是桌面，而且客户端clientAdj大于200，这类不调整adj大小，只设置adj类型
if (state.hasShownUi() && !state.getCachedIsHomeProcess()
&& clientAdj > ProcessList.PERCEPTIBLE_APP_ADJ) {
//则将adj类型设置成"cch-ui-provider"(缓存的带有ui的provider)
adjType = "cch-ui-provider";
} else {
//其它情况，如当前进程没有带界面的、桌面、或者客户端clientAdj小于等于200(PERCEPTIBLE_APP_ADJ用户可感知级别)
//clientAdj如果是大于0(FOREGROUND_APP_ADJ前台adj)，则直接将clientAdj赋值给provider端
//clientAdj如果是小于等于0，则provider端的adj都会设置成0(FOREGROUND_APP_ADJ)
//provider由于依赖关系最高优先级调整到0
adj = clientAdj > ProcessList.FOREGROUND_APP_ADJ
? clientAdj : ProcessList.FOREGROUND_APP_ADJ;
//将adj更新到mCurRawAdj中(mCurRawAdj一般是调整过程中最新的adj值)
state.setCurRawAdj(adj);
//则将adj类型设置成"provider"
adjType = "provider";
}
//只有客户端和provider都是cached的时候才设置当前进程为mCached = true，其它情况都是mCached = false
state.setCached(state.isCached() & cstate.isCached());
}
28.5 clientProcState进程状态依赖调整
//开始针对provider端的进程状态procState进行依赖调整（主要依据是客户端clientProcState的情况）
//只有进程状态clientProcState小于等于PROCESS_STATE_FOREGROUND_SERVICE(4)的时候才进来
if (clientProcState <= PROCESS_STATE_FOREGROUND_SERVICE) {
//只有adj类型是空的时候才进行设置
if (adjType == null) {
//只有adj类型设置成"provider"
adjType = "provider";
}
//客户端的进程状态clientProcState如果是top app(2)
if (clientProcState == PROCESS_STATE_TOP) {
//重新约束clientProcState到PROCESS_STATE_BOUND_TOP(3)
clientProcState = PROCESS_STATE_BOUND_TOP;
} else {
//重新约束clientProcState到PROCESS_STATE_BOUND_FOREGROUND_SERVICE(5)，这个状态刚好是可以启动前台服务的状态
clientProcState = PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
}
}
//调整之前，先保存关联关系记录的信息在AssociationState.SourceState中
//主要是进程状态，当前调整的序列号和调整时间
conn.trackProcState(clientProcState, mAdjSeq, now);
//只有当前进程的进程状态procState大于约束后的客户端clientProcState的进程状态时
if (procState > clientProcState) {
//才将约束后的客户端clientProcState赋值给当前进程的进程状态procState
procState = clientProcState;
//setCurRawProcState将procState赋值给mCurRawProcState(最新的计算值，可能不是最终的值)
state.setCurRawProcState(procState);
}
28.6 客户端分组依赖关系调整
//如果客户端的分组大于当前进程的schedGroup(computeOomAdjLSP默认初始化之后最低是SCHED_GROUP_BACKGROUND(1))
//也就是客户端分组起码是SCHED_GROUP_DEFAULT(2)
if (cstate.getCurrentSchedulingGroup() > schedGroup) {
//设置当前分组schedGroup为SCHED_GROUP_DEFAULT
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
28.7 输出provider调整的原因
//如果adj类型不为空，那么代表根据客户端，当前进程调整过adj或者进程状态procState
if (adjType != null) {
//设置adj类型
state.setAdjType(adjType);
//设置adj类型的代码mAdjTypeCode(和importanceReasonCode类似，就是优先级的原因)为provider正在使用中
state.setAdjTypeCode(ActivityManager.RunningAppProcessInfo
.REASON_PROVIDER_IN_USE);
//setAdjSource设置此次调整的来源：客户端ProcessRecord
state.setAdjSource(client);
//setAdjSourceProcState设置此次调整的进程状态来源：客户端约束后的clientProcState(不高于改值)
state.setAdjSourceProcState(clientProcState);
//setAdjTarget设置调整的原因的provider组件是ComponentName name(ProviderInfo构建的组件名字)
state.setAdjTarget(cpr.name);
//打印日志由于什么原因去调整该进程的adj或者进程状态
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to " + adjType
+ ": " + app + ", due to " + client
+ " adj=" + adj + " procState="
+ ProcessList.makeProcStateString(procState)
+ ", target=" + cpr.name );
}
}
}
28.8 hasExternalProcessHandles的调整
// If the provider has external (non-framework) process
// dependencies, ensure that its adjustment is at least
// FOREGROUND_APP_ADJ.
//cpr.hasExternalProcessHandles为true时，adj类型是"ext-provider"
//通过调用getContentProviderExternalUnchecked/getContentProviderExternal来设置hasExternalProcessHandles
//具体流程getContentProviderExternal->getContentProviderExternalUnchecked->getContentProviderImpl(caller == null)
//->incProviderCountLocked(r == null)->addExternalProcessHandleLocked->externalProcessTokenToHandle
if (cpr.hasExternalProcessHandles()) {
//如果当前adj大于0前台，则设置成0
if (adj > ProcessList.FOREGROUND_APP_ADJ) {
//adj设置成0(FOREGROUND_APP_ADJ),这种优先级比较高
//一般用在cmd、uiautomator
adj = ProcessList.FOREGROUND_APP_ADJ;
//更新adj到mCurRawAdj中
state.setCurRawAdj(adj);
//分组设置成默认
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
//非cached进程
state.setCached(false);
//adj类型是"ext-provider"
state.setAdjType("ext-provider");
//setAdjTarget设置调整的原因的provider组件是ComponentName name(ProviderInfo构建的组件名字)
state.setAdjTarget(cpr.name);
//打印日志，调整adj的原因是由于external provider
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise adj to external provider: " + app);
}
}
//如果当前进程状态procState大于PROCESS_STATE_IMPORTANT_FOREGROUND(6)
if (procState > PROCESS_STATE_IMPORTANT_FOREGROUND) {
//则将进程状态procState设置成PROCESS_STATE_IMPORTANT_FOREGROUND(这个级别不能启动前台服务)
procState = PROCESS_STATE_IMPORTANT_FOREGROUND;
//更新进程状态procState到mCurRawProcState
state.setCurRawProcState(procState);
//打印日志，调整进程状态procState的原因是由于external provider
//(这里adj和进程状态的调整都有输出日志，看起来比上面的adjType会更清晰一点，
//如果需要修改类似日志，建议参考这里adj和procState单独输出)
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise procstate to external provider: " + app);
}
}
}
}
29. recent-provider最近使用的provider调整
//getLastProviderTime(mLastProviderTime)在removeContentProvider/decProviderCountLocked/handleProviderRemoval
//当客户端释放provider而且客户端进程状态比PROCESS_STATE_LAST_ACTIVITY(15)小，则会设置mLastProviderTime
//大概意思是provider上一次使用的时间，设置了这个时间的话provider会延迟一小会释放，
//一般只在比last activity重要的进程状态(客户端的)时设置
//CONTENT_PROVIDER_RETAIN_TIME是20s，上一次使用在20s以内会进来这里，避免低内存状态下频繁启动回收provider进程
if (ppr.getLastProviderTime() > 0
&& (ppr.getLastProviderTime() + mConstants.CONTENT_PROVIDER_RETAIN_TIME) > now) {
//如果adj大于700(PREVIOUS_APP_ADJ上一个应用)
if (adj > ProcessList.PREVIOUS_APP_ADJ) {
//则将adj设置成700(就是dumpsys meminfo里面的Previous应用)
adj = ProcessList.PREVIOUS_APP_ADJ;
//设置分组为后台，这里是后台，不是前台和default
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
//非cached进程
state.setCached(false);
//adj类型是"recent-provider"最近使用的provider
state.setAdjType("recent-provider");
//输出调整adj的原因
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise adj to recent provider: " + app);
}
}
//进程状态procState如果大于PROCESS_STATE_LAST_ACTIVITY(15)
if (procState > PROCESS_STATE_LAST_ACTIVITY) {
//则将procState设置成PROCESS_STATE_LAST_ACTIVITY(15)
procState = PROCESS_STATE_LAST_ACTIVITY;
//将adj类型设置成"recent-provider"，注意只要有adj或者procState的提升都会重新设置adj类型为"recent-provider"
state.setAdjType("recent-provider");
//输出调整procstate的原因
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise procstate to recent provider: " + app);
}
}
}
30. 服务相关缓存进程CACHED的调整
//如果进程状态procState大于等于PROCESS_STATE_CACHED_EMPTY(19,这个优先级比较低)
if (procState >= PROCESS_STATE_CACHED_EMPTY) {
//看一下客户端是否有activity
if (psr.hasClientActivities()) {
// This is a cached process, but with client activities. Mark it so.
//看一下客户端是否有activity，如果有，则稍微提升一下进程状态的级别到PROCESS_STATE_CACHED_ACTIVITY_CLIENT(17)
procState = PROCESS_STATE_CACHED_ACTIVITY_CLIENT;
//设置adj类型是"cch-client-act"
state.setAdjType("cch-client-act");
//服务端psr是ProcessServiceRecord进程的服务信息记录对象app.mServices
//如果设置了mTreatLikeActivity为true(setTreatLikeActivity设置)，则就像对待activity一样对待这个进程
//adj类型设置成"cch-as-act"(as "cch-act")
} else if (psr.isTreatedLikeActivity()) {
// This is a cached process, but somebody wants us to treat it like it has
// an activity, okay!
//也是稍微提升一下进程状态的级别到PROCESS_STATE_CACHED_ACTIVITY(16)
//注意这里的优先级(值越低优先级越高)比上面17还高，但是是放在else里面，貌似不太合理，一般都是优先级高的在前面，
//不然如果同时满足hasClientActivities和isTreatedLikeActivity，那么就只能设置成17，而不是16
procState = PROCESS_STATE_CACHED_ACTIVITY;
//adj类型设置成"cch-as-act"(
state.setAdjType("cch-as-act");
}
}
31. A、B service分布调整
//如果adj是SERVICE_ADJ(500),具体可以看上面adj = ProcessList.SERVICE_ADJ;的逻辑
//只有上一次lastActivity服务启动或者bind时间是30分钟以内的才会设置成SERVICE_ADJ级别
//这段逻辑一直都没有变化，那么为啥Android O以前的版本那么多A、B services扎堆？现在S不见了
//其实不是这段逻辑有变化，而是google限制了后台进程启动服务的权限，没有启动服务的权限，那么服务就少了
//google针对后台乱象随着OS的升级逐渐砍，不够道高一尺魔高一丈，还是有很多办法绕过去的不是吗？
if (adj == ProcessList.SERVICE_ADJ) {
//在doingAll为true，而且cycleReEval循环计算为false，代表需要更新A/B services
//目前满足这个条件的只有updateOomAdjInnerLSP中fullUpdate为true的时候进来时
if (doingAll && !cycleReEval) {
//如果mNewNumAServiceProcs(A services的个数，一会下面会设置)个数大于mNumServiceProcs(上一次fullUpdate后总的服务个数)/3
//则将mServiceB设置为true，代表这个是b services
//也就是1/3的服务会被设置成B services
//从这里也可以看到其实服务的优先级还跟mLruProcesses中进程的位置index有关系，这个后面另外的文章来写吧
state.setServiceB(mNewNumAServiceProcs > (mNumServiceProcs / 3);
//mNewNumServiceProcs(fullUpdate更新所有进程中service的个数，调整完成后，会更新到mNumServiceProcs中)
mNewNumServiceProcs++;
//如果排在1/3之前的服务，也就是可能会调整成A services的进程
if (!state.isServiceB()) {
// This service isn't far enough down on the LRU list to
// normally be a B service, but if we are low on RAM and it
// is large we want to force it down since we would prefer to
// keep launcher over it.
//isLastMemoryLevelNormal获取是内存压力级别，目前用的是psi，psi不太准确，下次有时间讲到AppProfiler时再来讲
//mLastMemoryLevel只要不是(ADJ_MEM_FACTOR_NOTHING刚初始化，还没内存压力时；或者ADJ_MEM_FACTOR_NORMAL内存压力正常)
//则isLastMemoryLevelNormal返回false，代表此时有内存压力
//getLastPss获取的是AppProfiler中recordPssSampleLPf->setLastPss设置进去的mLastPss,
//android本身有一个pss收集的进程在，
//getCachedRestoreThresholdKb，如果是32bit是184320/3 = 60M, 64bit是322560/3=105M，具体逻辑在ProcessList.java中
//也就是进程的mLastPss大于60M(32bit)/105M(64bit),
//而且是有内存压力的时候会将这类服务标记成高内存用量，而且回落到B services
/*
//ProcessList.java
private final int[] mOomMinFreeLow = new int[] {
12288, 18432, 24576,
36864, 43008, 49152
};
private final int[] mOomMinFreeHigh = new int[] {
73728, 92160, 110592,
129024, 147456, 184320
};
for (int i = 0; i < mOomAdj.length; i++) {
int low = mOomMinFreeLow[i];//12288, 18432, 24576, 36864, 43008, 49152
int high = mOomMinFreeHigh[i];//73728, 92160, 110592,129024, 147456, 184320
if (is64bit) {
// Increase the high min-free levels for cached processes for 64-bit
if (i == 4) high = (high * 3) / 2;//221184
else if (i == 5) high = (high * 7) / 4;//322560
}
mOomMinFree[i] = (int)(low + ((high - low) * scale));//high，目前S上由于RAM大于1G，scale都是1
}
*/
//mLastPss值的更新，一般在亮灭屏: 如果是内存状态有变小，是5分钟更新，没有变小是20分钟更新
//其它场景如开机、更新全部的procStats(3个小时以上)时也会触发mLastPss的更新
if (!mService.mAppProfiler.isLastMemoryLevelNormal()
&& app.mProfile.getLastPss()
>= mProcessList.getCachedRestoreThresholdKb()) {
//设置该服务为高内存用量的服务，mServiceHighRam=true，isServiceHighRam提供给外部用，
//不够目前S都没有用到，Android这里也有另一个缺陷(高内存用量的进程没有单独划分出来)，
//这个功能其实挺好的，不过竟然没有大批量用起来！
state.setServiceHighRam(true);
//回落到B service级别
state.setServiceB(true);
//这个注释其实没有必要注掉，可以用DEBUG_PSS、DEBUG_OOM_ADJ_REASON都是可以的
//Slog.i(TAG, "ADJ " + app + " high ram!");
} else {
//回落到B service级别
mNewNumAServiceProcs++;
//Slog.i(TAG, "ADJ " + app + " not high ram!");
}
} else {
//其它情况下(b services)都认为不是高内存的服务(这个逻辑不敢恭维，牛头不对马尾)
state.setServiceHighRam(false);
}
}
//如果是b services的话
if (state.isServiceB()) {
//则将adj设置成SERVICE_B_ADJ(800)
adj = ProcessList.SERVICE_B_ADJ;
}
}
32. 更新最新的adj到mCurRawAdj中
//更新最新的adj到mCurRawAdj中
state.setCurRawAdj(adj);
33. 如果还有未处理完的getMaxAdj进程的调整
//如果当前adj大于setMaxAdj中设置的值(除了测试用例才会进来，Android S这段代码专门为测试用例留的？)
//注意了这里是没有调用setCurRawAdj更新mCurRawAdj，故进入这里的话mCurRawAdj可能不是最新调整的状态，看起来属于一个漏洞？
if (adj > state.getMaxAdj()) {
//adj则更新成setMaxAdj中设置的值
adj = state.getMaxAdj();
//如果adj小于等于250(PERCEPTIBLE_LOW_APP_ADJ用户可感知的最低级别)
if (adj <= ProcessList.PERCEPTIBLE_LOW_APP_ADJ) {
//则分组cgroup更新成默认分组
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}
34. 非唤醒状态时受限制分组SCHED_GROUP_RESTRICTED调整
// Put bound foreground services in a special sched group for additional
// restrictions on screen off
//如果进程状态procState大于等于PROCESS_STATE_BOUND_FOREGROUND_SERVICE(5)
//而且在灭屏状态，而且scheduleLikeTopApp(设定像对待前台一样对待该app，类似IMEs有界面时)是false
if (procState >= PROCESS_STATE_BOUND_FOREGROUND_SERVICE
&& mService.mWakefulness.get() != PowerManagerInternal.WAKEFULNESS_AWAKE
&& !scheduleLikeTopApp) {
//分组cgroup状态大于SCHED_GROUP_RESTRICTED(1)，那就是default、top的时候
if (schedGroup > ProcessList.SCHED_GROUP_RESTRICTED) {
//设置他们的分组状态都是SCHED_GROUP_RESTRICTED受限制分组
schedGroup = ProcessList.SCHED_GROUP_RESTRICTED;
}
}
35. 更新进程的能力capability
// apply capability from FGS.
//如果有前台服务(ContextImpl启动前台服务或者service启动时设置服务是前台的)
if (psr.hasForegroundServices()) {
//则将当前进程的能力capability设置成前台服务的能力capabilityFromFGS(具体请查看之前的介绍)
capability |= capabilityFromFGS;
}
//通过进程的服务记录psr和进程状态procState得到默认的能力
capability |= getDefaultCapability(psr, procState);
36. 更新最新的状态到ProcessStateRecord，完成本次adj调整
// Do final modification to adj. Everything we do between here and applying
// the final setAdj must be done in this function, because we will also use
// it when computing the final cached adj later. Note that we don't need to
// worry about this for max adj above, since max adj will always be used to
// keep it out of the cached vaues.
//本次adj调整即将完成，将计算的adj复制给mCurAdj
state.setCurAdj(psr.modifyRawOomAdj(adj));
//本次adj调整即将完成，将计算的能力capability复制给mCurCapability
state.setCurCapability(capability);
//本次adj调整即将完成，将计算的分组信息schedGroup复制给mCurSchedGroup
state.setCurrentSchedulingGroup(schedGroup);
//本次adj调整即将完成，将计算的进程状态procState复制给mCurProcState
state.setCurProcState(procState);
//本次adj调整即将完成，将计算的进程状态procState复制给mCurRawProcState
state.setCurRawProcState(procState);
//通过hasVisibleActivities更新mLastInvisibleTime，如果mHasVisibleActivities从true变成false，
//则记录这个时候的时间，相当于当进程从可见到不可见的时间
//主要用在是否允许启动前台服务里面，这个时间目前是mFgToBgFgsGraceDuration(5秒钟以内还是允许的)
state.updateLastInvisibleTime(hasVisibleActivities);
//更新mHasForegroundActivities是否拥有前台activity
state.setHasForegroundActivities(foregroundActivities);
//设置mCompletedAdjSeq(当前进程完成adj调整的系列号) = mAdjSeq(当前调整的adj系列号)
state.setCompletedAdjSeq(mAdjSeq);
37. 本次adj调整的返回值
// 如果当前的adj(mCurAdj)有相对于之前优先级有提升
// 或者当前的进程状态mCurProcState有相对于之前优先级有提升
// 或者当前进程的能力mCurCapability有相对于之前有改变
// 则返回true，否则返回false
// if curAdj or curProcState improved, then this process was promoted
return state.getCurAdj() < prevAppAdj || state.getCurProcState() < prevProcState
|| state.getCurCapability() != prevCapability;
}
38. 其它相关代码
38.1 获取默认的进程能力
//通过进程的服务记录psr和进程状态procState得到默认的能力
private int getDefaultCapability(ProcessServiceRecord psr, int procState) {
switch (procState) {
case PROCESS_STATE_PERSISTENT:
case PROCESS_STATE_PERSISTENT_UI:
case PROCESS_STATE_TOP:
//如果是top app或者是常驻进程的进程会有所有的能力
//包括定位、camera、电话、听筒的能力
/*
public static final int PROCESS_CAPABILITY_ALL = PROCESS_CAPABILITY_FOREGROUND_LOCATION
| PROCESS_CAPABILITY_FOREGROUND_CAMERA
| PROCESS_CAPABILITY_FOREGROUND_MICROPHONE
| PROCESS_CAPABILITY_NETWORK;
*/
return PROCESS_CAPABILITY_ALL;
case PROCESS_STATE_BOUND_TOP:
//如果当前进程是service、provider，被前台(client)绑定的话，则当前进程拥有网络能力
return PROCESS_CAPABILITY_NETWORK;
case PROCESS_STATE_FOREGROUND_SERVICE:
//当前进程的进程状态是PROCESS_STATE_FOREGROUND_SERVICE(4)前台服务级别(instrumentation/hasForegroundServices)
//如果带有是前台服务(hasForegroundServices == true)
if (psr.hasForegroundServices()) {
// Capability from FGS are conditional depending on foreground service type in
// manifest file and the mAllowWhileInUsePermissionInFgs flag.
// 则拥有网络能力
return PROCESS_CAPABILITY_NETWORK;
} else {
//其它情况，如instrumentation
//还有service、provider依赖关系貌似不会直接设置PROCESS_STATE_FOREGROUND_SERVICE
//拥有camera、听筒、网络能力
/*
public static final int PROCESS_CAPABILITY_ALL_IMPLICIT = PROCESS_CAPABILITY_FOREGROUND_CAMERA
| PROCESS_CAPABILITY_FOREGROUND_MICROPHONE;
*/
// process has no FGS, the PROCESS_STATE_FOREGROUND_SERVICE is from client.
// the implicit capability could be removed in the future, client should use
// BIND_INCLUDE_CAPABILITY flag.
return PROCESS_CAPABILITY_ALL_IMPLICIT | PROCESS_CAPABILITY_NETWORK;
}
case PROCESS_STATE_BOUND_FOREGROUND_SERVICE:
//当前进程的进程状态是PROCESS_STATE_BOUND_FOREGROUND_SERVICE(5)绑定前台服务
//则拥有网络能力
return PROCESS_CAPABILITY_NETWORK;
default:
//其它情况不赋予相关能力
return PROCESS_CAPABILITY_NONE;
}
}
38.1 shouldSkipDueToCycle是否需要在计算依赖关系时跳过计算
//app: 当前需要调整的进程
//client: 客户端的进程状态记录
//procState: 当前进程的进程状态
//adj: 当前进程的adj值
//cycleReEval: 是否处于循环计算模式，只有在updateOomAdjInnerLSP会让cycleReEval=true
//(条件是设置了setContainsCycle true，如正在计算computeOomAdjLSP的时候还没计算完又跑进来)
private boolean shouldSkipDueToCycle(ProcessRecord app, ProcessStateRecord client,
int procState, int adj, boolean cycleReEval) {
//如果客户端设置了setContainsCycle = true，也即是客户端未调整完毕又进入了computeOomAdjLSP
if (client.containsCycle()) {
// We've detected a cycle. We should retry computeOomAdjLSP later in
// case a later-checked connection from a client would raise its
// priority legitimately.
//这里计算依赖关系的时候，将当前的进程app，设置成包括循环，需要在后面重新计算
app.mState.setContainsCycle(true);
//同时将该进程放入循环计算的list里面mProcessesInCycle，后面如果需要重新计算该进程adj的时候会从此处取回
mProcessesInCycle.add(app);
// If the client has not been completely evaluated, check if it's worth
// using the partial values.
//客户端已经完成的adj调整序列号mCompletedAdjSeq，小于mAdjSeq，代表是之前的调整，本次还未更新
if (client.getCompletedAdjSeq() < mAdjSeq) {
//如果是循环计算进来此处
if (cycleReEval) {
// If the partial values are no better, skip until the next
// attempt
//如果客户端的进程状态大于当前app进程的进程状态
//而且客户端的mCurRawAdj(当前调整的未约束过的adj)，大于当前进程的adj
//代表客户端的优先级比较低，需要等客户端计算完成再来，所以本次依赖关系计算先跳过
if (client.getCurRawProcState() >= procState
&& client.getCurRawAdj() >= adj) {
return true;
}
// Else use the client's partial procstate and adj to adjust the
// effect of the binding
} else {
//如果是非循环计算进来此处，由于客户端还没有计算完成，那就等客户端计算完成，先跳过
return true;
}
}
}
return false;
}
1209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
