Android-Window(一)——初识Window
Android-Window(一)——初识Window
学习自
- 《Android开发艺术探索》
- https://blog.csdn.net/qian520ao/article/details/78555397?locationNum=7&fps=1 CSDN博主--凶残的程序员
- https://blog.csdn.net/tongsiw/article/details/78632063
开发环境
- SDK 24
- AS 3.0.1
- Everything 工具 用来快速查找无法直接通过AS找到的类文件
UI先行
Notion to say, UI对于一个APP的成功与否实在是太重要了，我想毕竟大多数人都是一个颜控。当然我也不例外，在我们选择一软件产品的时候，我们肯定会选择比较漂亮的哪一款。 在Android中漂亮的UI都是由各种各样的View来组成的，在很多时候，我们View都呈现在Activity上。 提到了View那么View的添加、更新和删除是由谁负责的呢？ 如果你的回答是Activity，请你试想一
下，不仅仅是Activity可以显示在屏幕上，Dialog、Toast，同样也可以显示在屏幕上。那么是不是他们都各自管理着自己的View呢？ 这样显然是不符合设计的！所以有必要让一个具有普适性的 东西 来承载View了。 这个 东西 就是我们今天的主角——Window.
Window是一个抽象的窗口的概念，负责承载视图，不管是Activity的视图，但是Dialog或者Toast的视图都是由Window来承担的。就像在Activity中调用的 setContentView 其中调用的Window的 setContentView 方法。可以这理解--Window是View的直接管理者。
WindowManager
要想知道，Window的工作原理，我们需要知道先怎么添加一个Window，要先添加Window需要通过WindowManager来完成。而WindowManager是一个接口继承自 ViewManager。其中有三个主要的方法:
- addView 负责穿件Window并向其中添加View
- updateViewLayout 更新Window中View的布局
- remoteView 通过移除Window中的View可以实现移除Window
class MainActivity : AppCompatActivity() {
lateinit var mButton: Button
lateinit var mLayoutParams: WindowManager.LayoutParams
lateinit var mWindowManager: WindowManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
addWindow()
}
/**
* 添加一个Window
* */
private fun addWindow() {
this.mButton = Button(this)
this.mButton.text = "Hello Button"
this.mLayoutParams = WindowManager.LayoutParams(
WindowManager.LayoutParams.WRAP_CONTENT,
WindowManager.LayoutParams.WRAP_CONTENT,
WindowManager.LayoutParams.TYPE_APPLICATION,
0,
PixelFormat.TRANSPARENT)
this.mWindowManager = this.windowManager
this.mLayoutParams.flags =
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
this.mLayoutParams.gravity = Gravity.TOP or Gravity.LEFT
this.mLayoutParams.x = 100
this.mLayoutParams.y = 300
this.mWindowManager.addView(this.mButton, this.mLayoutParams)
}
}
当Activity启动以后，我们可以发现我们定义的Button已经显示在屏幕上，因此我们已经做了一些设置，所以此界面还会显示在锁屏界面。但是当我们尝试去关闭此界面的时候，打印出了以下的Log:
android.view.WindowLeaked: Activity cn.shycoder.studywindow.MainActivity has leaked window android.widget.Button{9d337cc VFED..C.. ......ID 0,0-325,126} that was originally added here
这是因为当Activity已经销毁的时候，但是Activity中的我们刚才手动创建的Window还没有被销毁，造成了Window的内存泄漏。为了避免出现这种情况需要在Activity的 onDestroy 方法中将我们创建的Window移除掉。
override fun onDestroy() {
super.onDestroy()
this.mWindowManager.removeViewImmediate(this.mButton)
}
上面的添加Window的代码中，涉及到了几个比较重要的参数，我们依次来看一看。
Flag 参数表示Windows的属性，有很多不同的选项，通过这些选项可以控制Window的表现特性。
FLAG_NOT_FOCUSABLE
表示Window不需要获取焦点，也不需要接收各种输入事件，启用此FLAG的时候，也会隐式启用 NOT_TOUCH_MODAL 标签，最终事件会直接传递给下层具有焦点的Window。
FLAG_NOT_TOUCH_MODAL
在此模式在，系统会将当前Window区域以外的点击事件传递给底层的Window，当前区域内的点击事件则自己处理。一般都需要开启此FLAG。
FLAG_SHOW_WHEN——LOCKED
开启此模式会将Widow显示在锁屏界面上。
Type
Type 属性表示的Window的类型，一种分为三种 应用Window（我们的Activity中的Window），子Window(Dialog就是子Window)，系统 Window (Toast的Window就是一种系统Window)。其中子Window 比较特殊，必须依附于一个父Window中。如果你想要创建系统级的Window的话，得需要有相应的权限才行。
Window是分层的，每一个Window都有着对应的 z-ordered, 层级大的Window会覆盖在层级小的Window上面。
- 应用层级Window 1-99
- 子Window 1000-1999
- 系统Window 2000-2999
Window添加的过程
每一个Window都对应着一个View(一般是DecorView)和一个RootViewImpl，Window和View之间通过RootViewImpl来建立连接，View是Window的具体呈现。
在上面呢， 我们通过了WindowManager添加了一个Window，现在我们来分析一下Window添加的流程，当你了解了这个流程之后，就会明白为什么WindowManager调用了 addView 方法，却一直在说添加一个Window,而不是添加一个View了。
我们知道WindowManager 是一个接口其中并没有实现，WindowManager的实现类是 WindowManagerImpl，我们先来看这个类。
public final class WindowManagerImpl implements WindowManager {
//....
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}
@Override
public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
applyDefaultToken(params);
mGlobal.updateViewLayout(view, params);
}
@Override
public void removeView(View view) {
mGlobal.removeView(view, false);
}
//....
}
可以看到，WindowManagerImpl类也没有直接实现WindowManager，而是通过调用 mGlobal 的方法来实现，而mGlobal变量是一个 WindowManagerGlobal。在声明此成员变量的时候酒同时也进行了初始化(以单例的形式)。
在看addView的源码的时候，我们先来看一下WindowManagerGlobal 类中几个非常重要的集合变量:
private final ArrayList<View> mViews = new ArrayList<View>();
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
private final ArrayList<WindowManager.LayoutParams> mParams =
new ArrayList<WindowManager.LayoutParams>();
private final ArraySet<View> mDyingViews = new ArraySet<View>();
- mViews 存放了Window所对应的View
- mRoots 存放了所有Window的ViewRootImpl
- mParams 存放了所有Window的布局参数
- mDyingViews 存在的是正在被删除的View
我们来看一看WindowManagerGlobal是如何实现addView方法的。
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
//首先是一通参数合法性检查
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
if (display == null) {
throw new IllegalArgumentException("display must not be null");
}
//判断params对象是否是WindowManager.LayoutParams
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
}
final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
//如果parentWindow不为null则表示，当前要创建的Window是一个子Window
//通过adjustLayoutParamsForSubWindow方法做一些额外的参数调整
if (parentWindow != null) {
parentWindow.adjustLayoutParamsForSubWindow(wparams);
} else {
// If there's no parent, then hardware acceleration for this view is
// set from the application's hardware acceleration setting.
final Context context = view.getContext();
if (context != null
&& (context.getApplicationInfo().flags
& ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
}
}
ViewRootImpl root;
View panelParentView = null;
synchronized (mLock) {
// Start watching for system property changes.
if (mSystemPropertyUpdater == null) {
mSystemPropertyUpdater = new Runnable() {
@Override public void run() {
synchronized (mLock) {
for (int i = mRoots.size() - 1; i >= 0; --i) {
mRoots.get(i).loadSystemProperties();
}
}
}
};
SystemProperties.addChangeCallback(mSystemPropertyUpdater);
}
int index = findViewLocked(view, false);
if (index >= 0) {
if (mDyingViews.contains(view)) {
// Don't wait for MSG_DIE to make it's way through root's queue.
mRoots.get(index).doDie();
} else {
throw new IllegalStateException("View " + view
+ " has already been added to the window manager.");
}
// The previous removeView() had not completed executing. Now it has.
}
// If this is a panel window, then find the window it is being
// attached to for future reference.
if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
final int count = mViews.size();
for (int i = 0; i < count; i++) {
if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
panelParentView = mViews.get(i);
}
}
}
//实例化ViewRootImpl
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
//一顿添加集合的操作
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
// 将View显示出来
try {
root.setView(view, wparams, panelParentView);
} catch (RuntimeException e) {
// BadTokenException or InvalidDisplayException, clean up.
if (index >= 0) {
removeViewLocked(index, true);
}
throw e;
}
}
}
setView
在此方法中完成了Window的添加的过程。该方法的代码量非常多，现在只来看一下主要的代码：
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
//....
//异步请求刷新布局
//通过此方法会进行一系列的操作最终会完成View的 measure -> layout -> draw 的三大流程
requestLayout();
try {
//通过 mWindowSession 完成添加Window的操作
mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, mInputChannel);
} catch (RemoteException e) {
mAdded = false;
mView = null;
mAttachInfo.mRootView = null;
mInputChannel = null;
mFallbackEventHandler.setView(null);
unscheduleTraversals();
setAccessibilityFocus(null, null);
throw new RuntimeException("Adding window failed", e);
} finally {
if (restore) {
attrs.restore();
}
}
//.....
}
WindowSession
在上面的代码中，了解到setView方法最终通过 MWindowSession 完成了Window的添加，那么它是什么呢?
mWindowSession 的类型是Binder，其实现类是Session，从Session类我们可以推断出添加Window的过程一个 IPC(跨进程通信) 的过程。
@Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
Rect outOutsets, InputChannel outInputChannel) {
//调用WindowManagerService的addWindow方法
//在addWindow方法中将会完成Window的添加
return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
outContentInsets, outStableInsets, outOutsets, outInputChannel);
}
关于WindowManagerService这个类，因为博主水平有限，这里就不在瞎叨叨了。大家可以看一下 文章顶部的链接中的源码的分析。
从上面的一系列的源码中，我们发现，虽然是调用了WindowManager类的addView方法，其实最终还是添加了一个Window。不要被方法名称所迷惑。
类图
通过对上面Window添加的过程，我们可以得出以下的类图, 本图片是从 凶残的程序员 大神的博客中模仿来的.
Window删除的过程
前面我们已经分析了，WindowManager的实现类是 WindowManagerImpl 而在 WindowManagerImpl 则是调用了WindowManagerGlobal来实现，这里我们直接来看WindowManagerGlobal的 removeView 方法。
public void removeView(View view, boolean immediate) {
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
synchronized (mLock) {
//找到待删除的View的索引
int index = findViewLocked(view, true);
//获取到要删除的ViewRootImpl
View curView = mRoots.get(index).getView();
//删除View
removeViewLocked(index, immediate);
if (curView == view) {
return;
}
throw new IllegalStateException("Calling with view " + view
+ " but the ViewAncestor is attached to " + curView);
}
}
在上面的代码中，获取到了要溢出的View的索引，饭后通过调用 removeViewLocked 方法:
private void removeViewLocked(int index, boolean immediate) {
ViewRootImpl root = mRoots.get(index);
View view = root.getView();
if (view != null) {
InputMethodManager imm = InputMethodManager.getInstance();
if (imm != null) {
imm.windowDismissed(mViews.get(index).getWindowToken());
}
}
//通过RootViewImpl对象发送一个删除View的请求
boolean deferred = root.die(immediate);
if (view != null) {
view.assignParent(null);
//添加到待删除的View集合中
if (deferred) {
mDyingViews.add(view);
}
}
}
上面的主要的代码就是通过 ViewRootImpl 对象的 die 方法来删除 View，其分为两种情况 一种是 立即删除(同步的) 一种是发送消息等待删除(异步)。我们来看一下die方法的代码。
/**
* @param immediate True, do now if not in traversal. False, put on queue and do later.
* @return True, request has been queued. False, request has been completed.
*/
boolean die(boolean immediate) {
// Make sure we do execute immediately if we are in the middle of a traversal or the damage
// done by dispatchDetachedFromWindow will cause havoc on return.
//如果是同步删除的话直接调用 doDie方法完成删除操作
if (immediate && !mIsInTraversal) {
doDie();
return false;
}
if (!mIsDrawing) {
destroyHardwareRenderer();
} else {
Log.e(mTag, "Attempting to destroy the window while drawing!\n" +
" window=" + this + ", title=" + mWindowAttributes.getTitle());
}
//如果是异步的删除操作，那么发送一个消息，交给Handler去处理
mHandler.sendEmptyMessage(MSG_DIE);
return true;
}
从上面的代码中，我们可以清晰地看到，会通过两种同步和异步的方式来删除View。而不管是同步或者异步，删除View的时候都是调用的 doDie 方法。 我们来看一看doDie方法中做了些什么工作。
void doDie() {
checkThread();
if (LOCAL_LOGV) Log.v(mTag, "DIE in " + this + " of " + mSurface);
synchronized (this) {
if (mRemoved) {
return;
}
mRemoved = true;
//移除View
if (mAdded) {
//真正移除View的逻辑是在此方法中
dispatchDetachedFromWindow();
}
if (mAdded && !mFirst) {
destroyHardwareRenderer();
if (mView != null) {
int viewVisibility = mView.getVisibility();
boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
if (mWindowAttributesChanged || viewVisibilityChanged) {
// If layout params have been changed, first give them
// to the window manager to make sure it has the correct
// animation info.
try {
if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
& WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
mWindowSession.finishDrawing(mWindow);
}
} catch (RemoteException e) {
}
}
mSurface.release();
}
}
mAdded = false;
}
//将相关对象从WindowManagerGlobal的几个列表中删除
WindowManagerGlobal.getInstance().doRemoveView(this);
}
从doDie的源码中，我们可以了解到, 移除View的真正的逻辑在 dispatchDetachedFromWindow 方法中，我们来看看此方法。
void dispatchDetachedFromWindow() {
if (mView != null && mView.mAttachInfo != null) {
mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(false);
//调用View的dispatchDetachedFromWindow 方法，在此方法中会进行资源的回收
mView.dispatchDetachedFromWindow();
}
//一顿回收资源
mAccessibilityInteractionConnectionManager.ensureNoConnection();
mAccessibilityManager.removeAccessibilityStateChangeListener(
mAccessibilityInteractionConnectionManager);
mAccessibilityManager.removeHighTextContrastStateChangeListener(
mHighContrastTextManager);
removeSendWindowContentChangedCallback();
destroyHardwareRenderer();
setAccessibilityFocus(null, null);
mView.assignParent(null);
mView = null;
mAttachInfo.mRootView = null;
mSurface.release();
if (mInputQueueCallback != null && mInputQueue != null) {
mInputQueueCallback.onInputQueueDestroyed(mInputQueue);
mInputQueue.dispose();
mInputQueueCallback = null;
mInputQueue = null;
}
if (mInputEventReceiver != null) {
mInputEventReceiver.dispose();
mInputEventReceiver = null;
}
try {
//通过Session调用WinderManagerService完成移除Window的操作
//一次IPC
mWindowSession.remove(mWindow);
} catch (RemoteException e) {
}
// Dispose the input channel after removing the window so the Win
// doesn't interpret the input channel being closed as an abnorma
if (mInputChannel != null) {
mInputChannel.dispose();
mInputChannel = null;
}
mDisplayManager.unregisterDisplayListener(mDisplayListener);
unscheduleTraversals();
}
上面的代码比较长，但是大部分都是一些回收各种资源的代码，这些代码不需要我们太过注意。其中有两点需要我们注意的是 mView.dispatchDetachedFromWindow(); 这个方法将会对View所占用的资源进行回收。不同的View可能会对此方法有不同的实现，比如说ViewGroup的实现是 先调用子View的 dispatchDetachedFromWindow 方法 回收子View的资源，然后在回收自己所占用的资源。 在 View.dispatchDetachedFromWindow 方法中调用了 onDetachedFromWindow 方法，这个方法你可比较熟悉，因为当View从Window中被移除的时候，此方法会被调用, 我们通常会重写这个方法做一些回收资源的事情。 比如说:停止动画和线程等。
当调用完View的dispatchDetachedFromWindow方法后，紧接着就是一些释放资源的操作，这些我们不用管，在释放完资源后，就通过 mWindowSession.remove 调用了 WindowManagerService的移除Window的方法，哦，请不要忘记这是一个IPC的操作。
接着回到 doDie 方法，在doDie 方法的最后 调用了 WindowManagerGlobal的 doRemoveView方法，将相关的内容从各个集合中移除掉。至此移除Window的过程结束。
Window更新的过程
还是直接从WindowManagerGlobal的 updateViewLayout 方法开始
public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
//过滤异常
if (view == null) {
throw new IllegalArgumentException("view must not be null");
}
if (!(params instanceof WindowManager.LayoutParams)) {
throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
}
final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
view.setLayoutParams(wparams);
synchronized (mLock) {
int index = findViewLocked(view, true);
ViewRootImpl root = mRoots.get(index);
//将原来的LayoutParams移除掉
mParams.remove(index);
//将新的LayoutParams添加到原理的位置
mParams.add(index, wparams);
//通过ViewRootImpl来进行更新
root.setLayoutParams(wparams, false);
}
}
方法很简单，仅仅是设置了一下新的LayoutParams，然后调用 ViewRootImpl的 setLayoutParams 方法。
setLayoutParams方法代码比较多，但都是一些根据LayoutParams进行各种设置的代码，这里就不贴出来了，在setLayoutParams方法中比较重要的是调用了 scheduleTraversals 方法来对View进行重新布局，该方法最终会调用 performTraversals进行 View的 measure layout draw 三大过程。通知在方法中也会调用 relayoutWindow 方法,在该方法中会调用 Session 的 relayout 方法，最终会通过调用 WindowManagerService 的 relayoutWindow 方法来完成 Window的更新。这依然是一个IPC操作。
总结
最后，如果读者你能够看到这里，那我得十分感谢你能够忍受我这枯燥的文风，和我那三流的技术水平。本章的内容就到这了，如果本章的内容能够帮助你对Window有一个大致的了解，那对我来说真是一个值得高兴的事情，本文对Window的添加、删除和更新的流程做了一个简要的概览，并不是深入的分析其实现，主要目的是了解这些过程的脉络。Window是一个比较难的知识点，如果文中有任何纰漏，还望斧正。
