14558人阅读
Android Framework（26）
& & &Android系统--视图绘制主要由以下几部分组成：
& & &1) Canvas(画布)
& & & & &提供画图所需要的所有工具，即各种draw函数；当前可用的画布对象有：具有硬件加速的GLES20Canvas和GLES20RecordingCanvas，不使用硬件加速的CompatibleCanvas)。
& & &2) View(视图)
& & & & &在具体画布对象上完成各种绘制图形的操作，可根据需要选择以上三种画布中的一种。
& & &3)&&Gl20Renderer(把图直接绘制到屏幕上)
& & & & & 它是硬件加速视图绘制的引擎，负责整个与硬件加速相关的视图绘制过程，具体功能如下：
& & & & & &(1) 创建以下实例对象：
& & & & & & &o&GLES20Canvas & & & & & (Canvas)
& & & & & & &o&GLES20DisplayList & & &(DisplayList)
& & & & & & &o&GLES20TextureLayer &(HardwareLayer)
& & & & & & &o&GLES20RenderLayer &(HardwareLayer)
& & & & & & &o&SurfaceTexture
& & & & & & &o&Gl20Renderer & & & & & & &(HardwareRenderer)
& & & & & &(2) 在GlRenderer.draw中调用View.getDisplayList()完成DisplayList命令的录制，并返回DisplayList
& & & & & & & & &注：只有View被attach到硬件加速，才能创建DisplayList；
& & & & & & & & & & & & 真正的命令录制工作在View.getDisplayList(DisplayList displayList, boolean isLayer)中完成。
& & & & & &(3) 在GlRenderer.draw中调用GLES20Canvas.drawDisplayList，把DisplayList中录制的命令回放在画布上。
& & & & & &(4)&Gl20Renderer对象对应的画布为GLES20Canvas，Gl20Renderer对象在画布上的绘制实际上是绘制在OPENGL绘制上下文对应的主缓冲区。
& & &4)&GLES20DisplayList(把录制命令录制到Native的DiplayList中)
& & & & &GLES20DisplayList对象创建具体的DisplayList对象及绘制用的画布(GLES20RecordingCanvas画布)，完成视图绘制操作的DisplayList命令录制等工作。
& & &5)&GLES20RenderLayer(绘制到FOB Layer中，当作纹理)
& & & & &负责创建硬件Layer层(GLES20Canvas.nCreateLayer)和绘制用到的画布（GLES20Canvas，使用Layer实例化GLES20Canvas(layer, trans)）等工作。
& & & & &为了有效支持视图的多层绘制，视图对象可以创建一个HardwareLayer层完成视图的图形在硬件纹理上的绘制操作或者其它特效操作，这就是GLES20RenderLayer对象的作用，创建独立的层并返回相应的画布供视图绘制使用。
1.1 View.draw(Canvas canvas)六步曲
& & & 此函数将把View自身及其所有的子子孙孙绘制到给定的画布上。其画图过程主要分为以下六步：
& & & 1) 画背景
& & & 2) 如果需要，保存画布的层为未来的淡入淡出做好准备
& & & 3) 画View本身的内容
& & & 4) 画它的孩子
& & & 5) 如果需要，画淡入淡出的边缘并恢复层
& & & 6) 画装饰部分(如：滚动条)
* Manually render this view (and all of its children) to the given Canvas.
* The view must have already done a full layout before this function is
When implementing a view, implement
* {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
* If you do need to override this method, call the superclass version.
* @param canvas The Canvas to which the View is rendered.
public void draw(Canvas canvas) {
final int privateFlags = mPrivateF
final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
* Draw traversal performs several drawing steps which must be executed
* in the appropriate order:
1. Draw the background
2. If necessary, save the canvas' layers to prepare for fading
3. Draw view's content
4. Draw children
5. If necessary, draw the fading edges and restore layers
6. Draw decorations (scrollbars for instance)
// Step 1, draw the background, if needed
if (!dirtyOpaque) {
final Drawable background = mB
if (background != null) {
final int scrollX = mScrollX;
final int scrollY = mScrollY;
if (mBackgroundSizeChanged) {
background.setBounds(0, 0,
mRight - mLeft, mBottom - mTop);
mBackgroundSizeChanged =
if ((scrollX | scrollY) == 0) {
background.draw(canvas);
canvas.translate(scrollX, scrollY);
background.draw(canvas);
canvas.translate(-scrollX, -scrollY);
// skip step 2 & 5 if possible (common case)
final int viewFlags = mViewF
boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
if (!verticalEdges && !horizontalEdges) {
// Step 3, draw the content
if (!dirtyOpaque) onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
// Step 6, draw decorations (scrollbars)
onDrawScrollBars(canvas);
// we're done...
2. 家族图谱
2.1 View家族图谱
2.2 Canvas和HardwareRenderer家族图谱
2.3 DisplayList和HardwareLayer家族图谱
2.4 Native OpenGLRenderer家族图谱
DisplayList.replay调用流程如下：
GlRenderer.draw((View view, View.AttachInfo attachInfo,...)
GLES20Canvas.drawDisplayList(DisplayList displayList, Rect dirty, int flags)-&
nDrawDisplayList-&
android_view_GLES20Canvas_drawDisplayList(...,OpenGLRenderer* renderer,
DisplayList* displayList,...)-&
OpenGLRenderer.drawDisplayList(DisplayList* displayList,...)-&
DisplayList::replay(OpenGLRenderer& renderer,...)
2.5 Activity与Window家族图谱
o&WindowManagerImpl：
& & 允许把View子类增加到高级Window，应用不应该使用它，而是使用更高级的android.app.Activity或android.app.Dialog。
o PhoneWindow.mDecor(DecorView)：窗口最高级的装饰View，即窗口的View树的树根，它包含：标准的Window框架、装饰、和放于窗口中的内容，可把它当作一个Window增加到Window Manager。
2.6 Activity与PhoneWindow的关系
& & 每一个Activity都有一个关联的PhoneWindow对象，用来描述一个应用程序的窗口。每一个应用程序窗口(PhoneWindow)内部又包含有一个装饰View对象(mDecor：DecorView，View树的树根)和一个内容View对象(mContentParent: ViewGroup)，用来描述应用程序窗口的视图。
& &1)&mContentParent(ViewGroup)：是Layout 资源描述的视图树的树根，它是mDecor的孩子
& &2)&mDecor(DecorView)：是PhoneWindow窗口中的视图树的树根
2.7 Activity实例化PhoneWindow流程
& & &Activity在attach函数中实例化了PhoneWindow和WindowManagerImpl，以供后面绘制视图使用。
Activity.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)-&
1) PolicyManager.makeNewWindow(Context context)
// 返回PhoneWindow实例并保存在mWindow中
Policy.makeNewWindow(Context context)-&
//new PhoneWindow(context)
PhoneWindow(Context context)
//获取LayoutInflater，它可以把Layout XML实例化为对应的View Objects
2) Window.setWindowManager(
(WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
mToken, mComponent.flattenToString(),
(info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0)-&
WindowManagerImpl.createLocalWindowManager(Window parentWindow)
// 返回WindowManagerImpl实例，并保存在Window.mWindowManager
3)mWindow.setContainer(mParent.getWindow())
4)mWindowManager = mWindow.getWindowManager()
//返回Window.mWindowManager
//即Activity与Window中的mWindowManager为同一个
//WindowManagerImpl实例
2.8&放置窗口内容setContentView
&&setContentView的功能是：把Layout XML资源文件实例化为一棵视图树，然后把它加入PhoneWindow.mContentParent中，即成为PhoneWindow.mContentParent的子女。
Activity.setContentView(int layoutResID)-&
//设置Activity内容
PhoneWindow.setContentView(int layoutResID)-&
LayoutInflater.inflate(layoutResID, mContentParent)-&
//把XML资源文件实例化为一棵视图树，并返回视图树的树根(root)
//树根为ViewGroup实例
LayoutInflater.inflate(layoutResID, root, root != null)-&
//根据资源生成XmlResourceParser
LayoutInflater.inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot)-&
ViewGroup.addView(View child, LayoutParams params)-&
//把资源文件中的视图树加入PhoneWindow中的mContentParent中
View.requestLayout()
View.invalidate(true)-&
addViewInner(child, index, params, false)
//它将调用child.requestLayout(),依次递归下去
ViewGroup.invalidateChild(View child, final Rect dirty)-&
ViewGroup.invalidateChildInParent(final int[] location, final Rect dirty)
//更新dirty区域
3. FBO (Frame Buffer Object)和RBO (Render Buffer Object)
& & 在了解下面的内容之前，需要了解一下FBO和RBO，除了使用窗口系统固有的Frame Buffer外，可以创建Frame Buffer Object，用于off-screen rendering(离线渲染：就是通过OpenGL将绘制结果渲染到显存中的一张图片上，通过gl接口函数可以从显存读取到内存中)。FBO是一种特殊的Buffer Object。
& &1) glGenFramebuffers: 生成FBO对象的名字
& &2)&glBindFramebuffer: 绑定FBO并进行实始化
& &3)&glDeleteFramebuffers: 删除FBO对象
& &FBO创建后，还不能绘图，必须为FBO提供绘图的目标buffer，也即Render Buffer Object。
& & & Render Buffer Object包含具体的图像数据：
& & & 1)&glGenRenderbuffers：生成对象的名字
& & & 2)&glBindRenderbuffer:&绑定名字到RenderBuffer
& & & 3)&glRenderbufferStorage:&为render
buffer分配存储空间
3.3 把RBO连接到FBO上
& & &&glFramebufferRenderbuffer(GLenum target, GLenum attachment,GLenum renderbuffertarget, GLuint renderbuffer);
& & & 1) target：GL_DRAW_FRAMEBUFFER: 指定写入用途FBO
& & & & & & & & & & & &GL_READ_FRAMEBUFFER：指定读取用途FBO
& & & & & & & & & & & &GL_FRAMEBUFFER：指定两者
& & & 2)&attachment：GL_COLOR_ATTACHMENT
& & & & & & & & & & & & & & & &GL_DEPTH_ATTACHMENT
& & & & & & & & & & & & & & & &GL_STENCIL_ATTACHMENT
& & & & & & & & & & & & & & & &GL_DEPTH_STENCIL_ATTACHMENT
& & & 3)renderbuffertarget:&GL_RENDERBUFFER
& & & 4)&renderbuffer: RBO名字
& & &使用FBO可以创建出动态的texture，glFramebufferTexture可以绑定texture到FBO。
4. 各种各样的画布
& & 从上面的家族图谱中可以看到，可用的画布有以下几种：
& & 1)&GLES20RecordingCanvas: &此GL画布用于录制画图操作
& & 2)&GLES20Canvas: &在OpenGL ES 2.0之上实现的画布
& & 3)&HardwareCanvas: 硬件加速的画布
& & 3)&Canvas: 实现画图操作的画布
4.1&Gl20Renderer使用的画布(直接绘制在屏幕上)
& & &其相关代码如下：
Gl20Renderer.createCanvas()-&
& GLES20Canvas.GLES20Canvas(false, boolean translucent)-&
nCreateRenderer()
* Hardware renderer using OpenGL ES 2.0.
static class Gl20Renderer extends GlRenderer {
private GLES20Canvas mGlC
final boolean mT
HardwareCanvas createCanvas() {
//创建直接绘制到屏幕上的画布，而不会录制到DisplayList中
return mGlCanvas = new GLES20Canvas(mTranslucent);
* An implementation of Canvas on top of OpenGL ES 2.0.
class GLES20Canvas extends HardwareCanvas {
private final boolean mO
private int mR
* Creates a canvas to render directly on screen.
* 创建直接绘制到屏幕上的画布，而不会录制到DisplayList中
* 由Gl20Renderer.createCanvas调用
GLES20Canvas(boolean translucent) {
// 直接调用OpenGL函数把图画到屏幕上
this(false, translucent);
* Creates a canvas to render into an FBO.
* 创建离线绘制到FBO的画布
GLES20Canvas(int layer, boolean translucent) {
mOpaque = !
// mRenderer为Native中LayerRenderer类的实例
mRenderer = nCreateLayerRenderer(layer);
setupFinalizer();
protected GLES20Canvas(boolean record, boolean translucent) {
mOpaque = !
if (record) {
// 把画图命令录制到DisplayListRenderer.mWriter中
// mRender为Native中DisplayListRenderer类的实例
mRenderer = nCreateDisplayListRenderer();
// 直接调用OpenGL函数把图画到屏幕上
// mRenderer为Native中OpenGLRenderer类的实例
mRenderer = nCreateRenderer();
setupFinalizer();
4.2 GLES20RenderLayer使用的画布(离线绘制到FBO Layer)
GLES20RenderLayer.GLES20RenderLayer(w,h,trans)-&
&GLES20Canvas.nCreateLayer(w,h,trans,layerInfo)
&GLES20Canvas.GLES20Canvas(int layer, boolean translucent)-&
& &nCreateLayerRenderer(layer)
* An OpenGL ES 2.0 implementation of {@link HardwareLayer}. This
* implementation can be used a rendering target. It generates a
* {@link Canvas} that can be used to render into an FBO using OpenGL.
class GLES20RenderLayer extends GLES20Layer {
private int mLayerW
private int mLayerH
private final GLES20Canvas mC
GLES20RenderLayer(int width, int height, boolean isOpaque) {
super(width, height, isOpaque);
int[] layerInfo = new int[2];
// 请求Native LayerRenderer创建一个FBO Layer,以用于离线Render
mLayer = GLES20Canvas.nCreateLayer(width, height, isOpaque, layerInfo);
if (mLayer != 0) {
mLayerWidth = layerInfo[0];
mLayerHeight = layerInfo[1];
// 使用FBO Layer创建一个Native LayerRenderer,然后实例化画布
mCanvas = new GLES20Canvas(mLayer, !isOpaque);
mFinalizer = new Finalizer(mLayer);
mFinalizer =
* An implementation of Canvas on top of OpenGL ES 2.0.
class GLES20Canvas extends HardwareCanvas {
private final boolean mO
private int mR
* Creates a canvas to render directly on screen.
* 创建直接绘制到屏幕上的画布，而不会录制到DisplayList中
* 由Gl20Renderer.createCanvas调用
GLES20Canvas(boolean translucent) {
// 直接调用OpenGL函数把图画到屏幕上
this(false, translucent);
* Creates a canvas to render into an FBO.
* 创建离线绘制到FBO的画布
GLES20Canvas(int layer, boolean translucent) {
mOpaque = !
// mRenderer为Native中LayerRenderer类的实例
mRenderer = nCreateLayerRenderer(layer);
setupFinalizer();
protected GLES20Canvas(boolean record, boolean translucent) {
mOpaque = !
if (record) {
// 把画图命令录制到DisplayListRenderer.mWriter中
// mRender为Native中DisplayListRenderer类的实例
mRenderer = nCreateDisplayListRenderer();
// 直接调用OpenGL函数把图画到屏幕上
// mRenderer为Native中OpenGLRenderer类的实例
mRenderer = nCreateRenderer();
setupFinalizer();
4.3 GLES20RecordingCanvas使用的画布 (绘制到DisplayList)
GLES20DisplayList.start-&
& GLES20RecordingCanvas.obtain(GLES20DisplayList displayList)-& (static)
& & &GLES20RecordingCanvas.GLES20RecordingCanvas()-&
& & & &GLES20Canvas(true /*record*/, true /*translucent*/)-&&
& & & & &nCreateDisplayListRenderer()
* An implementation of display list for OpenGL ES 2.0.
class GLES20DisplayList extends DisplayList {
// These lists ensure that any Bitmaps and DisplayLists recorded by a DisplayList are kept
// alive as long as the DisplayList is alive.
The Bitmap and DisplayList lists
// are populated by the GLES20RecordingCanvas during appropriate drawing calls and are
// cleared at the start of a new drawing frame or when the view is detached from the window.
final ArrayList&Bitmap& mBitmaps = new ArrayList&Bitmap&(5);
final ArrayList&DisplayList& mChildDisplayLists = new ArrayList&DisplayList&();
private GLES20RecordingCanvas mC
// Used for debugging
private final String mN
// The native display list will be destroyed when this object dies.
// DO NOT overwrite this reference once it is set.
private DisplayListFinalizer mF
GLES20DisplayList(String name) {
public HardwareCanvas start() {
if (mCanvas != null) {
throw new IllegalStateException(&Recording has already started&);
// 使用GLES20DisplayList创建GLES20RecordingCanvas
mCanvas = GLES20RecordingCanvas.obtain(this);
mCanvas.start();
* An implementation of a GL canvas that records drawing operations.
* This is intended for use with a DisplayList. This class keeps a list of all the Paint and
* Bitmap objects that it draws, preventing the backing memory of Bitmaps from being freed while
* the DisplayList is still holding a native reference to the memory.
class GLES20RecordingCanvas extends GLES20Canvas implements Poolable&GLES20RecordingCanvas& {
// The recording canvas pool should be large enough to handle a deeply nested
// view hierarchy because display lists are generated recursively.
private static final int POOL_LIMIT = 25;
private static final Pool&GLES20RecordingCanvas& sPool = Pools.synchronizedPool(
Pools.finitePool(new PoolableManager&GLES20RecordingCanvas&() {
public GLES20RecordingCanvas newInstance() {
return new GLES20RecordingCanvas();
public void onAcquired(GLES20RecordingCanvas element) {
public void onReleased(GLES20RecordingCanvas element) {
}, POOL_LIMIT));
private GLES20DisplayList mDisplayL
private GLES20RecordingCanvas() {
//实例化DisplayListRender
super(true /*record*/, true /*translucent*/);
static GLES20RecordingCanvas obtain(GLES20DisplayList displayList) {
GLES20RecordingCanvas canvas = sPool.acquire();
canvas.mDisplayList = displayL
* An implementation of Canvas on top of OpenGL ES 2.0.
class GLES20Canvas extends HardwareCanvas {
private final boolean mO
private int mR
* Creates a canvas to render directly on screen.
* 创建直接绘制到屏幕上的画布，而不会录制到DisplayList中
* 由Gl20Renderer.createCanvas调用
GLES20Canvas(boolean translucent) {
// 直接调用OpenGL函数把图画到屏幕上
this(false, translucent);
* Creates a canvas to render into an FBO.
* 创建离线绘制到FBO的画布
GLES20Canvas(int layer, boolean translucent) {
mOpaque = !
// mRenderer为Native中LayerRenderer类的实例
mRenderer = nCreateLayerRenderer(layer);
setupFinalizer();
protected GLES20Canvas(boolean record, boolean translucent) {
mOpaque = !
if (record) {
// 把画图命令录制到DisplayListRenderer.mWriter中
// mRender为Native中DisplayListRenderer类的实例
mRenderer = nCreateDisplayListRenderer();
// 直接调用OpenGL函数把图画到屏幕上
// mRenderer为Native中OpenGLRenderer类的实例
mRenderer = nCreateRenderer();
setupFinalizer();
5. 绘制（Render）元素小结
& & 为了把图形绘制到屏幕上，必须使用Native Render，其最本质的东东是OpenGL，为了方便管理，其Native Render分为三类，其相关信息如下表所示：
Native Render类名
OpenGLRenderer
DisplayListRenderer
LayerRenderer
绘制到哪儿？
直接绘制到屏幕上
录制到SkWriter32
离线绘制到FBO Layer
JNI创建函数
nCreateRenderer
nCreateDisplayListRenderer
nCreateLayerRenderer
由谁管理？
GLES20Canvas
GLES20Canvas
GLES20Canvas
由谁使用？
Gl20Renderer
GLES20DisplayList
GLES20RenderLayer
使用者类别
HardwareRenderer
DisplayList
HardwareLayer
& & &画图五元素间的暧昧关系如下图所示：
6. 创建窗口(Window)流程
& & 其基本流程如下所示：
ActivityThread.handleResumeActivity-&
ActivityClientRecord.window = ActivityClientRecord.activity.getWindow();
View decor = ActivityClientRecord.window.getDecorView();
//实际调用PhoneWindow.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = Activity.getWindowManager();
//wm是WindowManagerImpl实例
Activity.mDecor =
WindowManager.LayoutParams l = r.window.getAttributes();
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardB
if (a.mVisibleFromClient) {
a.mWindowAdded =
wm.addView(decor, l);---&
//即调用WindowManagerImpl.addView,
//把PhoneWindow.mDecor加入WindowManager中
WindowManagerImpl.addView(View view, ViewGroup.LayoutParams params)-&
WindowManagerGlobal.addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow)-&
(root = new ViewRootImpl(view.getContext(), display))
ViewRootImpl.setView(View view, WindowManager.LayoutParams attrs, View panelParentView)-&
requestLayout()
mWindowSession.addToDisplay(mWindow,...) --& //to Window Manager Server
Session.addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
int viewVisibility, int displayId, Rect outContentInsets,
InputChannel outInputChannel)-&
WindowManagerService.addWindow(Session session, IWindow client, int seq,
WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
Rect outContentInsets, InputChannel outInputChannel)-&
new WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token,
WindowState attachedWindow, int seq, WindowManager.LayoutParams a,
int viewVisibility, final DisplayContent displayContent)
// WindowState实例即为Window Manager中刚创建的窗口
& & &在以上过程中，ViewRootImpl为客户端，通过IWindowSession接口把创建窗口的请求发送给Server端(Session),然后调用WindowManagerService中对应的功能函数。同时把IWindow.Stub (W extends IWindow.Stub)的实现实例发送给服务器端，以便WindowMangerService通过IWindow接口向ViewRootImpl发送命令。其相互关系如下图所示：
& & Activity&--&PhoneWindow&--&ViewRootImpl&--&WindowManagerService
& &在以上关系中，WindowManagerService系统中仅一个实例，其它三个实例一一对应，即一个Activity实例有一个唯一的PhoneWindow和ViewRootImpl实例与之一一对应。
7. 硬件绘制（Hardware Render)窗口流程
WMS.performLayoutAndPlaceSurfacesLocked-&
WMS.performLayoutAndPlaceSurfacesLockedLoop-&
WMS.performLayoutAndPlaceSurfacesLockedInner-&
mRelayoutWhileAnimating.get(j).mClient.doneAnimating()-&
//即IWindow.doneAnimating()
ViewRootImpl.W.doneAnimating()-&
ViewRootImpl.dispatchDoneAnimating()-&
ViewRootImpl.handleDispatchDoneAnimating()-&
ViewRootImpl.scheduleTraversals()-&
ViewRootImpl.mTraversalRunnable.run()-&
ViewRootImpl.doTraversal()-&
ViewRootImpl.performTraversals() -&
ViewRootImpl.performDraw()-&
ViewRootImpl.draw()-&
// ViewRootImpl.drawSoftware(..),软件render，暂且不讲,以下为硬件Render
attachInfo.mHardwareRenderer.draw(mView,...)-&
// attachInfo.mHardwareRenderer实际为Gl20Renderer实例，
// 在enableHardwareAcceleration中实例化
// Gl20Renderer.createDisplayList: 实例化GLES20DisplayList
// Gl20Renderer.createHardwareLayer(w,h):实例化GLES20RenderLayer
// Gl20Renderer.create:实例化Gl20Renderer
GlRenderer.draw(View view, View.AttachInfo attachInfo,...)-&
// 其mCanvas为GLES20Canvas,其对应的Native Render为OpenGLRenderer
GLES20Canvas.onPreDraw(dirty)
View.getDisplayList(mDisplayList, false)
// 如果mDisplayList为null, 则调用
mAttachInfo.mHardwareRenderer.createDisplayList
// 返回的DisplayList为GLES20DisplayList实例
GLES20DisplayList.start()
// 返回GLES20RecordingCanvas实例
//如果mLayerType为LAYER_TYPE_HARDWARE，则调用
mAttachInfo.mHardwareRenderer.createHardwareLayer(w,h,..)
//返回GLES20RenderLayer实例到mHardwareLayer中
GLES20RecordingCanvas.drawHardwareLayer(mHardwareLayer,...)
GLES20Canvas.drawDisplayList(displayList,...)
GLES20Canvas.onPostDraw()
EGL10.eglSwapBuffers(sEglDisplay, mEglSurface)
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2664895次
积分：26183
积分：26183
排名：第177名
原创：311篇
转载：197篇
评论：373条
(14)(27)(4)(2)(7)(16)(5)(10)(14)(14)(5)(2)(2)(4)(3)(2)(5)(4)(10)(3)(4)(3)(1)(3)(6)(1)(2)(6)(5)(5)(8)(7)(7)(19)(18)(5)(14)(4)(3)(1)(12)(12)(31)(21)(12)(14)(10)(11)(7)(4)(15)(10)(8)(56)(19)}