1.startActivity
Activity:
startActivity(Intent intent)
->startActivity(Intent intent, @Nullable Bundle options)
——>startActivityForResult(intent, -1);
->startActivityForResult(intent, requestCode, null);
-> mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
IPC 跨进程调用
——>ActivityTaskManager.getService().startActivity(
——>ActivityTaskManagerService.startActivity()
ActivityStartController->ActivityStarter.execute
——>getActivityStartController().obtainStarter(intent, "startActivityAsUser")
——>ActivityStarter.execute
//创建出ActivityRecord r = new ActivityRecord.Builder(mService)
->executeRequest(mRequest);
—>startActivityUnchecked(
—>startActivityInner(
-> mRootWindowContainer.resumeFocusedTasksTopActivities(
—>focusedRoot.resumeTopActivityUncheckedLocked
->resumeTopActivityInnerLocked
->resumeTopActivity
//系统ActivityRecord 系统进程是否创建 还没有创建主线程
```
if (next.attachedToProcess()) {
//Activity已经存在，topRunningActivity 执行onPause -> nextActivity执行
//
final ClientTransaction transaction =
ClientTransaction.obtain(next.app.getThread(), next.token);
mAtmService.getLifecycleManager().scheduleTransaction(transaction);
//realStartActivityLocked(r, wpc, andResume, checkConfig);
}else{
//ActivityTaskSupervisor
mTaskSupervisor.startSpecificActivity(
}
ActivityTaskSuperVisor
——> mTaskSupervisor.startSpecificActivity(
这个活动的应用程序已经运行了吗?
if (wpc != null && wpc.hasThread()) {
//start
//ActivityTaskSupervisor
realStartActivityLocked();
return;
}
//创建进程
mService.startProcessAsync(
---------------------------------------------------------
2. ActivityThread main执行
zygote fork出进程，启动ActivityThread的main方法
应用进程绑定到AMS
AMS发送启动Activity的请求
ActivityThread的Handler处理启动Activity的请求
1. main
public static void main(String[] args) {
....
//创建主线程的Looper以及MessageQueue
Looper.prepareMainLooper();
...
ActivityThread thread = new ActivityThread();
//AMS绑定ApplicationThread对象,即应用进程绑定到AMS
thread.attach(false, startSeq);
//开启主线程的消息循环
Looper.loop();
...
}
2. attach
—>thread.attach(false, startSeq);
final IActivityManager mgr = ActivityManager.getService();
//AMS 绑定 ApplicationThread对象
mgr.attachApplication(mAppThread, startSeq);
ActivityManagerService
—> mgr.attachApplication(
—> attachApplicationLocked(@NonNull IApplicationThread thread)
//将应用进程的ApplicationThread对象绑定到AMS，即AMS获得ApplicationThread的代理对象
3. bindApplication
thread.bindApplication(
//启动Activity
mAtmInternal.attachApplication(app.getWindowProcessController());
—>thread.bindApplication(
//向H发送绑定ApplicationThread对象的消息
//sendMessage(H.BIND_APPLICATION, data);
->handleBindApplication(AppBindData data)
//初始化app
app = makeApplicationInner(，null)
app.attach()
//
attachBaseContext(context);
//初始化内容提供者
//可以看到contentProvider是在Application之前初始化
installContentProviders(app, data.providers);
//调用Application.onCreate
->mInstrumentation.callApplicationOnCreate(app);
//ActivityTaskManagerService 内部类
LocalService extends ActivityTaskManagerInternal
——>mAtmInternal.attachApplication(
//RootWindowContainer
——>mRootWindowContainer.attachApplication(wpc);
-->mAttachApplicationHelper.process(app)
-->ensureActivitiesVisible()
//DisplayContent
-->display.ensureActivitiesVisible
forAllRootTasks(rootTask -> {
rootTask.ensureActivitiesVisible(starting, configChanges, preserveWindows,
notifyClients);
//com.android.server.wm.Task
-->rootTask.ensureActivitiesVisible()
forAllLeafTasks(task -> {
task.updateActivityVisibilities(starting, configChanges, preserveWindows,
notifyClients);
-->TaskFragment.updateActivityVisibilities()
-->mEnsureActivitiesVisibleHelper.process(
starting, configChanges, preserveWindows, notifyClients);
-->setActivityVisibilityState()
-->makeVisibleAndRestartIfNeeded()
//ActivityTaskSupervisor
-->mTaskSupervisor.startSpecificActivity(r,
-->
LoadedApk.java
private Application makeApplicationInner(boolean forceDefaultAppClass,
Instrumentation instrumentation, boolean allowDuplicateInstances) {
//创建PathClasssLoader
// hook 点
final java.lang.ClassLoader cl = getClassLoader();
//
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
(Application) cl.loadClass(className).newInstance()
private void createOrUpdateClassLoaderLocked(List<String> addedPaths) {
if (mPackageName.equals("android")) {
// Note: This branch is taken for system server and we don't need to setup
// jit profiling support.
if (mClassLoader != null) {
// nothing to update
return;
}
if (mBaseClassLoader != null) {
mDefaultClassLoader = mBaseClassLoader;
} else {
mDefaultClassLoader = ClassLoader.getSystemClassLoader();
}
mAppComponentFactory = createAppFactory(mApplicationInfo, mDefaultClassLoader);
mClassLoader = mAppComponentFactory.instantiateClassLoader(mDefaultClassLoader,
new ApplicationInfo(mApplicationInfo));
return;
}
private static ClassLoader createSystemClassLoader() {
String classPath = System.getProperty("java.class.path", ".");
String librarySearchPath = System.getProperty("java.library.path", "");
return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());
}
4. realStartActivityLocked
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
//进程存在 直接启动Activity
if (wpc != null && wpc.hasThread()) {
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
}
}
//开启进程
mService.startProcessAsync(r, knownToBeDead, isTop,
isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
: HostingRecord.HOSTING_TYPE_ACTIVITY);
//ActivityTaskSupervisor
—>mTaskSupervisor.realStartActivityLocked(
//添加一个 LaunchActivityItem 的callback
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final boolean isTransitionForward = r.isTransitionForward();
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
//判断生命周期的状态
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//AMS 获取ClientLifecycleManager 发送状态
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
//ClientLifecycleManager.
—> scheduleTransaction(
ClientTransaction
-> transaction.schedule();
//1.mClient是IApplicationThread类型，
//2.ActivityThread的内部类ApplicationThread
//IApplicationThread.Stub这个接口类并实现了对应的方法
//通过binder通知A
//3.ActivityThread实际调用的是他父类
//ClientTransactionHandler的scheduleTransaction方法。
->mClient.scheduleTransaction(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
5. ApplictionThread H 执行Activity启动
AMS通过binder通知ApplictionThread执行启动Activity任务，
ApplictionThread通过Hanlder发送消息进行Activity的启动。
—>sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
//H:
—> mTransactionExecutor.execute(transaction);
```
//先执行callbacks，当根活动首次启动时会有callback，
//callback会执行onCreate方法
//其它活动切换状态时没有callback
executeCallbacks(transaction);
//改变活动的生命周期状态
executeLifecycleState(transaction);
—>executeCallbacks(transaction);
..
for (int i = 0; i < size; ++i) {
//Activity启动 LaunchActivityItem
final ClientTransactionItem item = callbacks.get(i);
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
LaunchActivityItem
-> LaunchActivityItem.execute
-> client.handleLaunchActivity(r, pendingActions, null);
//ActivityThread
-> handleLaunchActivity(
—>performLaunchActivity(r, customIntent);
//创建启动Activity的上下文
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
//类加载器创建 Activity
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
//(Activity) cl.loadClass(className).newInstance()
//---------
//获取Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
//初始化Activity，创建Window对象（PhoneWindow）并实现Activity和Window相关联
//创建windowManager 实际是WindowManagerImpl
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken, r.shareableActivityToken);
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
//设置生命周期为onCreate
r.setState(ON_CREATE);
StartActivityItem
ResumeActivityItem
//onCreate后续的执行
—>executeLifecycleState(transaction);
//执行onCreate和onResume之前的生命周期 即onStart
cycleToPath(r, lifecycleItem.getTargetState(), true , transaction);
//此时的lifecycleItem 为 ResumeActivityItem
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
//在executeLifecycleState方法中，会先执行cycleToPath，
//
//此时的lifecycleItem为ResumeActivityItem，
//调用lifecycleItem.getTargetState时将得到ON_RESUME状态，
// cycleToPath方法。
private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState) {
final int start = r.getLifecycleState();
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path);
}
//onCreate方法已经执行，所以start为ON_CREATE,
//而finish为上面传递的ON_RESUME,
//excludeLastState是否移除最后的状态为true。
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
...
if (finish >= start) {
// 添加start到finish之间的周期状态
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
...
// 根据需求移除最后的状态
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
public abstract class ActivityLifecycleItem extends ClientTransactionItem {
.....
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;
...
}
//在getLifecyclePath这个方法中
//start为ON_CREATE, finish为ON_RESUME,
//所以mLifecycleSequence将添加ON_START和ON_RESUME状态，
//但是又因为excludeLastState为true，所以最后会移除掉ON_RESUME状态，
//所以返回的类型只包含ON_START状态。
//cycleToPath方法中的path中将只包含ON_START状态，
//然后继续执行 performLifecycleSequence 方法。
//
—>performLifecycleSequence(
//执行onStart
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r.token, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
handleResumeActivity
//cycleToPath执行完onCreate方法 执行
///ResumeActivityItem
—>lifecycleItem.execute
—>client.handleResumeActivity(r, true, mIsForward,
"RESUME_ACTIVITY");
//ActivityThread
—>handleResumeActivity
//设置Activity的生命周期为onResume
if (!performResumeActivity(r, finalStateRequest, reason))
//
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
//获取decorView 没有就直接创建
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
//把decorview 添加到window上
//windowmanagerImpl.addview()
// windowmanagerGlobal.addview()
// new ViewRootImpl
wm.addView(decor, l);
//显示decorview
r.activity.makeVisible()
void makeVisible() {
//decordview显示
mDecor.setVisibility(View.VISIBLE);
}
3. UI
1.window 什么时候创建？
2.ViewRootImpl什么时候创建？
3.view的绘制流程哪里开始？
布局层级
Activity->PhoneWindow—>DecorView(parent->ViewRootImpl)
PhoneWindow创建
—> performLaunchActivity 里
->activity.attach(
////1、回调 attachBaseContext
attachBaseContext(context);
////2、创建PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
// phonewindow 关联windowmanager(windowmanagerImpl)
mWindow.setWindowManager(
(WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
mToken, mComponent.flattenToString(),
DecordView 创建
public void setContentView(@LayoutRes int layoutResID) {
getWindow().setContentView(layoutResID);
initWindowDecorActionBar();
}
—> PhoneWindow.setContentView
public void setContentView(int layoutResID) {
if (mContentParent == null) {
//1、 创建DecorView
installDecor();
} else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
mContentParent.removeAllViews();
}
if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
getContext());
transitionTo(newScene);
} else {
//2、mContentParent是DecorView中的FrameLayout，将我们的布局添加到这个FrameLayout里
mLayoutInflater.inflate(layoutResID, mContentParent);
}
...
}
—> installDecor();
private void installDecor() {
mForceDecorInstall = false;
if (mDecor == null) {
//1.创建DecorView
mDecor = generateDecor(-1);
mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
mDecor.setIsRootNamespace(true);
if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
}
} else {
// 2. mDecor 不为空，就是创建过，只需设置window
mDecor.setWindow(this);
}
if (mContentParent == null) {
//3.找到DecorView 内容部分，findViewById(ID_ANDROID_CONTENT)
mContentParent = generateLayout(mDecor);
// Set up decor part of UI to ignore fitsSystemWindows if appropriate.
mDecor.makeOptionalFitsSystemWindows();
//4.找到DecorView的根View，给标题栏部分，设置图标和标题...
final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(
R.id.decor_content_parent);
}
}
—>generateDecor(
protected DecorView generateDecor(int featureId) {
...
return new DecorView(context, featureId, this, getAttributes());
}
—>generateLayout(
protected ViewGroup generateLayout(DecorView decor) {
// 1.窗口各种属性设置，例如 requestFeature(FEATURE_NO_TITLE);
...
if (a.getBoolean(R.styleable.Window_windowNoTitle, false)) {
requestFeature(FEATURE_NO_TITLE);
}
...
if (a.getBoolean(R.styleable.Window_windowFullscreen, false)) {
setFlags(FLAG_FULLSCREEN, FLAG_FULLSCREEN & (~getForcedWindowFlags()));
}
...
//2.获取 windowBackground 属性，默认窗口背景
if (mBackgroundDrawable == null) {
if (mBackgroundResource == 0) {
mBackgroundResource = a.getResourceId(
R.styleable.Window_windowBackground, 0);
}
...
}
...
// 3.获取DecorView里面id为 R.id.content的布局
ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
...
if (getContainer() == null) {
//4.在注释2的时候已经获取了窗口背景属性id，这里转换成drawable，并且设置给DecorView
final Drawable background;
if (mBackgroundResource != 0) {
background = getContext().getDrawable(mBackgroundResource);
} else {
background = mBackgroundDrawable;
}
mDecor.setWindowBackground(background);
}
return contentParent;
}
ViewRootImpl的创建
ActivityThread #handleResumeActivity
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
ActivityClientRecord r = mActivities.get(token);
//...
//1、先回调Activity的onResume方法
r = performResumeActivity(token, clearHide, reason);
if (r != null) {
final Activity a = r.activity;
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
//2、wm是当前Activity的WindowManager
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
...
if (a.mVisibleFromClient && !a.mWindowAdded) {
a.mWindowAdded = true;
// 3.添加decor到WindowManager
wm.addView(decor, l);
}
//performResumeActivity，主要是回调Activity的onResume方法。
//
//从上文performLaunchActivity中，mInstrumentation.newActivity()->
//-> Activity.attach()开始跟踪这个wm,
//创建phoneWindow 创建 windowManager 实现类WindowManagerImpl
//wm = WindowManagerImpl,
//调用WindowManagerImpl的addView方法，
//最终调用的是WindowManagerGlobal的addView方法，
//DecorView和viewrootimpl 关联，执行绘制流程
wm.addView(decor, l);
WindowManagerGlobal
mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
// view = DecorView
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow, int userId) {
//创建 ViewRootImpl
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
//leakcanary检测RootView ，Curtains也是hook WindowManageGlobal,的mViews,
//替换ArrayList的add(),removeAt()方法，
//详细请看Curtains: RootViewsSpy.install()
//2、添加到ArrayList进行管理
mViews.add(view);
//3.mRoots 存放ViewRootImpl对象
mRoots.add(root);
mParams.add(wparams);
//viewRootImpl和Decorview关联
root.setView(view, wparams, panelParentView, userId);
}
ViewRootImpl view的绘制流程
public ViewRootImpl(Context context, Display display,boolean useSfChoreographer) {
mContext = context;
//1、WindowSession 是IWindowSession，binder对象，可跨进程跟WMS通信
//WindowManagerGlobal.getWindowSession()
//通过windowManagerServie. 获取Session
//mWindowSession = Session
mWindowSession = WindowManagerGlobal.getWindowSession();
mDisplay = display;
...
// 2、创建window，是一个binder对象
mWindow = new W(this);
...
//3、mAttachInfo View.post 相关
mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this);
...
//4、Choreographer编舞者在这里初始化
mChoreographer = Choreographer.getInstance();
mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);
}
void setView{
// 1.DecorView赋值给mView
mView = view;
...
//2.开始测量布局绘制
requestLayout();
//3.WindowSession,将window添加到屏幕，有返回值
//最终通过wms.addWindow()添加
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, mInputChannel);
//4.设置decorView的父parent
view.assignParent(this);
}
Choreographer
requestLayout，会请求vsync信号(垂直同步信号，双缓冲(前缓冲，后缓冲，交替进行))，
然后下一次vsync信号来的时候，会调用 performTraversals 方法，
performTraversals 主要是执行View的measure、layout、draw。
——>
requestLayout()
```
public void requestLayout() {
if (!mHandlingLayoutInLayoutRequest) {
checkThread();
mLayoutRequested = true;
scheduleTraversals();
}
}
```
——>scheduleTraversals()
```
if (!mTraversalScheduled) {
mTraversalScheduled = true;
//设置同步屏障
mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
//具体源码请看Choreographer.java
mChoreographer.postCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
}
TraversalRunnable mTraversalRunnable = new TraversalRunnable();
void doTraversal() {
if (mTraversalScheduled) {
mTraversalScheduled = false;
//移除同步屏障
mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
if (mProfile) {
Debug.startMethodTracing("ViewAncestor");
}
//执行绘制
performTraversals();
if (mProfile) {
Debug.stopMethodTracing();
mProfile = false;
}
}
}
performTraversals
private void performTraversals() {
// decorView
final View host = mView;
//把mAttachInfo分发给所以的子view
//view.post能获取到宽高的根本，
//分给子view执行获取宽高的任务消息
host.dispatchAttachedToWindow(mAttachInfo, 0);
performMeasure()
performLayout()
performDraw()
}
4.startProcessAsync fork进程
1. 创建ActivityThread执行main方法
——>ActivityTaskManagerService.startProcessAsync(
Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent());
mH.sendMessage(m);
//通过ActivityManagerInternal::startProcess
ActivityManagerInternal 的实现类 ActivityManagerService #LocalService
——>LocalService.startProcess(
-> startProcessLocked(,,,,,false
// ProcessList 创建进程
——>mProcessList.startProcessLocked -> app = newProcessRecordLocked(
//启动
——>final boolean success = startProcessLocked(
//当前系统的32 or 64
String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi;
//Zygote进程启动ActivityThread.main
final String entryPoint = "android.app.ActivityThread";
——>startProcessLocked
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
requiredAbi, instructionSet, invokeWith, startTime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
——> startProcess(
Process向Zygote进程发送创建应用进程请求
——>Process.start( -> ZYGOTE_PROCESS.start(
ZygoteProcess
->startViaZygote(
zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote);
// 尝试多个Socket连接
// 该函数可能会阻塞，可能需要尝试连接多个受精卵来找到
// 合适的一个。
//与Zygote建立Socket连接
——> openZygoteSocketIfNeeded(abi);
//尝试连接主到Zygote
attemptConnectionToPrimaryZygote();
//Socket进行连接成功并匹配abi后会返回ZygoteState类型对象
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
if (mZygoteSecondarySocketAddress != null) {
//主Abi不适配，尝试连接次Zygote
// The primary zygote didn't match. Try the secondary.
attemptConnectionToSecondaryZygote();
if (secondaryZygoteState.matches(abi)) {
return secondaryZygoteState;
}
}
attemptConnectionToPrimaryZygote();
->64进程中 与 名zygote的建立连接
primaryZygoteState =ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
attemptConnectionToSecondaryZygote();
->
32位进程中与 名 zygote_secondary的建立连接
//发送请求
//将传入的应用进程的启动参数argsForZygote写入到ZygoteState
—> zygoteSendArgsAndGetResult
##Zygote进程接受请求并孵化应用进程
AMS已经与Zygote进程建立Socket连接并发送了创建应用进程的请求，那么Zygote进程是会收到请求
Zygote进程是在ZygoteInit的main方法中接受请求的。所以现在的入口就是ZygoteInit的main方法。
2. ZygoteInit
//文件
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
——> ZygoteInit.main
```
@UnsupportedAppUsage
public static void main(String argv[]) {
ZygoteServer zygoteServer = new ZygoteServer();
Runnable caller;
try {
...
//创建名为zygote的Socket
zygoteServer.createZygoteSocket(socketName);
....
//由于在init.rc中设置了start-system-server参数,因此
//这里将启动SystemServer,可见SystemServer由Zygote创建的第一个进程
if (startSystemServer) {
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
if (r != null) {
r.run();
return;
}
}
caller = Zygote.initBlastulaPool();
if (caller == null) {
//等待AMS的请求
caller = zygoteServer.runSelectLoop(abiList);
}
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
zygoteServer.closeServerSocket();
}
// We're in the child process and have exited the select loop. Proceed to execute the
// command.
//执行runnable
if (caller != null) {
caller.run();
}
3.ZygoteInit.main
通过main方法，我们可以知道在这个main方法首先要创建一个Server端的Socket，
这个name为”zygote”的Socket用来等待ActivityManagerService来请求Zygote来创建新的应用程序进程,
在上面AMS请求的分析中我们也知道客户端将根据这个name来与Zygote的Socket建立连接。
接下去会启动SystemServer进程，这个进程会启动各种系统服务，比如与Activity启动息息相关的AMS。
最后会调用ZygoteServer.runSelectLoop(abiList)
来使创建的Socket进入无限循环，等待AMS请求
4.ZygoteServer
frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
这个方法是死循环表示不停的监听着Socket连接。
acceptCommandPeer方法就是监听是否收到了请求，
如果收到了请求就交给processOneCommand来实现
—>runSelectLoop
Runnable runSelectLoop(String abiList) {
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
peers.add(null);
while (true) {
while (--pollIndex >= 0) {
if ((pollFDs[pollIndex].revents & POLLIN) == 0) {
continue;
}
if (pollIndex == 0) {
//监听Socket连接，充当服务端Socket
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
socketFDs.add(newPeer.getFileDescriptor());
} else if (pollIndex < blastulaPoolEventFDIndex) {
try {
//不断处理客户端的AMS的请求，然后交给processOneCommand
ZygoteConnection connection = peers.get(pollIndex);
final Runnable command = connection.processOneCommand(this);
}
....
}
}
}
}
在这个方法中将对请求进行处理，首先获取到将要启动的应用进程的启动参数，
然后调用forkAndSpecialize来创建应用进程。
—>processOneCommand
Runnable processOneCommand(ZygoteServer zygoteServer) {
String args[];
ZygoteArguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
//获取应用程序进程的启动参数
args = Zygote.readArgumentList(mSocketReader);
// TODO (chriswailes): Remove this and add an assert.
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
throw new IllegalStateException("IOException on command socket", ex);
}
....
parsedArgs = new ZygoteArguments(args);
....
//fork当前进程创建一个子进程
pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mTargetSdkVersion);
try {
//pid为0则代表这个进程为子进程，即新创建的应用程序进程
if (pid == 0) {
zygoteServer.setForkChild();
zygoteServer.closeServerSocket();
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
return handleChildProc(parsedArgs, descriptors, childPipeFd,
parsedArgs.mStartChildZygote);
} else {
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
handleParentProc(pid, descriptors, serverPipeFd);
return null;
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
5. Zygote
frameworks/base/core/java/com/android/internal/os/Zygote.java
在forkAndSpecialize中，最终将创建应用进程的任务交给nativeForkAndSpecialize，
nativeForkAndSpecialize最终是通过fork当前进程来创建一个子进程，
而fork后会有返回值给pid:
父进程中，fork返回新创建的子进程pid;
子进程中，fork返回0；
出现错误时，fork返回负数
public static int forkAndSpecialize(int uid, int gid, int[] gids, int runtimeFlags,
int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,
int[] fdsToIgnore, boolean startChildZygote, String instructionSet, String appDataDir,
int targetSdkVersion) {
ZygoteHooks.preFork();
// Resets nice priority for zygote process.
resetNicePriority();
int pid = nativeForkAndSpecialize(
uid, gid, gids, runtimeFlags, rlimits, mountExternal, seInfo, niceName, fdsToClose,
fdsToIgnore, startChildZygote, instructionSet, appDataDir);
// Enable tracing as soon as possible for the child process.
if (pid == 0) {
Zygote.disableExecuteOnly(targetSdkVersion);
Trace.setTracingEnabled(true, runtimeFlags);
// Note that this event ends at the end of handleChildProc,
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "PostFork");
}
ZygoteHooks.postForkCommon();
return pid;
}
6.启动ActivityThread
//ZygoteConnection.processOneCommand()
—> handleChildProc(
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,
parsedArgs.mRemainingArgs, null /* classLoader */);
} else {
....
}
ZygoteInit
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
RuntimeInit.redirectLogStreams();
//为当前的VM设置未捕获异常器
RuntimeInit.commonInit();
//Binder驱动初始化，该方法完成后，可通过Binder进行进程通信
ZygoteInit.nativeZygoteInit();
//主要调用SystemServer的main方法
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
在这个方法里会创建当前进程的Binder线程池，便于后续与其它进程通信，
然后调用了RuntimeInit的applicationInit方法，如下：
frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
...
final Arguments args = new Arguments(argv);
//args.startClass, args.startArgs,
// == ActivityThread.main
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
—> findStaticMain(
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader);//1
} catch (ClassNotFoundException ex) {
....
}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });//2
} catch (NoSuchMethodException ex) {
...
} catch (SecurityException ex) {
...
}
return new MethodAndArgsCaller(m, argv);
}
通过反射获取到android.app.ActivityThread类，
然后在注释2获取到ActivityThread的main方法，
最后通过main方法来构造MethodAndArgsCaller。
frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
static class MethodAndArgsCaller implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
Throwable cause = ex.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException(ex);
}
}
}
MethodAndArgsCaller其实是RuntimeInit的一个内部类并且继承了Runnable,
然后在run方法中会通过反射调用了mMethod方法，
此时mMethod是ActivityThread的main方法，
即run方法中将会执行ActivityThread的main方法，
在这里你可能会有疑问了，那这个run方法什么时候执行呢？
让我们来看看最开始的ZygoteInit的main方法。
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static void main(String argv[]) {
Runnable caller;
try {
....
caller = Zygote.initBlastulaPool();
if (caller == null) {
Log.i(TAG, "Accepting command socket connections");
//等待AMS的请求
caller = zygoteServer.runSelectLoop(abiList);
}
} catch (Throwable ex) {
Log.e(TAG, "System zygote died with exception", ex);
throw ex;
} finally {
zygoteServer.closeServerSocket();
}
//执行 ActivityThread.main
if (caller != null) {
caller.run();
}
}
7.启动总结
从分析Zygote进程接受请求并孵化应用进程的一开始，
我们就是分析zygoteServer.runSelectLoop(abiList)这个方法，
而分析到最后findStaticMain方法将返回MethodAndArgsCaller对象（继承Runnable）
,所以这时候在ZygoteInit的main方法caller会等于这个MethodAndArgsCaller对象，
显然caller不等于null，故最后会执行caller.run方法，
即执行ActivityThread的main方法。
于是应用进程成功启动ActivityThread。
