android4.0 WindowManagerService的分析
对于Activity，在ActivityThread.java在handleLaunchActivity会调用performLaunchActivity，而performLaunchActivity则调用Activity中的attach函数，实现创建window(实际是PhoneWindow)：
Activity.java
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config) {
//创建window
mWindow = PolicyManager.makeNewWindow(this);
mWindow.setCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
//获取WindowManager
mWindow.setWindowManager(null, mToken, mComponent.flattenToString(),
(info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
mWindowManager = mWindow.getWindowManager();
}
PolicyManager.java
public static Window makeNewWindow(Context context) {
//使用sPolicy来创建window
return sPolicy.makeNewWindow(context);
}
这里的sPolicy定义是：private static final IPolicy sPolicy;
那么，如何初始化？
private static final String POLICY_IMPL_CLASS_NAME =
"com.android.internal.policy.impl.Policy";
static {
// 获取Policy这个class并实例化
try {
Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);
sPolicy = (IPolicy)policyClass.newInstance();
}
}
再往下：
Policy.java
public class Policy implements IPolicy {
public Window makeNewWindow(Context context) {
/*可见，activity.attach中的PolicyManager.makeNewWindow(this)是新建一个PhoneWindow
*context则是Activity中实现的ContextImpl实例
*而PhoneWindow是window的子类，故而可以赋给window
*/
return new PhoneWindow(context);
}
……
}
由Policy的定义可知，Policy implement IPolicy，并且实现了它定义的接口。
/*至此，实现了创建一个PhoneWindow*/
接着Activity.attach往下：
//设置window的Callback，Activity是实现了Window.Callback的接口的
mWindow.setCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
//设置soft input mode
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
我们回到最初，我们说过，在ActivityThread中会在performLaunchActivity之后判断是否成功，并真正调用handleResumeActivity();
ActivityThread.java
final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward) {
ActivityClientRecord r = performResumeActivity(token, clearHide);
//这个layoutParams是在ActivityClientRecord 这里的。
WindowManager.LayoutParams l = r.window.getAttributes();
……
/*
*r是ActivityClientRecord，在performResumeActivity之前并没有将window加入到r中
*那么，activity如何创建并且是如何加入到这个activityClientRecord中的呢？
*/
if (r.window == null && !a.mFinished && willBeVisible) {
//在activity的attach函数中创建的activity的window赋给r.window
r.window = r.activity.getWindow();
//我们知道attach创建的是PhoneWindow，那PhoneWindow中DecorView如何创建的？
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
//WindowManager是ViewManager的子类
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
//将decor赋给Activity的mDecor
a.mDecor = decor;
//type的数值是1
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (a.mVisibleFromClient) {
a.mWindowAdded = true;
//将主View(decorView)添加到WindowManager中
wm.addView(decor, l);
}
}
}
我们在Context的分析中已经分析过，WindowManager实际上初始化的是WindowManagerImpl，通过它来进行各种操作，我们转到WindowManagerImpl.java分析addView
PhoneWindow.java
是这样获取DecorView的
public final View getDecorView() {
if (mDecor == null) {
installDecor();
}
return mDecor;
}
private void installDecor() {
if (mDecor == null) {
//创建DecorView，接着往下去看如何创建DecorView，DecorView是个什么？
mDecor = generateDecor();
mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
mDecor.setIsRootNamespace(true);
}
if (mContentParent == null) {
//这个mContentParent是干什么的？
mContentParent = generateLayout(mDecor);
}
}
private final class DecorView extends FrameLayout implements RootViewSurfaceTaker
{
public DecorView(Context context, int featureId) {
super(context);
mFeatureId = featureId;
}
/*
*DecorView中还实现了派发key event、key快捷方式等方法
*/
public boolean dispatchKeyEvent(KeyEvent event) {
……
}
public boolean dispatchKeyShortcutEvent(KeyEvent ev) {
……
}
}
由DecorView定义我们可以知道，DecorView是一个扩张的FrameLayout，它是所有当前的Activity中View的主View
WindowManagerImpl.java
public void addView(View view, ViewGroup.LayoutParams params, CompatibilityInfoHolder cih) {
addView(view, params, cih, false);
}
private void addView(View view, ViewGroup.LayoutParams params,
CompatibilityInfoHolder cih, boolean nest) {
//这说明将DecorView添加到WindowManager必须要满足下面这个条件，否则会报异常
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException(
"Params must be WindowManager.LayoutParams");
}
final WindowManager.LayoutParams wparams
= (WindowManager.LayoutParams)params;
ViewRootImpl root;
View panelParentView = null;
synchronized (this) {
//主要是查看要添加的View是否已经在mViews中了，若有就返回对应的index
int index = findViewLocked(view, false);
if (index >= 0) {
if (!nest) {
throw new IllegalStateException("View " + view
+ " has already been added to the window manager.");
}
//为什么这样，因为若添加了view到mViews，那么mRoots也对应添加
root = mRoots[index];
root.mAddNesting++;
// Update layout parameters.
view.setLayoutParams(wparams);
root.setLayoutParams(wparams, true);
return;
}
root = new ViewRootImpl(view.getContext());
//第一次添加view到mView，mViews是还没有分配空间的
if (mViews == null) {
index = 1;
mViews = new View[1];
mRoots = new ViewRootImpl[1];
mParams = new WindowManager.LayoutParams[1];
} else {
//这里奇怪的是，为什么将mViews、mRoots中内容先保存然后再拷贝一遍呢？
index = mViews.length + 1;
Object[] old = mViews;
mViews = new View[index];
System.arraycopy(old, 0, mViews, 0, index-1);
old = mRoots;
mRoots = new ViewRootImpl[index];
System.arraycopy(old, 0, mRoots, 0, index-1);
old = mParams;
mParams = new WindowManager.LayoutParams[index];
System.arraycopy(old, 0, mParams, 0, index-1);
}
index--;
//这里就完成了添加View到WindowManager
mViews[index] = view;
mRoots[index] = root;
mParams[index] = wparams;
}
//这一步非常重要
root.setView(view, wparams, panelParentView);
}
ViewRootImpl.java
public ViewRootImpl(Context context) {
getWindowSession(context.getMainLooper());
//获取当前activity的线程
mThread = Thread.currentThread();
//IWindow的代理，在ViewRootImpl中创建
//这里强调一下，创建W时传入this，代指ViewRootImpl的ContextImpl，而这个ContextImpl又是由
//WindowManagerImpl传入的ContextImpl，再之后就是当前的调用者的ContextImpl传递给//ContextImpl.java的获取Service时传入的。这样看来，在当前的上下文创建了一个实例，只要传入它的//Context，那么，都是可以通过Context找到这个当前调用者的
mWindow = new W(this);
}
public static IWindowSession getWindowSession(Looper mainLooper) {
synchronized (mStaticInit) {
if (!mInitialized) {
try {
//先获取InputMethodManager，然后用它调用InputMethodManagerService
InputMethodManager imm = InputMethodManager.getInstance(mainLooper);
//获取WindowManagerService中的Session,同时我们看到这里用到了
//InputMethodManagerService的mClient和ControlledInputConnectionWrapper
sWindowSession = Display.getWindowManager().openSession(
imm.getClient(), imm.getInputContext());
mInitialized = true;
} catch (RemoteException e) {
}
}
//注意：sWindowSession是个全局变量
return sWindowSession;
}
}
WindowManagerService.java
这个sWindowSession是在WindowManagerService中实现的，是client调用WindowManagerService的接口。
每一个ViewRoot对应在WindowManagerService中有一个sWindowSession
同时我们注意，这里传入的client是InputMethodManager中的IInputMethodClient类型的mClient
public IWindowSession openSession(IInputMethodClient client,
IInputContext inputContext) {
……
//创建一个Session并返回
//在这个Session的构造函数中有如下操作：
//mService.mInputMethodManager.addClient(client, inputContext, mUid, mPid);
//将InputMethodManger中的mClient添加进去了
Session session = new Session(this, client, inputContext);
return session;
}
我们接着，WindowManagerImpl往下看，在setView的最后会调用ViewRoot.setView()，这个是连接client和
WindowManagerService的关键地方：
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
……
try {
mOrigWindowType = mWindowAttributes.type;
//这里调用
res = sWindowSession.add(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mAttachInfo.mContentInsets, mInputChannel);
} catch (RemoteException e) {
……
}
}
Session.java
public int add(IWindow window, int seq, WindowManager.LayoutParams attrs,
int viewVisibility, Rect outContentInsets, InputChannel outInputChannel) {
//如此，将Client端提供给WindowManagerService的接口IWindow赋给WindowManagerService使用
return mService.addWindow(this, window, seq, attrs, viewVisibility, outContentInsets,
outInputChannel);
}
WindowManagerService.java
//主要是将PhoneWindow的回调函数IWindow传递给WindowManagerService
//outInputChannel是inputChannel
public int addWindow(Session session, IWindow client, int seq,
WindowManager.LayoutParams attrs, int viewVisibility,
Rect outContentInsets, InputChannel outInputChannel) {
WindowState win = null;
win = new WindowState(this, session, client, token,
attachedWindow, seq, attrs, viewVisibility);
……
win.attach();
if (outInputChannel != null && (attrs.inputFeatures
& WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
String name = win.makeInputChannelName();
InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
win.setInputChannel(inputChannels[0]);
inputChannels[1].transferTo(outInputChannel);
mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
}
}
在windowState.java中调用attach：
void attach() {
mSession.windowAddedLocked();
}
最后在Session.java中实现添加：
void windowAddedLocked() {
if (mSurfaceSession == null) {
mSurfaceSession = new SurfaceSession();
mService.mSessions.add(this);
}
mNumWindow++;
}
至此，正式建立activity的client和windowManagerService之间的联系：
ViewRootImpl 通过IWindowSession 访问 WindowManagerService
WindowManagerService通过IWindow访问ViewRootImpl