1 概述

Android从3.0（API Level 11）开始，在绘制View的时候支持硬件加速，充分利用GPU的特性，使得绘制更加平滑。
实质上就是Android3.0以前，几乎所有的图形绘制都是由Skia完成，Skia是一个向量绘图库，使用CPU来进行运算；所以从Android3.0 开始，Google用hwui取代了Skia，准确的说，是推荐取代，因为Opengl的支持不完全，有少量图形api仍由Skia完成，多数view的绘制通过HWUI模块使用openGL的函数来实现。

由于硬件加速自身并非完美无缺，所以Android提供选项来打开或者关闭硬件加速，默认是关闭。一般我们会在两个级别上打开或者关闭硬件加速：

      Application级别：<applicationandroid:hardwareAccelerated="true" ...>      Activity级别：<activity android:hardwareAccelerated="false" ...>

下面我们从代码级别来理解系统是如何实现硬件加速的。

2 开启硬件加速

在开始分析之前，我们先来看下ViewRootImpl中的一个基本流程图：

如上图所示，其实过程2就是打开硬件加速的过程，在ViewRootImpl的SetView函数中，通过调用enableHardwareAcceleration函数来开启硬件加速，我们来看下enableHardwareAcceleration的代码：

                               [cpp] view plain copy                     
         
  1. privatevoidenableHardwareAcceleration(WindowManager.LayoutParamsattrs){
    2.      
  2. mAttachInfo.mHardwareAccelerated=false;
    3.      
  3. mAttachInfo.mHardwareAccelerationRequested=false;
    4.      
  4. finalbooleanhardwareAccelerated=
    5.      
  5. (attrs.flags&WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED)!=0;
    6.      
  6. if(hardwareAccelerated){
    7.      
  7. if(!HardwareRenderer.isAvailable()){
    8.      
  8. return;
    9.      
  9. }
    10.      
  10. //Persistentprocesses(includingthesystem)shouldnotdo
    11.      
  11. //acceleratedrenderingonlow-enddevices.Inthatcase,
    12.      
  12. //sRendererDisabledwillbeset.Inaddition,thesystemprocess
    13.      
  13. //itselfshouldneverdoacceleratedrendering.Inthatcase,both
    14.      
  14. //sRendererDisabledandsSystemRendererDisabledareset.When
    15.      
  15. //sSystemRendererDisabledisset,PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED
    16.      
  16. //canbeusedbycodeonthesystemprocesstoescapethatandenable
    17.      
  17. //HWaccelerateddrawing.(Thisisbasicallyforthelockscreen.)
    18.      
    19.      
  19. finalbooleanfakeHwAccelerated=(attrs.privateFlags&
    20.      
  20. WindowManager.LayoutParams.PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED)!=0;
    21.      
  21. finalbooleanforceHwAccelerated=(attrs.privateFlags&
    22.      
  22. WindowManager.LayoutParams.PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED)!=0;
    23.      
    24.      
  24. if(!HardwareRenderer.sRendererDisabled||(HardwareRenderer.sSystemRendererDisabled
    25.      
  25. &&forceHwAccelerated)){
    26.      
  26. //Don'tenablehardwareaccelerationwhenwe'renotonthemainthread
    27.      
  27. if(!HardwareRenderer.sSystemRendererDisabled&&
    28.      
  28. Looper.getMainLooper()!=Looper.myLooper()){
    29.      
  29. Log.w(HardwareRenderer.LOG_TAG,"Attemptingtoinitializehardware"
    30.      
  30. +"accelerationoutsideofthemainthread,aborting");
    31.      
  31. return;
    32.      
  32. }
    33.      
    34.      
  34. if(mAttachInfo.mHardwareRenderer!=null){
    35.      
  35. mAttachInfo.mHardwareRenderer.destroy(true);
    36.      
  36. }
    37.      
    38.      
  38. finalbooleantranslucent=attrs.format!=PixelFormat.OPAQUE;
    39.      
  39. mAttachInfo.mHardwareRenderer=HardwareRenderer.createGlRenderer(2,translucent);
    40.      
  40. if(mAttachInfo.mHardwareRenderer!=null){
    41.      
  41. mAttachInfo.mHardwareRenderer.setName(attrs.getTitle().toString());
    42.      
  42. mAttachInfo.mHardwareAccelerated=
    43.      
  43. mAttachInfo.mHardwareAccelerationRequested=true;
    44.      
  44. }
    45.      
  45. }elseif(fakeHwAccelerated){
    46.      
  46. //Thewindowhadwantedtousehardwareacceleration,butthis
    47.      
  47. //isnotallowedinitsprocess.Bysettingthisflag,itcan
    48.      
  48. //stillrenderasifitwasaccelerated.Thisisbasicallyfor
    49.      
  49. //thepreviewwindowsthewindowmanagershowsforlaunching
    50.      
  50. //applications,sotheywilllookmoreliketheappbeinglaunched.
    51.      
  51. mAttachInfo.mHardwareAccelerationRequested=true;
    52.      
  52. }
    53.      
  53. }
    54.      
  54. }
    55.

上面代码不长，而且注释很完善，所以我们主要来看下函数的最主体部分即可。

                               [cpp] view plain copy                     
         
  1. staticHardwareRenderercreateGlRenderer(intglVersion,booleantranslucent){
    2.      
  2. switch(glVersion){
    3.      
  3. case2:
    4.      
  4. returnGl20Renderer.create(translucent);
    5.      
  5. }
    6.      
  6. thrownewIllegalArgumentException("UnknownGLversion:"+glVersion);
    7.      
  7. }
    8.      
  8. staticHardwareRenderercreate(booleantranslucent){
    9.      
  9. if(GLES20Canvas.isAvailable()){
    10.      
  10. returnnewGl20Renderer(translucent);
    11.      
  11. }
    12.      
  12. returnnull;
    13.      
  13. }
    14.      
  14. GlRenderer(intglVersion,booleantranslucent){
    15.      
  15. mGlVersion=glVersion;
    16.      
  16. mTranslucent=translucent;
    17.      
  17. loadSystemProperties(null);
    18.      
  18. }
    19.

我们发现这段代码最主要的作用就是创建了一个Gl20Renderer（继承自GlRenderer和HardwareRenderer）。创建时调用了通过loadSystemProperties函数加载了一些属性和调试选项，这里不展开，有兴趣可以详细研究一下。

创建好的Gl20Renderer保存在了mAttachInfo.mHardwareRenderer中，后面我们在使用硬件加速时就会用到。

3 硬件绘制

从前面图中我们可以知道，在ViewRootImpl绘制时，调用了draw函数。有两种选择，一种是软件绘制，一种是硬件绘制。

                               [cpp] view plain copy                     
         
  1. if(attachInfo.mHardwareRenderer!=null&&attachInfo.mHardwareRenderer.isEnabled()){
    2.      
  2. //Drawwithhardwarerenderer.
    3.      
  3. mIsAnimating=false;
    4.      
  4. mHardwareYOffset=yoff;
    5.      
  5. mResizeAlpha=resizeAlpha;
    6.      
    7.      
  7. mCurrentDirty.set(dirty);
    8.      
  8. dirty.setEmpty();
    9.      
    10.      
  10. attachInfo.mHardwareRenderer.draw(mView,attachInfo,this,
    11.      
  11. animating?null:mCurrentDirty);
    12.      
  12. }else{
    13.      
  13. //Ifwegetherewithadisabled&requestedhardwarerenderer,somethingwent
    14.      
  14. //wrong(aninvalidatepostedrightbeforewedestroyedthehardwaresurface
    15.      
  15. //forinstance)soweshouldjustbailout.Lockingthesurfacewithsoftware
    16.      
  16. //renderingatthispointwouldlockitforeverandpreventhardwarerenderer
    17.      
  17. //fromdoingitsjobwhenitcomesback.
    18.      
  18. //Beforewerequestanewframewemusthoweverattempttoreinitiliazethe
    19.      
  19. //hardwarerendererifit'sinrequestedstate.Thiswouldhappenafteran
    20.      
  20. //eglTerminate()forinstance.
    21.      
  21. if(attachInfo.mHardwareRenderer!=null&&
    22.      
  22. !attachInfo.mHardwareRenderer.isEnabled()&&
    23.      
  23. attachInfo.mHardwareRenderer.isRequested()){
    24.      
    25.      
  25. try{
    26.      
  26. attachInfo.mHardwareRenderer.initializeIfNeeded(mWidth,mHeight,
    27.      
  27. mHolder.getSurface());
    28.      
  28. }catch(OutOfResourcesExceptione){
    29.      
  29. handleOutOfResourcesException(e);
    30.      
  30. return;
    31.      
  31. }
    32.      
    33.      
  33. mFullRedrawNeeded=true;
    34.      
  34. scheduleTraversals();
    35.      
  35. return;
    36.      
  36. }
    37.      
    38.      
  38. if(!drawSoftware(surface,attachInfo,yoff,scalingRequired,dirty)){
    39.      
  39. return;
    40.      
  40. }
    41.      
  41. }
    42.      
  42. }
    43.

软件绘制不在我们分析范围内，这里我们将在下一小节中来研究一下attachInfo.mHardwareRenderer.draw(mView, attachInfo, this,animating ? null : mCurrentDirty)这个调用。


我们前面已经知道mHardwareRenderer其实是一个Gl20Renderer，那么我们来看下它的draw函数。

                               [cpp] view plain copy                       
         
  1. voiddraw(Viewview,View.AttachInfoattachInfo,HardwareDrawCallbackscallbacks,
    2.      
  2. Rectdirty){
    3.      
  3. if(canDraw()){
    4.      
  4. if(surfaceState!=SURFACE_STATE_ERROR){
    5.      
  5. HardwareCanvascanvas=mCanvas;
    6.      
  6. attachInfo.mHardwareCanvas=canvas;
    7.      
  7. dirty=beginFrame(canvas,dirty,surfaceState);
    8.      
  8. DisplayListdisplayList=buildDisplayList(view,canvas);
    9.      
  9. intsaveCount=0;
    10.      
  10. intstatus=DisplayList.STATUS_DONE;
    11.      
  11. try{
    12.      
  12. status=prepareFrame(dirty);
    13.      
  13. if(mSurface.isValid()&&dirty!=null){
    14.      
  14. mSurface.setDirtyRect(dirty);
    15.      
  15. }
    16.      
  16. saveCount=canvas.save();
    17.      
  17. callbacks.onHardwarePreDraw(canvas);
    18.      
    19.      
  19. if(displayList!=null){
    20.      
  20. status|=drawDisplayList(attachInfo,canvas,displayList,status);
    21.      
  21. }
    22.      
  22. }catch(Exceptione){
    23.      
  23. Log.e(LOG_TAG,"Anerrorhasoccurredwhiledrawing:",e);
    24.      
  24. }finally{
    25.      
  25. callbacks.onHardwarePostDraw(canvas);
    26.      
  26. canvas.restoreToCount(saveCount);
    27.      
  27. view.mRecreateDisplayList=false;
    28.      
    29.      
  29. if(mDrawDelta>0){
    30.      
  30. mFrameCount++;
    31.      
  31. debugOverdraw(attachInfo,dirty,canvas,displayList);
    32.      
  32. debugDirtyRegions(dirty,canvas);
    33.      
  33. drawProfileData(attachInfo);
    34.      
  34. }
    35.      
  35. }
    36.      
  36. onPostDraw();
    37.      
  37. swapBuffers(status);
    38.      
  38. }
    39.      
  39. }
    40.      
  40. }
    41.

上面这几十行代码，就是硬件绘制的最重要的几个流程调用，我们看到draw函数主要分为如下几步，beginFrame，buildDisplayList，prepareFrame，drawDisplayList，onHardwarePostDraw，onPostDraw，swapBuffers。整个详细的调用过程如下图:

从上图中我们可以看出，整个内部详细的调用过程还是比较复杂的，我们这里仔细的一一讲解一下。

1 beginFrame

这个函数的作用很简单：Notifies EGL that the frame is about to be rendered。
功能主要通过android_view_HardwareRenderer_beginFrame这个JNI函数实现：

                               [cpp] view plain copy                       
         
  1. staticvoidandroid_view_HardwareRenderer_beginFrame(JNIEnv*env,jobjectclazz,
    2.      
  2. jintArraysize){
    3.      
  3. EGLDisplaydisplay=eglGetCurrentDisplay();
    4.      
  4. EGLSurfacesurface=eglGetCurrentSurface(EGL_DRAW);
    5.      
  5. if(size){
    6.      
  6. EGLintvalue;
    7.      
  7. jint*storage=env->GetIntArrayElements(size,NULL);
    8.      
  8. eglQuerySurface(display,surface,EGL_WIDTH,&value);
    9.      
  9. storage[0]=value;
    10.      
  10. eglQuerySurface(display,surface,EGL_HEIGHT,&value);
    11.      
  11. storage[1]=value;
    12.      
  12. env->ReleaseIntArrayElements(size,storage,0);
    13.      
  13. }
    14.      
  14. eglBeginFrame(display,surface);
    15.

在BeginFrame() 里获取EGLDisplay(用于显示) 和一个EGLSurface，OpenGL将在这个Surface上进行绘图。
eglBeginFrame主要是校验参数的合法性。

2 buildDisplayList

buildDisplayList是一个很重要也比较复杂的函数，通过这个函数，我们真正完成了视图绘制的录制工作，并将操作指令保存到了native层的DisplayList中，我们这里重点讲一下。

                               [cpp] view plain copy                       
         
  1. privateDisplayListbuildDisplayList(Viewview,HardwareCanvascanvas){
    2.      
  2. if(mDrawDelta<=0){//如果根本没有新的绘制发生，使用之前的displaylist即可
    3.      
  3. returnview.mDisplayList;
    4.      
  4. }
    5.      
  5. view.mRecreateDisplayList=(view.mPrivateFlags&View.PFLAG_INVALIDATED)
    6.      
  6. ==View.PFLAG_INVALIDATED;
    7.      
  7. view.mPrivateFlags&=~View.PFLAG_INVALIDATED;
    8.      
  8. longbuildDisplayListStartTime=startBuildDisplayListProfiling();
    9.      
  9. canvas.clearLayerUpdates();
    10.      
  10. Trace.traceBegin(Trace.TRACE_TAG_VIEW,"getDisplayList");
    11.      
  11. DisplayListdisplayList=view.getDisplayList();
    12.      
  12. Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    13.      
  13. endBuildDisplayListProfiling(buildDisplayListStartTime);
    14.      
  14. returndisplayList;
    15.      
  15. }
    16.

其实主要逻辑是通过view类的getDisplayList()方法实现的,这个方法通过递归的方式获得了整个View树的DisplayList：

                               [cpp] view plain copy                       
         
  1. privateDisplayListgetDisplayList(DisplayListdisplayList,booleanisLayer){
    2.      
  2. if(((mPrivateFlags&PFLAG_DRAWING_CACHE_VALID)==0||
    3.      
  3. displayList==null||!displayList.isValid()||
    4.      
  4. (!isLayer&&mRecreateDisplayList))){
    5.      
  5. //Don'tneedtorecreatethedisplaylist,justneedtotellour
    6.      
  6. //childrentorestore/recreatetheirs
    7.      
  7. if(displayList!=null&&displayList.isValid()&&
    8.      
  8. !isLayer&&!mRecreateDisplayList){
    9.      
  9. mPrivateFlags|=PFLAG_DRAWN|PFLAG_DRAWING_CACHE_VALID;
    10.      
  10. mPrivateFlags&=~PFLAG_DIRTY_MASK;
    11.      
  11. dispatchGetDisplayList();
    12.      
  12. returndisplayList;
    13.      
  13. }
    14.      
  14. if(!isLayer){
    15.      
  15. //Ifwegothere,we'rerecreatingit.Markitassuchtoensurethat
    16.      
  16. //wecopyinchilddisplaylistsintooursindrawChild()
    17.      
  17. mRecreateDisplayList=true;
    18.      
  18. }
    19.      
  19. if(displayList==null){
    20.      
  20. displayList=mAttachInfo.mHardwareRenderer.createDisplayList(getClass().getName());
    21.      
  21. //Ifwe'recreatinganewdisplaylist,makesureourparentgetsinvalidated
    22.      
  22. //sincetheywillneedtorecreatetheirdisplaylisttoaccountforthis
    23.      
  23. //newchilddisplaylist.
    24.      
  24. invalidateParentCaches();
    25.      
  25. }
    26.      
  26. booleancaching=false;
    27.      
  27. intwidth=mRight-mLeft;
    28.      
  28. intheight=mBottom-mTop;
    29.      
  29. intlayerType=getLayerType();
    30.      
  30. finalHardwareCanvascanvas=displayList.start(width,height);
    31.      
  31. ...
    32.

上面函数相当长，我们首先分析前半部分。暂时只看displaylist新创建时会走的逻辑：函数前半部分的流程基本是createDisplayList，invalidateParentCaches，displayList.start，我们来一点点分析。

2.1 createDisplayList

首先我们要创建一个displaylist，这里实际上只是创建了一个GLES20DisplayList类。

                               [cpp] view plain copy                       
         
  1. publicDisplayListcreateDisplayList(Stringname){
    2.      
  2. returnnewGLES20DisplayList(name);
    3.      
  3. }
    4.

GLES20DisplayList是DisplayList的子类，这是一个影子类，没有实际用途，主要用来管理Native层的DisplayList的销毁。Native层的DisplayList在后面的start函数中才被真正创建。

2.2 invalidateParentCaches

这个函数的作用主要是，一旦我们重建了DisplayList，那么这个view必须清空之前的缓存，我们通过这个函数调用来清空缓存。

                               [cpp] view plain copy                       
         
  1. protectedvoidinvalidateParentCaches(){
    2.      
  2. if(mParentinstanceofView){
    3.      
  3. ((View)mParent).mPrivateFlags|=PFLAG_INVALIDATED;
    4.      
  4. }
    5.      
  5. }
    6.

2.3 displayList.start

下面看下displayList.start函数：

                               [cpp] view plain copy                       
         
  1. publicHardwareCanvasstart(intwidth,intheight){
    2.      
  2. mValid=false;
    3.      
  3. mCanvas=GLES20RecordingCanvas.obtain(this);
    4.      
  4. mCanvas.start();
    5.      
  5. mCanvas.setViewport(width,height);
    6.      
  6. //Thedirtyrectshouldalwaysbenullforadisplaylist
    7.      
  7. mCanvas.onPreDraw(null);
    8.      
  8. returnmCanvas;
    9.      
  9. }
    10.

2.3.1 GLES20RecordingCanvas.obtain

start函数真正开始构建DisplayList的上下文，先来看下obtain函数：

                               [cpp] view plain copy                       
         
  1. staticGLES20RecordingCanvasobtain(GLES20DisplayListdisplayList){
    2.      
  2. GLES20RecordingCanvascanvas=sPool.acquire();
    3.      
  3. if(canvas==null){
    4.      
  4. canvas=newGLES20RecordingCanvas();
    5.      
  5. }
    6.      
  6. canvas.mDisplayList=displayList;
    7.      
  7. returncanvas;
    8.      
  8. }
    9.

obtain函数的作用从名字中就可以看出来，主要作用是获取到一个GLES20RecordingCanvas，这个类是 HardwareCanvas和GLES20Canvas的子类。

HardwareCanvas是一个抽象类，如果系统属性和应用程序指定使用硬件加速（现已成为默认），它将会被View（通过AttachInfo,如 下图所示) 引用来完成所有的图形绘制工作。GLES20Canvas 则是hardwareCanvas的实现，但它也只是一层封装而已，真正的实现在Native 层，通过jni (andriod_view_gles20Canvas.cpp)接口来访问底层的Renderer, 进而执行OpenGL的命令。 此外，GLES20Canvas还提供了一些静态接口，用于创建各类Renderer对象。

GLES20RecordingCanvas 继承GLES20Canvas, 通过它调用的OpenGL命令将会存储在DisplayList里面，而不会立即执行。

                               [cpp] view plain copy                       
         
  1. protectedGLES20Canvas(booleanrecord,booleantranslucent){
    2.      
  2. mOpaque=!translucent;
    3.      
  3. if(record){
    4.      
  4. mRenderer=nCreateDisplayListRenderer();
    5.      
  5. }else{
    6.      
  6. mRenderer=nCreateRenderer();
    7.      
  7. }
    8.      
  8. setupFinalizer();
    9.      
  9. }
    10.

我们看到GLES20Canvas在创建时，由于我们现在需要录制命令，所以我们这里调用了nCreateDisplayListRenderer函数，创建的真正的用于渲染的本地对象DisplayListRenderer：

                               [cpp] view plain copy                       
         
  1. staticOpenGLRenderer*android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv*env,
    2.      
  2. jobjectclazz){
    3.      
  3. returnnewDisplayListRenderer;
    4.      
  4. }
    5.

DisplayListRenderer是OpenGLRenderer的子类，相比于OpenGLRenderer是直接绘制，DisplayListRenderer则是将绘制命令保存在它内部的mDisplayListData中，mDisplayListData的类型是DisplayListData：

                               [cpp] view plain copy                       
         
  1. classDisplayListData:publicLightRefBase<DisplayListData>{
    2.      
  2. public:
    3.      
  3. LinearAllocatorallocator;
    4.      
  4. Vector<DisplayListOp*>displayListOps;
    5.      
  5. };
    6.

我们看到这里的重点必然是这个容器displayListOps，一定是它存储了绘制命令DisplayListOp，至于DisplayListOp的详细内容，我们后面再展开。

这样，通过nCreateDisplayListRenderer函数，我们创建了一个本地的DisplayListRenderer对象，他会将绘制命令保存在一个DisplayListData类的DisplayListOp容器里。
现在我们再次回到GLES20Canvas的创建过程中来，调用完nCreateDisplayListRenderer后，程序又继续调用了setupFinalizer，这个我们从名字就可以猜出来这是用于这个canvas回收的，这里我们就不再展开。

2.3.2 GLES20RecordingCanvas.start

回到displayList.start函数中来，创建好GLES20RecordingCanvas之后，继续调用了它的start函数。这个函数主要是清空自己和它的孩子的所有display的引用，这里不再展开。

2.3.3 GLES20RecordingCanvas.setViewport

继续调用setViewport来设置视口：

                               [cpp] view plain copy                       
         
  1. publicvoidsetViewport(intwidth,intheight){
    2.      
  2. mWidth=width;
    3.      
  3. mHeight=height;
    4.      
  4. nSetViewport(mRenderer,width,height);
    5.      
  5. }
    6.      
  6. staticvoidandroid_view_GLES20Canvas_setViewport(JNIEnv*env,jobjectclazz,
    7.      
  7. OpenGLRenderer*renderer,jintwidth,jintheight){
    8.      
  8. renderer->setViewport(width,height);
    9.      
  9. }
    10.      
  10. voidDisplayListRenderer::setViewport(intwidth,intheight){
    11.      
  11. mOrthoMatrix.loadOrtho(0,width,height,0,-1,1);
    12.      
  12. mWidth=width;
    13.      
  13. mHeight=height;
    14.      
  14. }
    15.      
    16.      
  16. voidMatrix4::loadOrtho(floatleft,floatright,floatbottom,floattop,floatnear,floatfar){
    17.      
  17. loadIdentity();
    18.      
  18. data[kScaleX]=2.0f/(right-left);
    19.      
  19. data[kScaleY]=2.0f/(top-bottom);
    20.      
  20. data[kScaleZ]=-2.0f/(far-near);
    21.      
  21. data[kTranslateX]=-(right+left)/(right-left);
    22.      
  22. data[kTranslateY]=-(top+bottom)/(top-bottom);
    23.      
  23. data[kTranslateZ]=-(far+near)/(far-near);
    24.      
  24. mType=kTypeTranslate|kTypeScale|kTypeRectToRect;
    25.      
  25. }
    26.

我们看到上层调用了视口，下层实际上还是通过DisplayListRenderer做了具体实现，主要是做了一个正交投影，具体计算我们这里暂时先不研究。
其实大多数opengl在Canvas层面上的调用都是这样，底层通过render实现了类似OpenGl的实现，后面类似函数我们将不再展开。

2.3.4 GLES20RecordingCanvas.onPreDraw

GLES20RecordingCanvas.onPreDraw函数其实也很简单，先来看代码：

                               [cpp] view plain copy                       
         
  1. publicintonPreDraw(Rectdirty){
    2.      
  2. if(dirty!=null){
    3.      
  3. returnnPrepareDirty(mRenderer,dirty.left,dirty.top,dirty.right,dirty.bottom,
    4.      
  4. mOpaque);
    5.      
  5. }else{
    6.      
  6. returnnPrepare(mRenderer,mOpaque);
    7.      
  7. }
    8.      
  8. }
    9.      
  9. staticintandroid_view_GLES20Canvas_prepare(JNIEnv*env,jobjectclazz,
    10.      
  10. OpenGLRenderer*renderer,jbooleanopaque){
    11.      
  11. returnrenderer->prepare(opaque);
    12.      
  12. }
    13.      
    14.      
  14. status_tOpenGLRenderer::prepare(boolopaque){
    15.      
  15. returnprepareDirty(0.0f,0.0f,mWidth,mHeight,opaque);
    16.      
  16. }
    17.      
  17. status_tOpenGLRenderer::prepareDirty(floatleft,floattop,
    18.      
  18. floatright,floatbottom,boolopaque){
    19.      
  19. setupFrameState(left,top,right,bottom,opaque);
    20.      
  20. //Layerrendererswillstarttheframeimmediately
    21.      
  21. //Theframebufferrendererwillfirstdeferthedisplaylist
    22.      
  22. //foreachlayerandwaituntilthefirstdrawingcommand
    23.      
  23. //tostarttheframe
    24.      
  24. if(mSnapshot->fbo==0){
    25.      
  25. syncState();
    26.      
  26. updateLayers();
    27.      
  27. }else{
    28.      
  28. returnstartFrame();
    29.      
  29. }
    30.      
  30. returnDrawGlInfo::kStatusDone;
    31.      
  31. }
    32.

本身这个onPreDraw其实是很简单的，无非是通过canvas来设置要显示的脏区域。最终逻辑依然是通过native层的OpenGLRenderer来实现，当然，这个实现最后变得有点复杂,因为这里又引入了一个新的概念，SnapShot：

                               [cpp] view plain copy                       
         
  1. voidOpenGLRenderer::setupFrameState(floatleft,floattop,
    2.      
  2. floatright,floatbottom,boolopaque){
    3.      
  3. mCaches.clearGarbage();
    4.      
  4. mOpaque=opaque;
    5.      
  5. mSnapshot=newSnapshot(mFirstSnapshot,
    6.      
  6. SkCanvas::kMatrix_SaveFlag|SkCanvas::kClip_SaveFlag);
    7.      
  7. mSnapshot->fbo=getTargetFbo();
    8.      
  8. mSaveCount=1;
    9.      
  9. mSnapshot->setClip(left,top,right,bottom);
    10.      
  10. mTilingClip.set(left,top,right,bottom);
    11.      
  11. }
    12.

我们这章引入的新概念实在过多，因此我们这里先跳过这个概念，可以参考这篇博客来先了解一下这个快照的概念，我们后面将单独开章节讲这个问题。

2.4 getDisplayList中段小结

由于getDisplayList实在是逻辑比较长，涉及的新概念比较多，我们这里暂时先暂停一下，回顾下前半部分的逻辑：：函数前半部分的流程基本是createDisplayList，invalidateParentCaches，displayList.start。createDisplayList的作用是创建了一个java层的GLES20DisplayList，而displayList.start重点则是创建了一个native层GLES20RecordingCanvas，在创建Canvas的同时创建了DisplayListRenderer，DisplayListRenderer将需要执行的命令保存在内部的displaylist列表中，然后设置了视口，设置了脏区域，这里我们跳过了Snapshot这个新概念。
下面我们继续来看下getDisplayList后半段的代码。

                               [cpp] view plain copy                       
         
  1. {
    2.      
  2. ...
    3.      
  3. try{
    4.      
  4. if(!isLayer&&layerType!=LAYER_TYPE_NONE){
    5.      
  5. if(layerType==LAYER_TYPE_HARDWARE){
    6.      
  6. finalHardwareLayerlayer=getHardwareLayer();
    7.      
  7. if(layer!=null&&layer.isValid()){
    8.      
  8. canvas.drawHardwareLayer(layer,0,0,mLayerPaint);
    9.      
  9. }else{
    10.      
  10. if(layer!=null&&!layer.isValid())Log.e("ViewSystem","View#2getHardwareLayer()isnotvalid.");
    11.      
  11. canvas.saveLayer(0,0,mRight-mLeft,mBottom-mTop,mLayerPaint,
    12.      
  12. Canvas.HAS_ALPHA_LAYER_SAVE_FLAG|
    13.      
  13. Canvas.CLIP_TO_LAYER_SAVE_FLAG);
    14.      
  14. }
    15.      
  15. caching=true;
    16.      
  16. }else{
    17.      
  17. buildDrawingCache(true);
    18.      
  18. Bitmapcache=getDrawingCache(true);
    19.      
  19. if(cache!=null){
    20.      
  20. canvas.drawBitmap(cache,0,0,mLayerPaint);
    21.      
  21. caching=true;
    22.      
  22. }
    23.      
  23. }
    24.      
  24. }else{
    25.      
  25. computeScroll();
    26.      
  26. canvas.translate(-mScrollX,-mScrollY);
    27.      
  27. if(!isLayer){
    28.      
  28. mPrivateFlags|=PFLAG_DRAWN|PFLAG_DRAWING_CACHE_VALID;
    29.      
  29. mPrivateFlags&=~PFLAG_DIRTY_MASK;
    30.      
  30. }
    31.      
  31. //Fastpathforlayoutswithnobackgrounds
    32.      
  32. if((mPrivateFlags&PFLAG_SKIP_DRAW)==PFLAG_SKIP_DRAW){
    33.      
  33. dispatchDraw(canvas);
    34.      
  34. if(mOverlay!=null&&!mOverlay.isEmpty()){
    35.      
  35. mOverlay.getOverlayView().draw(canvas);
    36.      
  36. }
    37.      
  37. }else{
    38.      
  38. draw(canvas);
    39.      
  39. }
    40.      
  40. }
    41.      
  41. }
    42.      
  42. ...
    43.

2.5 开始生成绘制命令

上面这段代码涉及到两条分支，第一条分支又涉及到了新概念，layerType和HardwareLayer，这条分支比较复杂，我们单独放在下一章中单独讲解，我们现在重点看下第二条分支的代码：

                               [cpp] view plain copy                       
         
  1. {
    2.      
  2. ...
    3.      
  3. else{
    4.      
  4. computeScroll();
    5.      
  5. canvas.translate(-mScrollX,-mScrollY);
    6.      
  6. if(!isLayer){
    7.      
  7. mPrivateFlags|=PFLAG_DRAWN|PFLAG_DRAWING_CACHE_VALID;
    8.      
  8. mPrivateFlags&=~PFLAG_DIRTY_MASK;
    9.      
  9. }
    10.      
  10. //Fastpathforlayoutswithnobackgrounds
    11.      
  11. if((mPrivateFlags&PFLAG_SKIP_DRAW)==PFLAG_SKIP_DRAW){
    12.      
  12. dispatchDraw(canvas);
    13.      
  13. if(mOverlay!=null&&!mOverlay.isEmpty()){
    14.      
  14. mOverlay.getOverlayView().draw(canvas);
    15.      
  15. }
    16.      
  16. }else{
    17.      
  17. draw(canvas);
    18.      
  18. }
    19.      
  19. }
    20.      
  20. }
    21.

computeScroll计算滚动位置，和Graphic关系不大，不展开。

translate函数我们在上一节 Android 4.4 Graphic系统详解（4） 一个view的绘制之旅 中已经讲过了，这里不再展开。
其实就是创建了一个Op类的对象，然后将它保存在了DisplayListData的displayListOps容器里面，便于后面的执行。

回到view类getdisplaylist函数中来,说完了translate，下面就是重要的绘制生成流程了。

                               [cpp] view plain copy                       
         
  1. {
    2.      
  2. if((mPrivateFlags&PFLAG_SKIP_DRAW)==PFLAG_SKIP_DRAW){
    3.      
  3. dispatchDraw(canvas);
    4.      
  4. if(mOverlay!=null&&!mOverlay.isEmpty()){
    5.      
  5. mOverlay.getOverlayView().draw(canvas);
    6.      
  6. }
    7.      
  7. }else{
    8.      
  8. draw(canvas);
    9.      
  9. }
    10.      
  10. }
    11.

其中dispatchDraw是通知view的所有孩子进行绘制(?)，其实流程应该都是类似的，因此我们直接看当前view的draw流程,此函数将把View自身及其所有的子子孙孙绘制到给定的画布上。其画图过程主要分为以下六步：

  1) 画背景  2) 如果需要，保存画布的层为未来的淡入淡出做好准备  3) 画View本身的内容  4) 画它的孩子  5) 如果需要，画淡入淡出的边缘并恢复层  6) 画装饰部分(如：滚动条)

上述六步中，2,5步常规情况下不需要，因此我们暂时跳过，只重点分析1,3,6步。

                               [cpp] view plain copy                       
         
  1. publicvoiddraw(Canvascanvas){
    2.      
  2. //Step1,drawthebackground,ifneeded
    3.      
  3. intsaveCount;
    4.      
    5.      
  5. if(!dirtyOpaque){
    6.      
  6. finalDrawablebackground=mBackground;
    7.      
  7. if(background!=null){
    8.      
  8. finalintscrollX=mScrollX;
    9.      
  9. finalintscrollY=mScrollY;
    10.      
  10. if(mBackgroundSizeChanged){
    11.      
  11. background.setBounds(0,0,mRight-mLeft,mBottom-mTop);
    12.      
  12. mBackgroundSizeChanged=false;
    13.      
  13. }
    14.      
  14. if((scrollX|scrollY)==0){
    15.      
  15. background.draw(canvas);
    16.      
  16. }else{
    17.      
  17. canvas.translate(scrollX,scrollY);
    18.      
  18. background.draw(canvas);
    19.      
  19. canvas.translate(-scrollX,-scrollY);
    20.      
  20. }
    21.      
  21. }
    22.      
  22. }
    23.      
    24.      
  24. //skipstep2&5ifpossible(commoncase)
    25.      
  25. finalintviewFlags=mViewFlags;
    26.      
  26. booleanhorizontalEdges=(viewFlags&FADING_EDGE_HORIZONTAL)!=0;
    27.      
  27. booleanverticalEdges=(viewFlags&FADING_EDGE_VERTICAL)!=0;
    28.      
  28. if(!verticalEdges&&!horizontalEdges){
    29.      
  29. //Step3,drawthecontent
    30.      
  30. if(!dirtyOpaque)onDraw(canvas);
    31.      
  31. //Step4,drawthechildren
    32.      
  32. dispatchDraw(canvas);
    33.      
  33. //Step6,drawdecorations(scrollbars)
    34.      
  34. onDrawScrollBars(canvas);
    35.      
  35. if(mOverlay!=null&&!mOverlay.isEmpty()){
    36.      
  36. mOverlay.getOverlayView().dispatchDraw(canvas);
    37.      
  37. }
    38.      
  38. //we'redone...
    39.      
  39. return;
    40.      
  40. }
    41.      
  41. }
    42.

2.5.1 绘制背景

绘制背景很简单，只是调用了 background.draw(canvas)函数，其中background是一个Drawable类型，关于Drawable的绘制，依然可以参考“一个view的绘制之旅”一章中的Drawable的绘制小节讲解，这里不再展开。

2.5.2 onDraw 绘制内容

这一过程比较复杂，其实也就是我们在上一章“一个view的绘制之旅”中讲到的全部内容，具体内容可参考上一章。

2.5.3 绘制滚动条

绘制滚动条的代码比较长，但是按照我们一贯的习惯，我们只关注和Graphic相关的部分，在onDrawScrollBars函数中有横向和纵向ScrollBar的区别，但是对于下层的Graphic并无这种区别，都是调用ScrollBarDrawable的draw函数：

                               [cpp] view plain copy                       
         
  1. publicvoiddraw(Canvascanvas){
    2.      
  2. booleandrawTrack=true;
    3.      
  3. Rectr=getBounds();
    4.      
  4. if(drawTrack){
    5.      
  5. drawTrack(canvas,r,vertical);
    6.      
  6. }
    7.      
  7. if(drawThumb){
    8.      
  8. intsize=vertical?r.height():r.width();
    9.      
  9. intthickness=vertical?r.width():r.height();
    10.      
  10. intlength=Math.round((float)size*extent/range);
    11.      
  11. intoffset=Math.round((float)(size-length)*mOffset/(range-extent));
    12.      
  12. drawThumb(canvas,r,offset,length,vertical);
    13.      
  13. }
    14.      
  14. }
    15.

drawThumb中逻辑转来转去，最终其实还是在drawThumb中再次调用了Drawable的draw函数，这里不再详述。

最终，通过漫长的过程，我们终于完成了displaylist的构建，在完成了buildDisplayList的调用之后，我们回到Gl20Renderer类，继续来看下的draw函数，接下来就该Displaylist的真正执行了。

更多相关文章

  1. 没有一行代码，「2020 新冠肺炎记忆」这个项目却登上了 GitHub 中
  2. GitHub 标星 2.5K+！教你通过玩游戏的方式学习 VIM！
  3. 如何在后台运行Linux命令？
  4. No.11 使用firewall配置的防火墙策略的生效模式
  5. Cocos2d-x +Android(安卓)+ Windows 7环境配置
  6. Android直播开发之旅(15)：libjpeg库的编译移植与使用
  7. android 模拟器和PC用sockets通讯
  8. Android应用开发笔记(12)：Android应用的自动升级、更新模块的实现
  9. [置顶] 玩转pandaboard之linaro对于Android的编译上的一些优化

随机推荐

  1. Android之常用adb指令
  2. Android(安卓)Zip压缩解压缩
  3. android ubuntu /windows usb device lis
  4. Android的Activity动画切换
  5. Android时间获取之——Date、String、Lon
  6. Android实现widget定时更新
  7. android adb命令
  8. 在本地UI使用webview，在html页面用js与and
  9. 14天学会安卓开发(第十三天)Android多媒
  10. android开发新浪微博客户端 完整攻略 [新