写这篇博客,其实我自己还有很多地方原理没有看懂(像Binder机制达到当前进程跟AMS进行通信),但并不是很影响看懂App启动主要做了一些什么事。
看源码我是带着1个问题
问题:Application具体在什么时候创建以及执行的onCreate
众所周知App应用是从ActivityThread的main方法开始(以方便阅读我删掉了一些次要代码)
public static void main(String[] args) {
//从这里我们可以知道 App以消息来驱动App的各种事件(Handler机制嘛,有机会我会写一遍关于Handler机制源码分析的博客)
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
//接下来,看看ActivityThread的attach的实现
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
// ...省略
RuntimeInit.setApplicationObject(mAppThread.asBinder());
//这里拿到的IActivityManager,这里先打住忘下看。我搞清楚mgr它真正是什么,在哪里实例,搞清这个情况接下来看看ActivityManager的getService()
final IActivityManager mgr = ActivityManager.getService();
try {
//这里等一等,先搞清楚mgr
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
// Watch for getting close to heap limit.
BinderInternal.addGcWatcher(new Runnable() {
@Override public void run() {
....
});
} else {
//...省略
}
// ...省略
}
/**
* @hide
*/
public static IActivityManager getService() {
//赫赫...点击IActivityManagerSingleton就到了下面
return IActivityManagerSingleton.get();
}
//这里...
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
//这里先记住这个Context.ACTIVITY_SERVICE,
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
//看完这里,是不是有点什么感觉,这块Binder机制来实现获取到远程的一个代理类 am
//到此还是没搞懂这个am真正的实例在哪里,它的实现类是什么鬼
//要弄清这个问题,我要飙车了,直接去看一下ActivityManagerService的一个方法,请往下看
}
};
//这快的代码我是在ActivityManagerService拷贝过来的
public void setSystemProcess() {
try {
//这里,看Context.ACTIVITY_SERVICE 注册的AMS,看到这里我们应该知道上面的哪个am
//真正实现就是ActivityManagerService
//别问我怎么知道的,我也是看了《深入理解android内核设计》AMS专题才知道的,
//要不然鬼知道AMS在这里注册的哈
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this));
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this));
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
//...省略
}
}
OK,回到刚开始的ActivityThread的attach那里
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
到此已经知道了mgr他的真正实现是ActivityManagerService(我直接说AMS了),我们直接去去看看attachApplication(...)的实现(哦对了,先留意一下mAppThread它是当前进程跟远程AMS通信的接口)
下面是AMS相关实现
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
//继续跟,往下看
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
//...此处省略一堆代码
checkTime(startTime, "attachApplicationLocked: immediately before bindApplication");
mStackSupervisor.mActivityMetricsLogger.notifyBindApplication(app);
//这里AMS通过收集信息,然后通过进程通信把信息回传App进程。OK,下面我们再往会看看ActivityThread的一个内部类实现的IApplicationThread的bindApplication的方法
if (app.instr != null) {
thread.bindApplication(processName, appInfo, providers,
app.instr.mClass,
profilerInfo, app.instr.mArguments,
app.instr.mWatcher,
app.instr.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
} else {
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
}
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {//这里会有惊喜,这次暂时不做分析这块流程
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
//...省略一路代码
return true;
}
回到ActivityThread的ApplicationThread(这里是App进程哦,不是AMS所在进程)
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableBinderTracking, boolean trackAllocation,
boolean isRestrictedBackupMode, boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
String buildSerial) {
if (services != null) {
// Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}
setCoreSettings(coreSettings);
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.instrumentationArgs = instrumentationArgs;
data.instrumentationWatcher = instrumentationWatcher;
data.instrumentationUiAutomationConnection = instrumentationUiConnection;
data.debugMode = debugMode;
data.enableBinderTracking = enableBinderTracking;
data.trackAllocation = trackAllocation;
data.restrictedBackupMode = isRestrictedBackupMode;
data.persistent = persistent;
data.config = config;
data.compatInfo = compatInfo;
data.initProfilerInfo = profilerInfo;
data.buildSerial = buildSerial;
//这里,sendMessage,然后跟进去其实就是ActivityThread一个内部Handler实例,继续
sendMessage(H.BIND_APPLICATION, data);
}
根据sendMessage的H.BIND_APPLICATION,我跟到了这里
public void handleMessage(Message msg) {
//...省略其它case
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
//...省略其它case
}
接下来看看handleBindApplication(data)实现
Application app;
try {
//看到这里,Application在此处实例化(次于怎么创建的感兴趣的同学跟进去看看哈)
app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
// don't bring up providers in restricted mode; they may depend on the
// app's custom Application class
if (!data.restrictedBackupMode) {
if (!ArrayUtils.isEmpty(data.providers)) {
installContentProviders(app, data.providers);
// For process that contains content providers, we want to
// ensure that the JIT is enabled "at some point".
mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
}
}
//...省略
try {
//这里跟进去就会发现 Application的onCreate再此处调用
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
if (!mInstrumentation.onException(app, e)) {
throw new RuntimeException(
"Unable to create application " + app.getClass().getName()
+ ": " + e.toString(), e);
}
}
} finally {
if (data.appInfo.targetSdkVersion <= Build.VERSION_CODES.O
|| StrictMode.getThreadPolicy().equals(writesAllowedPolicy)) {
StrictMode.setThreadPolicy(savedPolicy);
}
}
到此Application的启动流程梦游了一遍,看源码需谨慎带着问题去源码里面走可以不容易迷失在源码里面
其实看看这些东西,有些问题可能会不言自明,比如App启动优化为什么在Application的onCreate进行优化...
最近一个多月公司大部分精力放在了小程序开发这块,时间充足,接下来要是有空我会写几遍关于App换皮肤,插件化的干货博客附带Demo