序入口函数，ActivityThread的main()函数
public static void main(String[] args) {
//此处省略N行.......
//创建Lopper,主线程Looper
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//false,首次启动，需要初始化
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 主线程looper，开启死循环，不断处理按键、触摸等消息，activity的生命周期也由其处理
//若在activity的某个生命周期执行耗时操作，那么其他的消息无法及时执行，那么整个loop循环会卡顿
//时间一长，就会触发抛出ANR
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
attach()分析
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
//main入口传入的fasle
if (!system) {
//先走该分支代码
//先获取ActivityManagerService对象，调用ActivityManagerService的attachApplication()
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
// ======= 展开分析1 ========
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//此处省略N行代码
} else {
try {
//Instrumentation类会在应用的任何代码执行前被实列化，用来监控系统与应用的交互
//另一个重要作用是提供Android组件单元测试。
mInstrumentation = new Instrumentation();
//应用进程conext创建 ====== 展开分析2 =======
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
、 //创建mInitialApplication ===== 展开分析3 ========
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
DropBox.setReporter(new DropBoxReporter());
ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
@Override
public void onConfigurationChanged(Configuration newConfig) {
synchronized (mResourcesManager) {
//立即将此更改应用于资源，因为在返回时，将查看视图层次结构。
if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {
updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(),
mResourcesManager.getConfiguration().getLocales());
//资源被更改，发送消息通知
if (mPendingConfiguration == null ||
mPendingConfiguration.isOtherSeqNewer(newConfig)) {
mPendingConfiguration = newConfig;
sendMessage(H.CONFIGURATION_CHANGED, newConfig);
}
}
}
}
@Override
public void onLowMemory() {
}
@Override
public void onTrimMemory(int level) {
}
});
====展开分析1 ======
ActivityManagerNative，抽象类，一个Binder通信类
检索系统的默认/全局活动管理器。
static public IActivityManager getDefault() {
//这里返回的是ActivityManagerService，继承自ActivityManagerService
return gDefault.get();
}
最终调用ActivityManagerService内的attachAppliocation()
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
进入attachAoolicationLockede()
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
//遍历activity栈，找到栈顶的Activity
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = stacks.get(stackNdx);
if (!isFrontStack(stack)) {
continue;
}
//解锁
ActivityRecord hr = stack.topRunningActivityLocked(null);
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
//找到符合条件的Activity，真正启动Activity
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) {
//此处省略N行......
}
}
}
}
}
//此处省略N行......
return didSomething;
}
realStartActivityLocked()内调用了ActivityThread的scheduleLaunchActivity()
此处给Activity赋值了各种信息，如token，在Android的Window机制中，添加Dailog、View会校验token，因此这边也会将token信息携带下去。
（如："Unable to add window -- token " + attrs.token + " is not valid; is your activity running?这类token异常。关于这块可以去了解一下窗口机制）
此段代码最重要的是最后面的sendMessage。这里发送了一个消息，交给一个名为H的handler处理。H这个handler几乎处理所有Activity的生命周期的方法。
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
//赋值各类信息信息
r.token = token;
r.ident = ident;
r.intent = intent;
r.referrer = referrer;
r.voiceInteractor = voiceInteractor;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.persistentState = persistentState;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profilerInfo = profilerInfo;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
//发送启动Activity的消息，使用内部继承Handelr的H，在ActivityThread创建时初始化
sendMessage(H.LAUNCH_ACTIVITY, r);
}
来看一下H的处理
handleMessage内调用handleLaunchActivity()
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} bre
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
unscheduleGcIdler();
//此处省略N行.........
//初始化WindowManagerGlobal
WindowManagerGlobal.initialize();
// ======== performLaunchActivity()内部 ============
//1.加载Activity的class类，执行其attach()
//2.调用mInstrumentation.callActivityOnCreate，最终调用Activity的onCreate()
//3.调用Activity的start()方法
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
// ========= handleResumeActivity（）内部 ==============
//1.获取window，创建DecorView对象
//2.获取windowManager，将DecorView添加到wm，此时开启view的测量，布局，绘制等等
//3.使Activity可见
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} else {
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
====展开分析2 ======
ContextImpl（继承自Context）的构造方法，所以返回的是Context
简要看下一源码，针对Context的分析，后续会展开一篇文章，有兴趣的话，可以关注我~~
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
return new ContextImpl(null, mainThread,
packageInfo, null, null, 0, null, null, Display.INVALID_DISPLAY);
}
private ContextImpl(ContextImpl container, ActivityThread mainThread,
LoadedApk packageInfo, IBinder activityToken, UserHandle user, int flags,
Display display, Configuration overrideConfiguration, int createDisplayWithId) {
mOuterContext = this;
//如果创建者没有指定使用哪个存储，则使用默认的应用程序位置。
if ((flags & (Context.CONTEXT_CREDENTIAL_PROTECTED_STORAGE
| Context.CONTEXT_DEVICE_PROTECTED_STORAGE)) == 0) {
//此处省略N行代码
}
//传入ActvityThread
mMainThread = mainThread;
//传入activityToken
mActivityToken = activityToken;
mFlags = flags;
if (user == null) {
user = Process.myUserHandle();
}
mUser = user;
mPackageInfo = packageInfo;
//初始化ResourcesManager实例，用以获取资源文件
mResourcesManager = ResourcesManager.getInstance();
///此处省略N行代码...........
}
======展开分析3 =========
LoadApk类,调用makeApplication(）入参（true，null）。
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
//此处省略N行............
try {
java.lang.ClassLoader cl = getClassLoader();
//此处省略N行............
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
//通过mInstrumentation创建Application
//
======= 展开分析4 =========
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
//此处省略N行............
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
if (instrumentation != null) {
try {
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
//此处省略N行............
}
//此处省略N行............
return app;
}
=======展开分析4=======
Instrumetation类，创建Application，调用attach(context)
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return newApplication(cl.loadClass(className), context);
}
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}
网友评论