2024年最新Android插件化架构 - Activity的启动流程分析，面试问题集锦

最后

感觉现在好多人都在说什么安卓快凉了，工作越来越难找了。又是说什么程序员中年危机啥的，为啥我这年近30的老农根本没有这种感觉，反倒觉得那些贩卖焦虑的都是瞎j8扯谈。当然，职业危机意识确实是要有的，但根本没到那种草木皆兵的地步好吗？

Android凉了都是弱者的借口和说辞。虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。

所以，最后这里放上我耗时两个月，将自己8年Android开发的知识笔记整理成的Android开发者必知必会系统学习资料笔记，上述知识点在笔记中都有详细的解读，里面还包含了腾讯、字节跳动、阿里、百度2019-2021面试真题解析，并且把每个技术点整理成了视频和PDF（知识脉络 + 诸多细节）。

以上全套学习笔记面试宝典，吃透一半保你可以吊打面试官，只有自己真正强大了，有核心竞争力，你才有拒绝offer的权力，所以，奋斗吧！骚年们！千里之行，始于足下。种下一颗树最好的时间是十年前，其次，就是现在。

最后，赠与大家一句诗，共勉！

不驰于空想，不骛于虚声。不忘初心，方得始终。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

// 检测结果也就是否正常

public static void checkStartActivityResult(int res, Object intent) {

if (res >= ActivityManager.START_SUCCESS) {

return;

}

switch (res) {

case ActivityManager.START_INTENT_NOT_RESOLVED:

case ActivityManager.START_CLASS_NOT_FOUND:

// 在这里就会报各种错，AndroidManifest.xml中没有配置的错就出现在这

if (intent instanceof Intent && ((Intent)intent).getComponent() != null)

throw new ActivityNotFoundException(

"Unable to find explicit activity class "

• ((Intent)intent).getComponent().toShortString()

• “; have you declared this activity in your AndroidManifest.xml?”);

throw new ActivityNotFoundException(

"No Activity found to handle " + intent);

case ActivityManager.START_PERMISSION_DENIED:

throw new SecurityException("Not allowed to start activity "

• intent);

case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:

throw new AndroidRuntimeException(

“FORWARD_RESULT_FLAG used while also requesting a result”);

case ActivityManager.START_NOT_ACTIVITY:

throw new IllegalArgumentException(

“PendingIntent is not an activity”);

case ActivityManager.START_NOT_VOICE_COMPATIBLE:

throw new SecurityException(

"Starting under voice control not allowed for: " + intent);

case ActivityManager.START_VOICE_NOT_ACTIVE_SESSION:

throw new IllegalStateException(

“Session calling startVoiceActivity does not match active session”);

case ActivityManager.START_VOICE_HIDDEN_SESSION:

throw new IllegalStateException(

“Cannot start voice activity on a hidden session”);

case ActivityManager.START_CANCELED:

throw new AndroidRuntimeException("Activity could not be started for "

• intent);

default:

throw new AndroidRuntimeException("Unknown error code "

• res + " when starting " + intent);

}

}

ActivityManagerNative.getDefault().startActivity又是一个进程间的通信，如果不了解IPC的请移步 Android进程间的通信 - IPC(机制)Binder的原理和源码阅读，来到ActivityManagerService中的startActivity方法：

@Override

public final int startActivity(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,

int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {

return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,

resultWho, requestCode, startFlags, profilerInfo, bOptions,

UserHandle.getCallingUserId());

}

@Override

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,

Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,

int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {

enforceNotIsolatedCaller(“startActivity”);

userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),

userId, false, ALLOW_FULL_ONLY, “startActivity”, null);

// TODO: Switch to user app stacks here.

return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,

resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,

profilerInfo, null, null, bOptions, false, userId, null, null);

}

final int startActivityMayWait(IApplicationThread caller, int callingUid,

String callingPackage, Intent intent, String resolvedType,

IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,

IBinder resultTo, String resultWho, int requestCode, int startFlags,

ProfilerInfo profilerInfo, IActivityManager.WaitResult outResult, Configuration config,

Bundle bOptions, boolean ignoreTargetSecurity, int userId,

IActivityContainer iContainer, TaskRecord inTask) {

// PackageManagerService-----> 扫描app，注册组件

ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);

// Collect information about the target of the Intent.

ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

rInfo = mSupervisor.resolveIntent(intent, null /resolvedType/, userId);

int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,

aInfo, rInfo, voiceSession, voiceInteractor,

resultTo, resultWho, requestCode, callingPid,

callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,

options, ignoreTargetSecurity, componentSpecified, outRecord, container,

inTask);

}

final int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,

String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,

IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,

IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,

String callingPackage, int realCallingPid, int realCallingUid, int startFlags,

ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,

ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,

TaskRecord inTask) {

// 验证intent、Class、Permission等

// 保存将要启动的Activity的Record

err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,

true, options, inTask);

return err;

}

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,

IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,

int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {

// 检查将要启动的Activity的launchMode和启动Flag

// 根据launcheMode和Flag配置task

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);

// 举一个例子 SingleTop

if (dontStart) {

top.deliverNewIntentLocked(

mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);

// Don’t use mStartActivity.task to show the toast. We’re not starting a new activity

// but reusing ‘top’. Fields in mStartActivity may not be fully initialized.

mSupervisor.handleNonResizableTaskIfNeeded(

top.task, preferredLaunchStackId, topStack.mStackId);

return START_DELIVERED_TO_TOP;

}

mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);

if (mDoResume) {

mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,

mOptions);

}

}

进入ActvityStack中的startActivityLocked()方法

// 任务栈历史栈配置

final void startActivityLocked(ActivityRecord r, boolean newTask, boolean keepCurTransition,

ActivityOptions options) {

if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {

// 加入栈顶 管理栈

insertTaskAtTop(rTask, r);

// 管显示

mWindowManager.moveTaskToTop(taskId);

}

if (!newTask) {

// 不是一个新的Task

task.addActivityToTop®;

r.putInHistory();

addConfigOverride(r, task);

}

}

进入ActivityStack的resumeTopActivityInnerLocked()方法

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {

// Find the first activity that is not finishing.

final ActivityRecord next = topRunningActivityLocked();

// The activity may be waiting for stop, but that is no longer

// appropriate for it.

mStackSupervisor.mStoppingActivities.remove(next);

mStackSupervisor.mGoingToSleepActivities.remove(next);

next.sleeping = false;

mStackSupervisor.mWaitingVisibleActivities.remove(next);

if (mResumedActivity != null) {

if (DEBUG_STATES) Slog.d(TAG_STATES,

"resumeTopActivityLocked: Pausing " + mResumedActivity);

pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);

}

}

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,

ActivityRecord resuming, boolean dontWait) {

if (prev.app != null && prev.app.thread != null) {

if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);

try {

EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,

prev.userId, System.identityHashCode(prev),

prev.shortComponentName);

mService.updateUsageStats(prev, false);

// 暂停Activity

prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,

userLeaving, prev.configChangeFlags, dontWait);

}

completePauseLocked(false, resuming);

}

进入ApplicationThread的schedulePauseActivity()方法

public final void schedulePauseActivity(IBinder token, boolean finished,

boolean userLeaving, int configChanges, boolean dontReport) {

sendMessage(

finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,

token,

(userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),

configChanges,

seq);

}

public void handleMessage(Message msg) {

switch (msg.what) {

…

case PAUSE_ACTIVITY: {

Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “activityPause”);

SomeArgs args = (SomeArgs) msg.obj;

handlePauseActivity((IBinder) args.arg1, false,

(args.argi1 & USER_LEAVING) != 0, args.argi2,

(args.argi1 & DONT_REPORT) != 0, args.argi3);

maybeSnapshot();

Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

} break;

}

private void handlePauseActivity(IBinder token, boolean finished,

boolean userLeaving, int configChanges, boolean dontReport, int seq) {

//…

performPauseActivity(token, finished, r.isPreHoneycomb(), “handlePauseActivity”);

//…

// Tell the activity manager we have paused.

if (!dontReport) {

try {

ActivityManagerNative.getDefault().activityPaused(token);

} catch (RemoteException ex) {

throw ex.rethrowFromSystemServer();

}

}

}

final Bundle performPauseActivity(IBinder token, boolean finished,

boolean saveState, String reason) {

ActivityClientRecord r = mActivities.get(token);

return r != null ? performPauseActivity(r, finished, saveState, reason) : null;

}

final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,

boolean saveState, String reason) {

// …

performPauseActivityIfNeeded(r, reason);

}

private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {

// …

mInstrumentation.callActivityOnPause(r.activity);

}

进入Instrumentation的callActivityOnPause()方法

public void callActivityOnPause(Activity activity) {

activity.performPause();

}

进入Activity的performPause()方法

final void performPause() {

mDoReportFullyDrawn = false;

mFragments.dispatchPause();

mCalled = false;

// 调用onPause()暂停方法

onPause();

mResumed = false;

if (!mCalled && getApplicationInfo().targetSdkVersion

= android.os.Build.VERSION_CODES.GINGERBREAD) {

throw new SuperNotCalledException(

"Activity " + mComponent.toShortString() +

" did not call through to super.onPause()");

}

mResumed = false;

}

总算是回调到了Activity的onPause方法，哈哈还是挺简单的，Activity生命周期中的onPause方法终于被我们找到了。也就是说我们在启动一个Activity的时候最先被执行的是栈顶的Activity的onPause方法。我们对Activity这些生命周期早已背得滚瓜烂熟。接着往下看然后回到我们ApplicationThread的handlePauseActivity()方法中的ActivityManagerNative.getDefault().activityPaused(token);进入ActivityManagerService中的activityPaused()方法

@Override

public final void activityPaused(IBinder token) {

final long origId = Binder.clearCallingIdentity();

synchronized(this) {

ActivityStack stack = ActivityRecord.getStackLocked(token);

if (stack != null) {

stack.activityPausedLocked(token, false);

}

}

Binder.restoreCallingIdentity(origId);

}

进入ActivityStack中的activityPausedLocked()方法

final void activityPausedLocked(IBinder token, boolean timeout){

completePauseLocked(true, null);

}

private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {

ActivityRecord prev = mPausingActivity;

if (resumeNext) {

final ActivityStack topStack = mStackSupervisor.getFocusedStack();

mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);

}

}

进入ActivityStackSupervisor中的resumeFocusedStackTopActivityLocked()方法

boolean resumeFocusedStackTopActivityLocked(

ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {

targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);

}

进入ActivityStack中的resumeTopActivityUncheckedLocked()方法

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {

result = resumeTopActivityInnerLocked(prev, options);

}

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {

// 这个方法我们已经很熟悉了

mStackSupervisor.startSpecificActivityLocked(next, true, true);

}

进入ActivityStackSupervisor中的startSpecificActivityLocked()方法

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.task.stack.setLaunchTime®;

if (app != null && app.thread != null) {

try {

if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0

|| !“android”.equals(r.info.packageName)) {

// Don’t add this if it is a platform component that is marked

// to run in multiple processes, because this is actually

// part of the framework so doesn’t make sense to track as a

// separate apk in the process.

app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,

mService.mProcessStats);

}

// 真的要启动Activity了

小福利：

在当下这个碎片化信息环境的时代，很多资源都可以在网络上找到，只取决于你愿不愿意找或是找的方法对不对了

很多朋友不是没有资料，大多都是有几十上百个G，但是杂乱无章，不知道怎么看从哪看起，甚至是看后就忘

如果大家觉得自己在网上找的资料非常杂乱、不成体系的话，我也分享一套给大家，比较系统，我平常自己也会经常研读。

2021大厂最新Android面试真题解析

各个模块学习视频：如数据结构与算法

只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。

这份体系学习笔记，适应人群：**第一，**学习知识比较碎片化，没有合理的学习路线与进阶方向。**第二，**开发几年，不知道如何进阶更进一步，比较迷茫。第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。如果你有需要，我这里恰好有为什么，不来领取！说不定能改变你现在的状态呢！点赞+评论即可获得！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

可以在网络上找到，只取决于你愿不愿意找或是找的方法对不对了

很多朋友不是没有资料，大多都是有几十上百个G，但是杂乱无章，不知道怎么看从哪看起，甚至是看后就忘

如果大家觉得自己在网上找的资料非常杂乱、不成体系的话，我也分享一套给大家，比较系统，我平常自己也会经常研读。

2021大厂最新Android面试真题解析

[外链图片转存中…(img-2xIthGWk-1715139978121)]

各个模块学习视频：如数据结构与算法

[外链图片转存中…(img-2Idmh7DN-1715139978122)]

只有系统，有方向的学习，才能在段时间内迅速提高自己的技术。
[外链图片转存中…(img-nqUb5s1h-1715139978122)]

[外链图片转存中…(img-oeQp9w86-1715139978123)]

这份体系学习笔记，适应人群：**第一，**学习知识比较碎片化，没有合理的学习路线与进阶方向。**第二，**开发几年，不知道如何进阶更进一步，比较迷茫。第三，到了合适的年纪，后续不知道该如何发展，转型管理，还是加强技术研究。如果你有需要，我这里恰好有为什么，不来领取！说不定能改变你现在的状态呢！点赞+评论即可获得！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！