在图解Android - Zygote 和 System Server 启动分析一 文里,我们已经知道Android 应用程序是怎么创建出来的,大概的流程是 ActivityManagerService
-> Zygote
-> Fork App
, 然后应用程序在ActivityThread
中的进入loop
循环等待处理来自AcitivyManagerService
的消息。如果一个Android的应用有Acitivity
, 那它起来后的第一件事情就是将自己显示出来,这个过程是怎样的? 这就是本章节要讨论的话题。
Android 中跟窗口管理相关(不包括显示和按键处理)主要有两个进程,Acitivty
所在进程 和 WndowManagerService
所在进程(SystemServer
). 上图中用不同颜色区分这两个进程,黄色的模块运行在Activity
的进程里,绿色的模块则在System Server
内部,本文主要讨论的是WindowManager Service
。它们的分工是,Activity
进程负责窗口内View
的管理,而WindowManager Service
管理来自与不同Acitivity
以及系统的的窗口。
1. Acitivty显示前的准备工作
在图解Android - Zygote, System Server 启动分析中我们已经知道,一个新的应用被fork
完后,第一个调用的方法就是 ActivityThread
的main()
,这个函数主要做的事情就是创建一个ActivityThread
线程,然后调用loop()
开始等待。当收到来自 ActivityManager
的 LAUNCH_ACTIVITY
消息后,Activity
开始了他的显示之旅。下图描绘的是Activity
在显示前的准备流程。
图分为三部分, 右上角是Acitivity
应用的初始化。中间部分是Acitivity
与WindowManager Service
的交互准备工作,左下角是window显示的开始。本文主要描述后两部分,而Activity
的启动会放在图解Android - Android GUI 系统 (4) - Activity的生命周期里讲解。
-
Activity内部的准备过程,这里面有一个重要对象,
ContextImpl
生成,它是Context
类的具体实现,它里面封装了应用程序访问系统资源的一些基本API
,比如说,连接某一个服务并获取其IBinder
,发送Intent
,获取应用程序的信息,访问数据库等等,在应用看来,它就是整个AndroidSDK
的入口。ContextImpl
除了实现函数,里面还维护成员变量,其中有一个mDisplay
,代表当前应用输出的显示设备,如果应用没有特别指定,一般指向系统的默认显示输出,比如手机的液晶屏。 -
在
图解Android - Android GUI 系统 (1) - 概论
中我们已经介绍过ViewRootImpl
的地位相当与MVC架构中的C,Controller
是连接View
和Modal
的关键,所以需要首先创建它。当addView(view,param)
被调用的时候,一个ViewRoot
就被创建出来,addView()
的实现如下:public void addView(View view, ViewGroup.LayoutParams params) { mGlobal.addView(view, params, mDisplay, mParentWindow); } public void addView(View view, ViewGroup.LayoutParams params,Display display, Window parentWindow){ ... root = new ViewRootImpl(view.getContext(), display); ... }
这里的参数
View
是想要添加到WindowManagerService
的“window
", 一般一个Activity
只需要一个’Window
’, 所以,Acitivy
的默认实现是将DecorView
作为”Window
" 交给Window Manager Service
进行管理。Params
是Layout
相关的参数,里面包含有长,宽,边缘尺寸(Margin)等信息,mDisplay
就是这个窗口想要输出的Display
设备编号,由ContextImpl
传递过来。mParentWindow
就是Activity
的成员变量mWindow
,从最上面的类图可以很容易看出来,对于手机而言,就是一个PhoneWindow
对象,对于GoogleTV
,就是TVWindow
对象。 -
ViewRootImpl
在构造过程成初始化一些重要的成员变量,包括一个Surface
对象(注意这是一个空的Surface
对象,没有赋给任何有效的值,后面会通过CopyFromParcel
来填充),还有mChoreophaer
定时器(Singleton
对象,每个进程只有一个),与此同时,ViewRootImp
通过WindowManagerGlobal
创建了一个和WindowManagerService
的通话通道,接下来会利用这条通道做进一步的初始化工作。 -
还是在
addView()
里,WindowManagerImpl
拿到ViewRoot
对象后调用它的setView
方法,将view,layout
参数交给ViewRootImpl
开始接管。在setView()
里ViewRootImpl
做进一步的初始化工作,包括创建一个InputChannel
接收用户按键输入,enable
图形硬件加速,请求第一次的Layout
等等,这里只介绍跟WindowManagerService
有关系的一件事,就是向WindowManager service
报道,加入到WindowManager
的窗口管理队列中。这个函数是addToDisplay()
,int addToDisplay(in IWindow window, //提供给WMS的回调接口 in int seq, in windowManager.LayoutParams attrs, // layout参数 in int viewVisibility, in int layerStackId, // display ID out Rect outContentInsets, // WMS计算后返回这个View在显示屏上的位置 out InputChannel outInputChannel); // 用户输入通道Handle
addToDisplay()
最终会调到WindowManager Service
的addWindow()
接口。 -
addWindow()
里首先生成了一个WindowState
对象,它是ViewRootImpl
在WindowManager Service
端的代表。在它的构造函数里,WindowState
会生成IWindowId.Stub
对象和DeathRecipient
对象来分别监听Focus
和窗口死亡的信息,根据用户传进来的Window Type
计算出窗口的mBaseLayer
,mSubLayer
和mLastLayer
值,分别对应于主窗口,主窗口上弹出的子窗口(如输入法),以及动画时分别对应的ZOrder
值,(在本文后面会具体介绍),生成一个WindowStateAnimation
负责整个Window
的动画,并在内部将windowToken
,appWindowToken
等关联起来。 -
WindowManager Service
调用openInputChannelPair() and RegisterInputChannel()
, 创建用于通信的SocketPair
,将其传给InputManagerService
, 用于接下来的用户输入事件对应的响应窗口(参考Android的用户输入处理), -
最后,
WindowManagerService
调用WindowState
的attach()
,创建了一个Surface Session
并将Surface Session
,WindowSession
还有WindowState
三者关联起来. -
WindowManager Service
调用assignLayersLocked()
计算所有Window的Z-Order
。 -
addToDisplay()
返回,ViewRootImpl
和WindowManager Service
内部的准备工作就绪。ActivityThread
会发送ACTIVITY_RESUMED
消息告诉Activity
显示开始。可以是图还没有画,不是吗?对的,此刻Surface
还没有真正初始化(我们前面说过ViewRootImpl
只是New
了一个空的对象,需要有人往里面填东西)。底层存放绘制结果的Buffer
也没有创建,但是最多16ms以后这一切就会开始。
2. Choreographer
和 Surface
的创建
所有的图像显示输出都是由时钟驱动的,这个驱动信号称为VSYNC
。这个名词来源于模拟电视时代,在那个年代,因为带宽的限制,每一帧图像都有分成两次传输,先扫描偶数行(也称偶场)传输,再回到头部扫描奇数行(奇场),扫描之前,发送一个VSYNC
同步信号,用于标识这个这是一场的开始。场频,也就是VSYNC
频率决定了帧率(场频/2). 在现在的数字传输中,已经没有了场的概念,但VSYNC
这一概念得于保持下来,代表了图像的刷新频率,意味着收到VSYNC
信号后,我们必须将新的一帧进行显示。
VSYNC
一般由硬件产生,也可以由软件产生(如果够准确的话),Android 中VSYNC
来着于HWComposer
,接收者没错,就是Choreographer
。Choreographer
英文意思是编舞者,跳舞很讲究节奏不是吗,必须要踩准点。Choreographer
就是用来帮助Android的动画,输入,还是显示刷新按照固定节奏来完成工作的。看看Chroreographer
和周边的类结构。
从图中我们可以看到, Choreographer
是ViewRootImpl
创建的(Choreographer
是一个sigleton
类,第一个访问它的ViewRootImpl
创建它),它拥有一个Receiver
, 用来接收外部传入的Event
,它还有一个Callback Queue
, 里面存放着若干个CallbackRecord
, 还有一个FrameHandler
,用来handleMessage
, 最后,它还跟Looper
有引用关系。再看看下面这张时序图,一切就清楚了,
首先Looper
调用loop()
后,线程进入进入睡眠,直到收到一个消息。Looper
也支持addFd()
方法,这样如果某个fd上发生了IO操作(read/write
), 它也会从睡眠中醒来。Choreographer
的实现用到了这两种方式,首先他通过某种方式获取到SurfaceFlinger
进程提供的fd
,然后将其交给Looper
进行监听,只要SurfaceFlinger
往这个fd
写入VSync
事件,looper
便会唤醒。Lopper
唤醒后,会执行onVsync()
时间,这里面没有做太多事情,而是调用Handler
接口 sendMessageAtTime()
往消息队列里又送了一个消息。这个消息最终调到了Handler
(实际是FrameHandler
)的handleCallback
来完成上层安排的工作。为什么要绕这么大个圈?为什么不在onVSync
里直接handleCallback()
? 毕竟onVSync
和 handleCallback()
都在一个线程里。这是因为MessageQueue
不光接收来自SurfaceFlinger
的VSync
事件,还有来自上层的控制消息。VSync
的处理是相当频繁的,如果不将VSync
信号送人MessageQueue
进行排队,MessageQueue
里的事件就有可能得不到及时处理,严重的话会导致溢出。当然了,如果因为VSync
信号排队而导致处理延迟,这就是设计的问题了,这也是为什么Android文档里反复强调在Activity的onXXX()
里不要做太耗时的工作,因为这些回调函数和Choreographer
运行在同一个线程里,这个线程就是所谓的UI线程。
言归正传,继续往前,VSync
事件最终在doFrame()
里调了三次doCallbacks()
来完成不同的功能, 分别处理用户输入事件,动画刷新(动画就是定时更新的图片), 最后执行performTraversals()
,这个函数里面主要是检查当前窗口当前状态,比如说是否依然可见,尺寸,方向,布局是否发生改变(可能是由前面的用户输入触发的),分别调用performMeasure()
, performLayout
, performDraw()
完成测量,布局和绘制工作。我们会在后面详细学习这三个函数,这里我们主要看一下第一次进入performTraversals
的情况,因为第一次会做些初始化的工作,最重要的一件就是如本节标题,创建Surface
对象。
回看图2,我们可以看到Surface
的创建不是在Activity
进程里,而是在WindowManagerService
完成的(粉颜色)。当一个Activity
第一次显示的时候,Android显示切换动画,因此Surface
是在动画的准备过程中创建的,具体发生在类WindowStateAnimator
的createSurfaced()
函数。它最终创建了一个SurfaceControl
对象。SurfaceControl
是Android 4.3 里新引进的类,Google从之前的Surface
类里拆出部分接口,变成SurfaceControl
,为什么要这样? 为了让结构更清晰,WindowManagerService
只能对Surface
进行控制,但并不更新Surface
里的内容,分拆之后,WindowManagerService
只能访问SurfaceControl
,它主要控制Surface
的创建,销毁,Z-order
,透明度,显示或隐藏,等等。而真正的更新者,View会通过Canvas
的接口将内容画到Surface
上。那View怎么拿到WMService
创建的Surface
,答案是下面的代码里,surfaceControl
被转换成一个Surface
对象,然后传回给ViewRoot, 前面创建的空的Surface现在有了实质内容。Surface通过这种方式被创建出来,Surface对应的Buffer 也相应的在SurfaceFlinger内部通过HAL层模块(GRAlloc)分配并维护在SurfaceFlinger 内部,Canvas() 通过dequeueBuffer()
接口拿到Surface的一个Buffer,绘制完成后通过queueBuffer()还给SurfaceFlinger进行绘制。
SurfaceControl surfaceControl = winAnimator.createSurfaceLocked();
if (surfaceControl != null) {
outSurface.copyFrom(surfaceControl);
if (SHOW_TRANSACTIONS) Slog.i(TAG,
" OUT SURFACE " + outSurface + ": copied");
} else {
outSurface.release();
}
到这里,我们知道了Activity
的三大工作,用户输入响应,动画,和绘制都是由一个定时器驱动的,Surface
在Activity
第一次启动时由WindowManager Service
创建。接下来我们具体看一下View
是如何画在Surface Buffer
上的,而Surface Buffer
的显示则交由图解Android - Android GUI 系统 (3) - Surface Flinger 来讨论。
3. View的Measure
, Layout
和 Draw
直接从前面提到的performMeasure()
函数开始.
因为递归调用,实际的函数调用栈比这里显示的深得很多,这个函数会从view的结构树顶(DecorView
), 一直遍历到叶节点。中间会经过三个基类,DecorView
, ViewGroup
和 View
, 它们的类结构如下图所示:
所有可见的View(不包括DecorView
和 ViewGroup
)都是一个矩形,Measure
的目的就是算出这个矩形的尺寸, mMeasuredWidth
和 mMeasuredHeight
(注意,这不是最终在屏幕上显示的尺寸),这两个尺寸的计算受其父View
的尺寸和类型限制,这些信息存放在 MeasureSpec
里。MeasureSpec
里定义了三种constraints
,
/*父View对子View尺寸没有任何要求,其可以设任意尺寸*/
public static final int UNSPECIFIED = 0 << MODE_SHIFT;
/* 父View为子View已经指定了大小*/
public static final int EXACTLY = 1 << MODE_SHIFT;
/*父View没有指定子View大小,但其不能超过父View的边界 */
public static final int AT_MOST = 2 << MODE_SHIFT;
widthMeasureSpec
和 heightMeasureSpec
作为 onMeasure
的参数出入,子View根据这两个值计算出自己的尺寸,最终调用 setMeasuredDimension()
更新mMeasuredWidth
和 mMeasuredHeight
.
performMeasure()
结束后,所有的View都更新了自己的尺寸,接下来进入performLayout()
.
performLayout()
的流程和performMeasure
基本上一样,可以将上面图中的measure()
和 onMeasure
简单的换成 layout()
和 onLayout()
, 也是遍历整课View
树,根据之前算出的大小将每个View的位置信息计算出来。这里不做太多描述,我们把重心放到performDraw()
, 因为这块最复杂,也是最为重要的一块。
很早就玩过Android手机的同学应该能体会到Android2.3 到 Android 4.0 (其实Android3.0就有了,只是这个版本只在平板上有)的性能的巨大提升,UI界面的滑动效果一下变得顺滑很多,到底是framework的什么改动带来的?我们马上揭晓。。。(这块非本人工作领域,网上相关的资料也很少,所以纯凭个人砖研,欢迎拍砖指正)
Android Graphics Hardware Acceleration
OK, 如标题所述,最根本的原因就是引入了硬件加速, GPU是专门优化图形绘制的硬件单元,很多GPU(至少手机上的)都支持OpenGL
,一种开放的跨平台的3D绘图API。Android3.0以前,几乎所有的图形绘制都是由Skia完成,Skia是一个向量绘图库,使用CPU来进行运算, 所以它的performance
是一个问题(当然,Skia也可以用GPU进行加速,有人在研究,但好像GPU对向量绘图的提升不像对Opengl那么明显),所以从Android3.0 开始,Google用hwui
取代了Skia
,准确的说,是推荐取代,因为Opengl
的支持不完全,有少量图形api仍由Skia
完成,另外还要考虑到兼容性,硬件加速的功能并不是默认打开,需要程序在AndroidManifests.xml
或代码里控制开关。当然,大部分Canvas
的基本操作都通过hwui
重写了,hwui
下面就是Opengl
和后面的GPU,这也是为什么Android 4.0的launcher
变得异常流畅的缘故。OK,那我们接下来的重点就是要分析HWUI的实现了。
在此之前,简单的介绍一下OpenGL
的一些概念,否则很难理解。要想深入理解Opengl
,请必读经典的红包书:http://www.glprogramming.com/red/
Opengl
说白了,就是一组图形绘制的API
。 这些API都是一些非常基本的命令,通过它,你可以构造出非常复杂的图形和动画,同时,它又是跟硬件细节无关的,所以无需改动就可以运行在不同的硬件平台上(前提是硬件支持所需特性)。OpenGL
的输入是最基本几何元素(geometric primitives), 点(points), 线(lines), 多边形(polygons), 以及bitmap
和pixle data
, 他的输出是一个或两个Framebuffer
(真3D立体). 输入到输出的流程(rendering pipeline)如下图所示:
这里有太多的概念,我们只描述跟本文相关的几个:
vertex data
所有的几何元素(点线面)都可以用点(vertics)来描述, 每个点都对应三维空间中的一个坐标(x,y,z), 如下图所示,改变若干点的位置,我们便可以构造出一个立体的图形。
Triangles
OpenGL只能画非凹(nonconvex
)的多边形,可是现实世界中存在太多的凹性的物体,怎么办呢?通过连线可以将凹的物体分成若干个三角形,三角形永远都是凸(convex
)的。同时三角形还有一个特性,三个点可以唯一确定一个平面,所以用尽可能多的三角形就可以逼近现实世界中复杂的曲线表面,比如下图的例子,三角形的数目越多,球体的表示就越逼真。这也是为什么我们经常看到显卡的性能评测都以三角形的生成和处理作为一个非常重要的指标。
Display List
所有的Vertex
和Pixel
信息均可以存在Display List
里面,用于后续处理,换句话说,Display List 就是OpenGL命令的缓存。Display List的使用对OpenGL的性能提升有很大帮助。这个很容易理解,想象一个复杂的物体,需要大量的OpenGL命令来描绘,如果画一次都需要重新调用OpenGL API,并把它转换成Vertex data
,显然是很低效的,如果把他们缓存在Display List里,需要重绘的时候,发一个个命令通知OpenGL
直接从Display List
读取缓存的Vertex Data
,那势必会快很多,如果考虑到Opengl
是基于C/S架构,可以支持远程Client,这个提升就更大了。Display也可以缓存BitMap 或 Image, 举个例子,假设要显示一篇文章,里面有很多重复的字符,如果每个字符都去字库读取它的位图,然后告诉Opengl去画,那显然是很慢的。但如果将整个字库放到Display List里,显示字符时候只需要告诉Opengl这个字符的偏移量,OpenGL
直接访问Display List
,那就高效多了。
Pixel Data
Pixle data 包括位图(bitmap), Image, 和任何用于绘制的Pixel
数据(比如Fonts
)。通常是以矩阵的形式存放在内存当中。通过Pxiel data, 我们避免大量的图形绘制命令。同时通过现实世界中获取的纹理图片,可以将最终的物体渲染得更逼真。比如说画一堵墙,如果没有pixel data
,我们需要将每块砖头都画出来,也就是说需要大量的Vertex
。可是如果通过一张现实生活中拍摄的砖墙的图片,只需要4个点画出一个大矩形,然后上面贴上纹理,显然,速度和效果都要好得多。
FrameBuffer
Framebuffer就是Opengl用来存储结果的buffer
。Opengl的frameBuffer
类型有几种。Front Buffer
和 Back Buffer
, 分别用于显示和绘制,两者通过swapBuffer 进行交换。Left Buffer 和 Right buffer, 用于真立体(需要带眼镜的那种) 图像的左右眼Buffer,Stencil buffer, 用于禁止在某些区域上进行绘制,想像一下如果在一件T恤上印上图案,你是不是需要一个镂空的纸板?这个纸板就是stencil buffer.
OK, 对Opengl rendering pipeline
简单介绍到此,有兴趣的同学可以阅读opengl的红包书或运行一些简单的例子来深入理解Opengl。回到主题,仅仅使用Opengl 和 GPU 取代Skia 就能够大幅提升性能?答案当然不是,性能的优化很大程度上取决于应用,应用必须正确的使用Opengl命令才能发挥其最大效能。Android从pipeline 角度提供了两种机制来提升性能,一个就是我们刚才说到的Display List,另一个叫 Hardware Layer, 其实就是缓存的FrameBuffer, 比如说Android的墙纸,一般来说,他是不会发生变化的,因此我们可以将它缓存在Hardware Layer里,这张就不需要每次进行拷贝和重绘,从而大幅提升性能。
说白了,优化图形性能的核心在于 1)用硬件来减少CPU的参与,加速图形计算。 2)从软件角度,通过Display List 和 Hardware Layer, 将已经完成的工作尽可能的缓存起来,只做必须要做的事情,尽可能的减少运算量。
接下来看实现吧。
Canvas, Renderer, DisplayList, HardwareLayer 实现
这块代码相当的复杂,花了两天时间才把下面的图整理出来,但还是没有把细节完全吃透,简单的介绍一下框架和流程吧,如果有需要大家可以下来细看代码。
图中上半部为Java 代码,下半部为Native
层。先介绍里面出现的一些概念:
Canvas
Canvas是Java层独有的概念,它为View
提供了大部分图形绘制的接口。这个类主要用于纯软件的绘制,硬件加速的图形绘制则由HardwareCanvas
取代。
HardwareCanvas,GLES20Canvas, GLES20RecordingCanvas
hardwareCanvas
是一个抽象类,如果系统属性和应用程序指定使用硬件加速(现已成为默认),它将会被View(通过AttachInfo,如 下图所示) 引用来完成所有的图形绘制工作。GLES20Canvas
则是hardwareCanvas
的实现,但它也只是一层封装而已,真正的实现在Native 层,通过jni (andriod_view_gles20Canvas.cpp)
接口来访问底层的Renderer
, 进而执行OpenGL
的命令。 此外,GLES20Canvas还提供了一些静态接口,用于创建各类Renderer对象。
GLES20RecordingCanvas
继承GLES20Canvas
, 通过它调用的OpenGL命令将会存储在DisplayList
里面,而不会立即执行。
HardwareRenderer, GLRender, GL20Renderer
这三个类都是Java的Wrapper类,通过访问各种Canvas来控制绘制流程。详见下面两张时序图。
OpenGLRenderer, DisplayListRenderer, HardwareLayerRenderer
Java的HardwareCanvas
和 HardwareRenderer
在底层的对应实现。OpenGLRenderer是基类,只有它直接访问底层OpenGL库。DisplayListRenderer
将View通过GLES20Canvas
传过来的OpenGL 命令存在OpenGL的DisplayList
中。而HardwareLayerRenderer 管理HardwareLayer的资源。
GLES20
就是OpenGL ES 2.0 的API。它的实现一般由GPU的设计厂家提供,可以在设备的/system/lib/egl/ 找到它的so,名字为 libGLES_xxx.so, xxx
就是特定设备的代号,比如说,libGLES_gc.so
就是Vivante公司的GPU实现,libGLESv2_mali.so
就是ARM公司提供的Mali GPU的实现。它也可以由软件实现,比如说 libGLES_android.so
, 是Google提供的软件实现。
EGL
虽然对于上层应用来说OpenGL接口是跨平台的,但是它的底层(GPU)实现和平台(SoC)是紧密相关的,于是OpenGL组织定义一套接口用来访问平台本地的窗口系统(native platform window system),这套接口就是EGL
,比如说 eglCreateDisplay(), eglCreateSurface(), eglSwapBuffer()
等等。EGL的实现一般明白libEGL.so
, 放在/system/lib/egl/ 下面。
View, Canvas, Renderer, DisplayList, HardwareLayer 的关系如下图所示:
每个View都对应一个DisplayList, 在Native层代码里管理。每个View通过GLESRecordingCanvas 以及Native层对应的DisplayRenderer 将OpenGL命令存入DisplayList.最后View 通过GLES20Canvas 通知OpenGLRenderer
执行这些DisplayList
里面的OpenGL
命令。
他们的生命周期如下图所示 (粉红代表 New, 黑色代表 Delete, 黄色代表Java类,蓝色代表C++, 绿色代表JNI).
- 如果系统支持硬件加速,
ViewRootImpl
首先创建一个GL20Renderer
, 存在成员变量mHardwareRenderer
里。 Surafce
是绘画的基础,如果不存在,HardwareRenderer
会调用GLRenderer
->createEglSurface()
创建一个新的Surface
。Surface
创建好后,接着生成Canvas
,因为大部分应用程序不会直接操作Surface
。- 在
Canvas
的构造函数里,会依次创建Native
层对应的OpenGLRenderer
对象,它会直接访问库libGLES_xxx
提供的OpenGL ES API
,来负责整个View
树的绘制工作。 - 与此同时,一个
CanvasFinalizer
成员对象也会被创建,它保存刚刚创建出来的OpenGLRenderer
指针,当它的finalizer()
函数被调用是,负责将其销毁,回收资源。 - 在运行过程中,如果窗口死掉或者不在可见,
ViewRootImpl
会调用DestroyHardwareResource()
来释放资源。这里会最终将底层创建的Hardware Layer
回收。 - 同时Java端的
GLES20Layer
对象也会因为被赋值NULL
被GC
在将来回收。 - 接下来,
ViewRootImpl
调用destroyHardwareRenderer()
将之前创建的Native Renderer(DisplayListRenderer,OpenGLRenderer)
依次回收。 - 最后将Java 层的
mHardwareRenderer
赋空,GC
将会回收最开始创建的GL20Renderer
对象。支持,一个View
树的生命周期完成,所有资源清楚干净。
等等!好像少了点什么,怎么没有DisplayList
? 前面不是说它是性能优化的帮手之一吗?对了,上面只介绍了绘制的开始和结尾,在View的生命周期中,还有最重要的一步,Draw
还没有被介绍,DisplayList
相关的操作就是在Draw()
里面完成的。
Draw 流程
绕了好大一圈,终于回到最初的话题,Android是怎样将View画出来的? 让我们按照图中的序号一一进行讲解。(黄色:Java, 绿色:C++,蓝色:JNI,粉色:New, 黑色:Delete).
- 首先,
ViewRootImpl
直接访问的HardwareRenderer
对象,首先在BeginFrame()
里获取EGLDisplay
(用于显示) 和初始化一个EGLSurface
,OpenGL
将在这个Surface
上进行绘图。关于EGLDisplay
和EGLSurface
将在 图解Android - Android GUI 系统 (3) - Surface Flinger里详细描述。 - 我们前面说过,Android 4.0 带来的图形性能的提升,有很大程度是
DisplayList
带来的,所以,HardwareRenderer
接下来就通过buildDisplayList()
创建整个View树的DisplayList.最开始,GL20Renderer
为View生成了一个GLES20DisplayList,这是一个影子类,没有实际用途,主要用来管理Native层的DisplayList的销毁。 - View 调用刚刚生成的
GLES20DisplayList
的start()
方法,真正开始构建DisplayList
的上下文。obtain()
函数里会判断是否mCanvas
已经存在,如果没有则New
一个新的GLES20RecordingCanvas
对象。 - 创建与
GLES20RecordingCanvas
一一对应的Native
层的DisplayListRenderer
。 - 3,4是一个递归的过程,直到所有的
View
的DisplayList
上下文生成,View才真正开始Draw()
,这里,OpenGL命令(Op)不会被立即执行,而是被存储到刚刚生成的DisplayListRenderer
里。 - 接着View调用
GLESDisplayList
的end()
方法,这里Native层的DisplayList
对象才真正被创建出来,Java 和 Native 的DisplayList
对象一一对应起来。 end()
方法最后,调用GLES20RecordingCanvas.recycle()
方法,首先将Native的DisplayListRender
进行重新初始化,然后将刚才创建出来的临时对象赋NULL值(GLES20RecordingCanvas
和GLES20DisplayList
),因为它们的使命已经完成,将View的OpenGL命令存储在Native层的DisplayList对象里。- GC() 被调用后,
GLES20RecordingCanvas
和GLES20DisplayList
被释放,相应的Finalizer
对象方法会被调用,进而调用Natice
层的deleteDisplayListDefered()
, 将之前不用的DisplayList
送入Caches
的Gabage
队列中,等待回收。(这是在Native
层实现的类似Java GC的机制) - 到此,所有的
DisplayList
上下文准备就绪。进入preDraw
状态,在GL20Renderer
的onPreDraw()
方法里,最终调用到底层的clearGarbage
将上一次绘图操作的DisplayList在底层释放。 HardwareRenderer
调用GLES20Canvas
的drawDisplayList()
, 通知 Native层的OpenGLRenderer
,其最终调用每个DisplayList
的Replay()
方法执行OpenGL命令。- 所有OpenGL命令执行完后, 图形被绘制到第一步生成的
EGLSurface
,hardwareRender
调用GLES20Canvas
的eglSwapBuffers()
交换Buffer
,交由SurfaceFlinger
在下一个VSync
到来时进行显示。
Hardware Layer
即便是使用了DisplayList
, 对于复杂的图形,仍然需要执行大量的OpenGL
命令,如果需要对这一部分进行优化,就需要使用到 HardwareLayer
对绘制的图形进行缓存,如果图形不发生任何变化,就不需要执行任何OpenGL
命令,而是将之前缓存在GPU内存的Buffer
直接与其他View
进行合成,从而大大的提高性能。这些存储在GPU内部的Buffer就称为 Hardware Layer。除了Hardware Layer
, Android 还支持Software Layer
,和Hardware Layer
不同之处在于,它不存在于GPU内部,而是存在CPU的内存里,因此它不经过前面所说的 Hardware Render Pipeline, 而是走Android最初的软件Render pipeline。不管是Hardware Layer 还是 Software Layer, 在Draw()
内部均称为Cache
,只要有Cache的存在,相对应的View将不用重绘,而是使用已有的Cache。Hardware Layer, Software Layer
和 Display List
是互斥的,同时只能有一种方法生效(当然,Hardware Layer
的第一次绘制还是通过Display List
完成),下表总结了它们的差别, 从中可以看到,Hardware Layer 对性能的提升是最大的,唯一的问题是占用GPU的内存(这也是为什么显卡的内存变得越来越大的原因之一),所以一般来说,Hardware Layer使用在那些图片较为复杂,但不经常改变,有动画操作或与其他窗口有合成的场景,比如说WallPaper, Animation 等等。
Enabled if | GPU accelerated? | Cached in | Performance(from Google I/O 2001) | Usage | |
---|---|---|---|---|---|
Display List | Hardware Accelerated = True | Y | GPU DisplayList | 2.1 | Complex View |
Hardware Layer | LayerType = HARDWARE | Y | GPU Memory | 0.009 | Complex View, Color Filter(颜色过滤), Alpha blending (透明度设置), etc. |
Software Layer | LayerType = SOFTWARE | N | CPU Memory | 10.3 | No Hardware Accelerated, Color filter, Alpha blending, etc. |
重绘 - Invaliate
前面介绍了View的第一次绘制的过程。但是一个View在运行中终究是要发生变化的,比如说,用户在TextView的文字发生了改变,或者动画导致View的尺寸发生变化,再或者说一个对话框弹出然后又消失,被遮挡的部分重新露了出来,这些都需要对View进行重绘。在介绍重绘之前,我们先了解一下View内部的一些Flag 定义。
Flags | == 1 | Set at | Clear at |
---|---|---|---|
PFFLAG_HAS_BOUNDS | 1: View has size and Position set. 0: setFrame() was not called yet | View::setFrame() | |
PFFLAG_DRAWN | 1: Has been drawn, only after which, invalidate() is valid. 0: not drawn, need to draw() later to show it. | ViewGroup::addViewInLayout ViewGroup::attachViewToParent View::draw() View::buildDrawingCache() View::getHardwareLayer() View::invalidate() View::setLeft/Right/Top/Bottom() | View::invalidate() |
PFFLAG_DRAWING_CACHE_VALID | 1: Has DisplayList / Hardware Layer / Software Layer 0: No Cache, using Software rendering path. | View::GetHardwareLayer() View::GetDisplayList() | View::invalidate(true) View::invalidate(rect) View::invalidateChild() |
PFFLAG_INVALIDATED | View is specifically invalidated, not just dirty(child for instance). DisplayList will be recreated if set. | ViewGroup::addViewInLayout ViewGroup::attachViewToParent View::force/requestLayout() View::invalidate() | View::draw() |
PFLAG_DIRTY | Set to indicate that the view need to be redrawn. (use displaylist cache if PFFLAG_INVALIDATED flag is false) | View::invalidate() | ViewGroup::addViewInLayout ViewGroup::attachViewToParent View::draw() View::buildDrawingCache() View::getHardwareLayer() View::invalidate() View::setLeft/Right/Top/Bottom() View::getDisplayList() |
PFLAG_DIRTY_OPAQUE | DIRTY because of OPAQUE (hidden by others). | View::invalidateChild() | ? |
从上表可以看出,View
通过内部这些Flag来控制重绘。基本上重绘分两种情况,一种是需要重新生成DisplayList
, 另外一种是使用之前已有的Cache
,包括DisplayList
或者是Hardware Layer
。使用哪种重绘方式由当前View
的Flags
,以及应用程序传入的参数决定。控制它的就是一组Invalidate()
函数。
void invalidate(boolean invalidateCache) {
if (skipInvalidate()) { //如果View不可见,并且不再动画退出过程中(fade out),将不执行Invalidate().
return;
}
if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) == (PFLAG_DRAWN | PFLAG_HAS_BOUNDS) || //DRAWN -> 已经被Draw()过
(invalidateCache && (mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID) || //有Cache,且被要求重新刷新Cache
(mPrivateFlags & PFLAG_INVALIDATED) != PFLAG_INVALIDATED || isOpaque() != mLastIsOpaque) //没有正在Invalidate()中
{
mLastIsOpaque = isOpaque();
mPrivateFlags &= ~PFLAG_DRAWN;
mPrivateFlags |= PFLAG_DIRTY;
if (invalidateCache) {
mPrivateFlags |= PFLAG_INVALIDATED;
mPrivateFlags &= ~PFLAG_DRAWING_CACHE_VALID; //标记将来清除Cache,如果为false,则有系统根据Dirty Region决定是否需要重新生成DisplayList。
}
final AttachInfo ai = mAttachInfo;
final ViewParent p = mParent;
if (!HardwareRenderer.RENDER_DIRTY_REGIONS) { //系统不支持Dirty Region,必须重绘整个区域, 基本不会进去
}
if (p != null && ai != null) {
final Rect r = ai.mTmpInvalRect;
r.set(0, 0, mRight - mLeft, mBottom - mTop);
p.invalidateChild(this, r); //通知兄弟view(有共同的ViewParent(ViewGroup 或者 ViewRoot)进行 Invalidate.
}
}
}
假如所有的条件都支持重绘,便会调用到ViewParent
的invalidateChild()
方法。(ViewParent
是一个接口类,它的实现类是ViewGroup
和 ViewRootImpl
。)这个方法会从当前View开始,向上遍历到ViewRoot
或者 到某个ViewGroup
的区域与当前View的Dirty
区域没有重叠为止。途中的每个ViewGroup
都会被标记上Dirty
。在接下来VSYNC
的performDraw()
里,ViewRootImpl
会遍历所有标记Dirty的ViewGroup
,然后找到里面标记Dirty
的View
,只有这些View的DisplayList
被重建,而其他实际上没有变化的View
(虽然它们在同一个ViewGroup
里面),如果没有Hardware Layer
, 只需重新执行对应Display List
里面的OpenGL 命令。通过这种方式,Android只重绘需要重绘的View
,从软件层面将GPU的输入最小化,从而优化图形性能。
4. Windows 的管理
到此,我们已经了解了一个Acitivty(Window)
是如何画出来的,让我们在简要重温一下这个过程:
- Acitivity创建,
ViewRootImpl
将窗口注册到WindowManager Service
,WindowManager Service
通过SurfaceFlinger
的接口创建了一个Surface Session
用于接下来的Surface
管理工作。 - 由
Surface Flinger
传上来的VSYNC
事件到来,Choreographer
会运行ViewRootImpl
注册的Callback
函数, 这个函数会最终调用performTraversal
遍历View树里的每个View
,在第一个VSYNC
里,WindowManager Service
会创建一个SurafceControll
对象,ViewRootImpl
根据Parcel
返回的该对象生成了Window对应的Surface
对象,通过这个对象,Canvas
可以要求Sruface Flinger
分配OpenGL绘图用的Buffer
。 View
树里的每个View
会根据需要依次执行measure(),layout()
和draw()
操作。Android在3.0之后引入了硬件加速机制,为每个View
生成DisplayList
,并根据需要在GPU内部生成Hardware Layer
,从而充分利用GPU的功能提升图形绘制速度。- 当某个View发生变化,它会调用
invalidate()
请求重绘,这个函数从当前View
出发,向上遍历找到View Tree
中所有Dirty
的 View 和ViewGroup
, 根据需要重新生成DisplayList
,并在drawDisplayList()
函数里执行OpenGL命令将其绘制在某个Surface Buffer
上。 - 最后,
ViewRootImpl
调用eglSwapBuffer
通知OpenGL
将绘制的Buffer
在下一个VSync
点进行显示。
注意的是,上面讨论的只是一个窗口的流程,而Android是个多窗口的系统,窗口之间可能会有重叠,窗口切换会有动画产生,窗口的显示和隐藏都有可能会导致资源的分配和释放,这一切需要有一个全局的服务进行统一的管理,这个服务就是我们大名鼎鼎的Window Manager Service
(简写 WMS
).
其实Window Manager Service
的工作不仅仅是管理窗口,还会跟很多其他服务打交道,如 InputManager Service
, AcitivityManager Service
等等,但本章只讨论它在Window Manager
方面的工作,下图中红色标记部分。
Layout
首先来看Layout
。Layout
是Window Manager Service
重要工作之一,它的流程如下图所示:
- 每个
View
将期望窗口尺寸交给WMS(WindowManager Service
). - WMS 将所有的窗口大小以及当前的Overscan区域传给WPM (
WindowPolicy Manager
). - WPM根据用户配置确定每个
Window
在最终Display
输出上的位置以及需要分配的Surface
大小。 - 返回这些信息给每个
View
,他们将在给会的区域空间里绘图。
Android里定义了很多区域,如下图所示
Overscan
:
Overscan 是电视特有的概念,上图中黄色部分就是Overscan
区域,指的是电视机屏幕四周某些不可见的区域(因为电视特性,这部分区域的buffer内容显示时被丢弃),也意味着如果窗口的某些内容画在这个区域里,它在某些电视上就会看不到。为了避免这种情况发生,通常要求UI不要画在屏幕的边角上,而是预留一定的空间。因为Overscan的区域大小随着电视不 同而不同,它一般由终端用户通过UI指定,(比如说GoogleTV里就有确定Overscan大小的应用)。
OverscanScreen, Screen
:
OverscanScreen
是包含Overscan
区域的屏幕大小,而Screen
则为去除Overscan
区域后的屏幕区域, OverscanScreen > Screen
.
Restricted and Unrestricted:
某些区域是被系统保留的,比如说手机屏幕上方的状态栏(如图纸绿色区域)和下方的导航栏,根据是否包括这些预留的区域,Android把区域分为Unrestricted Area
和 Resctrited Aread
, 前者包括这部分预留区域,后者则不包含, Unrestricted area > Rectricted area
。
mFrame, mDisplayFrame, mContainingFrame
Frame
指的是一片内存区域, 对应于屏幕上的一块矩形区域. mFrame
的大小就是Surface
的大小, 如上上图中的蓝色区域. mDisplayFrame
和 mContainingFrame
一般和mFrame
大小一致. mXXX
是Window(ViewRootImpl, Windowstate)
里面定义的成员变量.
mContentFrame, mVisibleFrame
一个Surface
的所有内容不一定在屏幕上都得到显示, 与Overscan
重叠的部分会被截掉, 系统的其他窗口也会遮挡掉部分区域 (比如短信窗口,ContentFrame
是800x600(没有Status Bar
), 但当输入法窗口弹出是,变成了800x352), 剩下的区域称为Visible Frame
, UI内容只有画在这个区域里才能确保可见. 所以也称为Content Frame
. mXXX
也是Window(ViewRootImpl, WindowState)
里面定义的成员变量.
Insects
insets
的定义如上图所示, 用了表示某个Frame
的边缘大小.
Layout
在WMS
内部的时序如下图所示,外部调整Overscan
参数或View内部主动调用requestLayout()
都会触发WMS
的重新layout
,layout
完成后,WMS会通过IWindow
的resized()
接口通知ViewRoot
, 最终会调用requestLayout()
, 并在下一个VSYNC
事件到来时更新。
计算Layout
主要有图中三个红色的函数完成,它们代码很多,涉及到很多计算,但只要对着我们上面给的三个图来看,不难看出它的意思,本文将不详细深入。
Animation
Animation
的原理很简单,就是定时重绘图形。下面的类图中给出了Android跟Animation
相关的类。
Animation:
Animation
抽象类,里面最重要的一个接口就是applyTranformation
, 它的输入是当前的一个描述进度的浮点数(0.0 ~ 1.0), 输出是一个Transformation
类对象,这个对象里有两个重要的成员变量,mAlpha
和 mMatrix
, 前者表示下一个动画点的透明度(用于灰度渐变效果),后者则是一个变形矩阵,通过它可以生成各种各样的变形效果。Android提供了很多Animation
的具体实现,比如RotationAnimation
, AlphaAnimation
等等,用户也可以实现自己的Animation
类,只需要重载applyTransform
这个接口。注意,Animation
类只生成绘制动画所需的参数(alpha
或 matrix
),不负责完成绘制工作。完成这个工作的是Animator
.
Animator:
控制动画的‘人’, 它通常通过向定时器Choreographer
注册一个Runnable
对象来实现定时触发,在回调函数里它要做两件事情:1. 从Animation那里获取新的Transform
, 2. 将Transform里的值更新底层参数,为接下来的重绘做准备。动画可以发生在Window上,也可以发生在某个具体的View。前者的动画会通过SurfaceControl直接在某个Surface上进行操作(会在SurfaceFlinger里详细描述),比如设置Alpha值。后者则通过OpenGL完成(生成我们前面提过的DisplayList).
WindowStateAnimator, WindowAnimator, AppWindowAnimator:
针对不同对象的Animator
. WindowAnimator
, 负责整个屏幕的动画,比如说转屏,它提供Runnable
实现。WindowStateAnimator
, 负责ViewRoot
,即某一个窗口的动画。AppWindowAnimator
, 负责应用启动和退出时候的动画。这几个Animator
都会提供一个函数,stepAnimationLocked()
, 它会完成一个动画动作的一系列工作,从计算Transformation
到更新Surface
的Matrix
.
具体来看一下Window的Animation
和View
的Animation
WindowManagerService
的scheduleAnimationLocked()
将windowAnimator
的mAnimationRunnable
注册到定时器Choreographer
.- 如果应用程序的
res/anim/
下有xml
文件定义animation
,在layout
过程中,会通过appTransition
类的loadAnimation()
函数将XML
转换成Animation_Set
对象,它里面可以包含多个Animation
。 - 当下一个
VSYNC
事件到来,刚才注册的Callback
函数被调用,即WindowAnimator
的mAnimationRunnable
,里面调用animateLocked()
, 首先,打开一个SurfaceControl
的动画会话,animationSession
。 - 首先执行的动画是
appWindowAnimator
, 如果刚才loadAnimation()
返回的animation
不为空,便会走到Animation
的getTransform()
获取动画的参数,这里可能会同时有多个动画存在,通过Transform
的compose()
函数将它们最终合为一个。 - 接下来上场的是
DisplayContentsAnimator
,它主要用来实现灰度渐变和转屏动画。同样,首先通过stepAnimation()
获取动画变形参数,然后通过SurfaceControl
将其更新到SrufaceFlinger
内部对应的Layer
.这里首先完成的是转屏的动画 - 然后就是每个窗口的动画。后面跟着的
perpareSurfaceLocked()
则会更新参数。 Wallpaper
的动画。- 接下来,就是上面提到的
DisplayContentsAnimator
的第二部分,通过DimLayer
实现渐变效果。 Surface
的控制完成后,关闭对话。然后scheduleAnimationLocked()
规划下一步动画。- 接下来的
performDraw()
会把所有更新参数的View
,或Surface
交给OpenGL
或HWcomposer
进行处理,于是我们就看到了动画效果。
View
的动画实现步骤与Windows 类似,有兴趣的同学可以去看View.java
的 drawAnimation()
函数。
管理窗口
WMS
里面管理着各式各样的窗口, 如下表所示(在WindowManagerService.java
中定义)
类型 | 用途 | |
---|---|---|
mAnimatingAppToken | ArrayList<AppWindowToken> | 正在动画中的应用 |
mExistingAppToken | ArrayList<AppWindowToken> | 退出但退出动画还没有完成的应用。 |
mResizingWindows | ArrayList<WindowState> | 尺寸正在改变的窗口,当改变完成后,需要通知应用。 |
mFinishedStarting | ArrayList<AppWindowToken> | 已经完成启动的应用。 |
mPendingRemove | ArrayList<WindowState> | 动画结束的窗口。 |
mLosingFocus | ArrayList<WindowState> | 失去焦点的窗口,等待获得焦点的窗口进行显示。 |
mDestorySurface | ArrayList<WindowState> | 需要释放Surface的窗口。 |
mForceRemoves | ArrayList<WindowState> | 需要强行关闭的窗口,以释放内存。 |
mWaitingForDrawn | ArrayList<Pair<WindowState, IRemoteCallback>> | 等待绘制的窗口 |
mRelayoutWhileAnimating | ArrayList<WindowState> | 请求relayout但此时仍然在动画中的窗口。 |
mStrictModeFlash | StrictModeFlash | 一个红色的背景窗口,用于提示可能存在的内存泄露。 |
mCurrentFocus | WindowState | 当前焦点窗口 |
mLastFocus | WindowState | 上一焦点窗口 |
mInputMethodTarget | WindowState | 输入法窗口下面的窗口。 |
mInputMethodWindow | WindowState | 输入法窗口 |
mWallpaperTarget | WindowState | 墙纸窗口 |
mLowerWallpaperTarget | WindowState | 墙纸切换动画过程中Z-Order 在下面的窗口 |
mHigherWallpaperTarget | WindowState | 墙纸切换动画过程中Z-Order 在上面的窗口 |
可以看到这里大量的用到了队列,不同的窗口,或同一窗口在不同的阶段,可能会出现在不同的队列里。另外因为WindowManager Service
的服务可能被很多个线程同时调用,在这种复杂的多线程环境里,通过锁来实现线程安全非常难以实现,一不小心就可能导致死锁,所以在 WindowManager
内专门有一个执行线程(WM Thread
)来将所有的服务请求通过消息进行异步处理,实现调用的序列化。队列是实现异步处理的常用手段。队列加Looper
线程是Android 应用常用的设计模型。
此外,WindowManager
还根据Window的类型进行了分类(在WindowManager.java
),如下表,
类型 | 常量范围 | 子类 | 常量值 | 说明 | 例子 |
---|---|---|---|---|---|
APPLICATION_WINDOW | 1~99 | TYPE_BASE_APPLICATION | 1 | ||
TYPE_APPLICATION | 2 | 应用窗口 | 大部分的应用程序窗口 | ||
TYPE_APPLICATION_STARTING | 3 | 应用程序的Activity显示之前由系统显示的窗口 | |||
LAST_APPLICATION_WINDOW | 99 | ||||
SUB_WINDOW | 1000~1999 | FIRST_SUB_WINDOW | 1000 | ||
TYPE_APPLICATION_PANEL | 1000 | 显示在母窗口之上,遮挡其下面的应用窗口。 | |||
TYPE_APPLICATION_MEDIA | 1001 | 显示在母窗口之下,如果应用窗口不挖洞,即不可见。 | SurfaceView,在小窗口显示时设为MEDIA, 全屏显示时设为PANEL | ||
TYPE_APPLICATION_SUB_PANEL | 1002 | ||||
TYPE_APPLICATION_ATTACHED_DIALOG | 1003 | ||||
TYPE_APPLICATION_MEIDA_OVERLAY | 1004 | 用于两个SurfaceView的合成,如果设为MEDIA, | |||
则上面的SurfaceView 挡住下面的SurfaceView | |||||
SYSTEM_WINDOW | 2000~2999 | TYPE_STATUS_BAR | 2000 | 顶部的状态栏 | |
TYPE_SEARCH_BAR | 2001 | 搜索窗口,系统中只能有一个搜索窗口 | |||
TYPE_PHONE | 2002 | 电话窗口 | |||
TYPE_SYSTEM_ALERT | 2003 | 警告窗口,在所有其他窗口之上显示 | 电量不足提醒窗口 | ||
TYPE_KEYGUARD | 2004 | 锁屏界面 | |||
TYPE_TOAST | 2005 | 短时的文字提醒小窗口 | |||
TYPE_SYSTEM_OVERLAY | 2006 | 没有焦点的浮动窗口 | |||
TYPE_PRIORITY_PHONE | 2007 | 紧急电话窗口,可以显示在屏保之上 | |||
TYPE_SYSTEM_DIALOG | 2008 | 系统信息弹出窗口 | 比如SIM插上后弹出的运营商信息窗口 | ||
TYPE_KEYGUARD_DIALOG | 2009 | 跟KeyGuard绑定的弹出对话框 | 锁屏时的滑动解锁窗口 | ||
TYPE_SYSTEM_ERROR | 2010 | 系统错误提示窗口 | ANR 窗口 | ||
TYPE_INPUT_METHOD | 2011 | 输入法窗口,会挤占当前应用的空间 | |||
TYPE_INPUT_METHOD_DIALOG | 2012 | 弹出的输入法窗口,不会挤占当前应用窗口空间,在其之上显示 | |||
TYPE_WALLPAPER | 2013 | 墙纸 | |||
TYPE_STATUS_BAR_PANEL | 2014 | 从状态条下拉的窗口 | |||
TYPE_SECURE_SYSTEM_OVERLAY | 2015 | 只有系统用户可以创建的OVERLAY窗口 | |||
TYPE_DRAG | 2016 | 浮动的可拖动窗口 | 360安全卫士的浮动精灵 | ||
TYPE_STATUS_BAR_PANEL | 2017 | ||||
TYPE_POINTER | 2018 | 光标 | |||
TYPE_NAVIGATION_BAR | 2019 | ||||
TYPE_VOLUME_OVERLAY | 2020 | 音量调节窗口 | |||
TYPE_BOOT_PROGRESS | 2021 | 启动进度,在所有窗口之上 | |||
TYPE_HIDDEN_NAV_CONSUMER | 2022 | 隐藏的导航栏 | |||
TYPE_DREAM | 2023 | 屏保动画 | |||
TYPE_NAVIGATION_BAR_PANEL | 2024 | Navigation bar 弹出的窗口 | 比如说应用收集栏 | ||
TYPE_UNIVERSAL_BACKGROUND | 2025 | ||||
TYPE_DISPLAY_OVERLAY | 2026 | 用于模拟第二显示设备 | |||
TYPE_MAGNIFICATION | 2027 | 用于放大局部 | |||
TYPE_RECENTS_OVERLAY | 2028 | 当前应用窗口,多用户情况下只显示在用户节目 |
windowManager Service
会根据窗口的类型值来决定Z-Order
(于常量值无关,值大说明是后面Android版本添加的,比如说2025~2028就是4.3 新加的)。比如说SurfaceView.java
里的一个函数,
public void setZOrderOnTop(boolean onTop) {
if (onTop) {
mWindowType = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL; //PANEL在上面
// ensures the surface is placed below the IME
mLayout.flags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
} else {
mWindowType = WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA; //MEDIA类型窗口在应用窗口之下,应用必需挖洞(设Alpha值)才能露出它。
mLayout.flags &= ~WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
}
}
这些类型最终在WindowManager
内部转换成几个Z-Order
值,mBaseLayer, mSubLayer, mAnimationLayer
, 分别表明主窗口,子窗口(附加在主窗口之上),和动画窗口的Z-Order
值(越大越在上边)。不同的窗口类型在不同的硬件产品上有不同的定义,因此它是实现在WindowManagerPolicy
里的windowTypeToLayerLw()
, 举PhoneWindowManager
为例,它的ZOrder
顺序是:
Univese background < Wallpaper < Phone < Search Bar < System Dialog < Input Method Window < Keyguard < Volume < System Overlay < Navigation < System Error < < Display Overlay< Drag < Pointer < Hidden NAV consumer
,
所以,我们如果要在手机锁屏时显示歌曲播放进度,就必须给这个窗口分配一个大于Keyguard
的type
,如 system overlay
等。
一个Window可以有若干个Sub Window
, 他们和主窗口的ZOrder
关系是
Media Sublayer(-2) < Media Overlay sublayer (-1) < Main Layer(0) < Attached Dialog (1) < Sub panel Sublayer (2)
通过 “adb shell dumpsys window
” 可以查看系统当前运行的窗口的ZOrder
和 Visibility
, 比如下面就是在短信输入界面下运行“dumpsys
" 获得的结果,
Window #0 Window{4ea4e178 u0 Keyguard}:
mBaseLayer=121000 mSubLayer=0 mAnimLayer=121000+0=121000 mLastLayer=121000
mViewVisibility=0x8 mHaveFrame=true mObscured=false
Window #1 Window{4ea4aa7c u0 InputMethod}:
mBaseLayer=101000 mSubLayer=0 mAnimLayer=21020+0=21020 mLastLayer=21020
mViewVisibility=0x0 mHaveFrame=true mObscured=false
Window #2 Window{4ec1a150 u0 com.android.mms/com.android.mms.ui.ComposeMessageActivity}:
mBaseLayer=21000 mSubLayer=0 mAnimLayer=21015+0=21015 mLastLayer=21015
mViewVisibility=0x0 mHaveFrame=true mObscured=false
Window #3 Window{4ea7c714 u0 com.android.mms/com.android.mms.ui.ConversationList}:
mBaseLayer=21000 mSubLayer=0 mAnimLayer=21010+0=21010 mLastLayer=21015
mViewVisibility=0x8 mHaveFrame=true mObscured=true
Window #4 Window{4eaedefc u0 com.android.launcher/com.android.launcher2.Launcher}:
mBaseLayer=21000 mSubLayer=0 mAnimLayer=21005+0=21005 mLastLayer=21010
mViewVisibility=0x8 mHaveFrame=true mObscured=true
Window #5 Window{4ea17064 u0 jackpal.androidterm/jackpal.androidterm.Term}:
mBaseLayer=21000 mSubLayer=0 mAnimLayer=21000+0=21000 mLastLayer=22000
mViewVisibility=0x8 mHaveFrame=true mObscured=true
可以看到:
- 当前只有两个窗口可见,
InputMethod
和com.android.mms/com.android.mms.ui.ComposeMessageActivity,mViewVisibility = 0
(0在View.java
定义是可见), 而其他mViewVisibility=0x8
(定义在View.java里, 意思是”GONE"). InputMethod(mLastLayer=21020)
在ComposeMessageActivity(mLastLayer=21015)
之上.细心的同学可能会发现,InputMethod
的mBaseLayer =101000
,为什么mLastLayer
小那么多?因为mLastLayer
才是真正的z-order
, 它经过了WidowManager
的调整。当用户点击输入框,View
会通过InputMethodManager
发送一个showSoftInput
命令,经过InputManagerService
的处理,输入法窗口(KeyboardView
)会被加入到WndowManager Service
里,WindowManager Service
会寻找它的目标窗口,即需要输入的窗口,(遍历WindowList
然后根据窗口的Flags
判断),然后将输入法窗口的mLayer
值改为目标窗口的mLayer +5
,这样,输入法窗口就显示在了目标窗口之上。在这里,输入法窗口存在于InputMethodManagerService
的上下文里,而不是某个Activity
,所以他可以跟任何需要输入法的Activity
绑定。其他一些应用,比如说PiP
(三星的Galaxy S3
可以在一个浮动的小窗口里显示视频)也是运用了类似的方法来实现的。Android的输入法是一个非常值得研究的模块,留到后面探讨。
所以,WindowManager Service
是通过调整窗口的mViewVisibility
和 mLayer
值来实现窗口重叠。最后给出跟Z-order
相关的类图。
图中序号表示输入法窗口找到它的目标窗口的过程:
WindowManagerService
找到默认输出(Default Display
) 的DisplayContents
成员变量。- 里面有一个数组
WindowList-mWindows
,按照Z-Order
顺序保存了当前在这个Display
上输出的所有窗口WindowState
。 - 遍历所有的
WindowState
,判断它的mAppToken
是否和输入法窗口的mAppToken
一致。呼起输入法窗口的窗口会将自己的mAppToken
拷贝给它。 - 相同的
Token
下,可能有多个窗口,通过WindowToken.windows
或者AppWindowToken.allAppWindows
, 可以找到他们。
WindowManager Service
的介绍暂告一段落,它与其他重要的Service
,SurfaceFlinger
, ActivityManager
, InputManager
, PowerManager
, WatchDog
之间的关系将在其他文章介绍。