|
|
51CTO旗下网站
|
|
移动端

Android 绘制原理浅析「干货」

对于Android开发,在面试的时候,经常会被问到,说一说View的绘制流程?我也经常问面试者,View的绘制流程。对于3年以上的开发人员来说,就知道onMeasure/onLayout/onDraw基本,知道他们呢是干些什么的,这样就够了吗?

作者:Newpaper来源:安卓巴士|2019-08-05 13:20

背景

对于Android开发,在面试的时候,经常会被问到,说一说View的绘制流程?我也经常问面试者,View的绘制流程.

对于3年以上的开发人员来说,就知道onMeasure/onLayout/onDraw基本,知道他们呢是干些什么的,这样就够了吗?

如果你来我们公司,我是你的面试官,可能我会考察你这三年都干了什么,对于View你都知道些什么,会问一些更细节的问题,比如LinearLayout的onMeasure,onLayout过程?他们都是什么时候被发起的,执行顺序是什么?

如果以上问题你都知道,可能你进来我们公司就差不多了(如果需要内推,可以联系我,Android/IOS 岗位都需要),可能我会考察你draw的 canvas是哪里来的,他是怎么被创建显示到屏幕上呢?看看你的深度有多少?

对于现在的移动开发市场逐渐趋向成熟,趋向饱和,很多不缺人的公司,都需要高级程序员.在说大家也都知道,面试要造飞机大炮,进去后拧螺丝,对于一个3年或者5年以上Android开发不稍微了解一些Android深一点的东西,不是很好混.扯了这么多没用的东西,还是回到今天正题,Android的绘图原理浅析.

本文介绍思路

从面试题中几个比较容易问的问题,逐层深入,直至屏幕的绘图原理.

在讲Android的绘图原理前,先介绍一下Android中View的基本工作原理,本文暂不介绍事件的传递流程。

View 绘制工作原理

我们先理解几个重要的类,也是在面试中经常问到的

Activity,Window(PhoneWindow),DecorView之间的关系

理解他们三者的关系,我们直接看代码吧,先从Activity开始的setContentView开始(注:代码删除了一些不是本次分析流程的代码,以免篇幅过长)

  1. //Activity 
  2.  /** 
  3.  * Set the activity content from a layout resource. The resource will be 
  4.  * inflated, adding all top-level views to the activity. 
  5.  * 
  6.  * @param layoutResID Resource ID to be inflated. 
  7.  * 
  8.  * @see #setContentView(android.view.View
  9.  * @see #setContentView(android.view.View, android.view.ViewGroup.LayoutParams) 
  10.  */ 
  11.  public void setContentView(@LayoutRes int layoutResID) { 
  12.  getWindow().setContentView(layoutResID); 
  13.  initWindowDecorActionBar(); 
  14.  } 
  15.   
  16.  public Window getWindow() { 
  17.  return mWindow; 
  18.  } 

里面调用的getWindow的setContentView,这个接下来讲,那么这个mWindow是何时被创建的呢?

  1. //Activity 
  2. private Window mWindow; 
  3. final void attach(Context context, ActivityThread aThread,····) { 
  4.  attachBaseContext(context); 
  5.  mFragments.attachHost(null /*parent*/); 
  6.  mWindow = new PhoneWindow(this, window, activityConfigCallback); 

在Activity的attach中创建了PhoneWindow,PhoneWindow是Window的实现类.

继续刚才的setContentView

  1. //PhoneWindow 
  2.  @Override 
  3.  public void setContentView(int layoutResID) { 
  4.  if (mContentParent == null) { 
  5.  installDecor(); 
  6.  } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) { 
  7.  mContentParent.removeAllViews(); 
  8.  } 
  9.  if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) { 
  10.  final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID, 
  11.  getContext()); 
  12.  transitionTo(newScene); 
  13.  } else { 
  14.  mLayoutInflater.inflate(layoutResID, mContentParent); 
  15.  } 
  16.  } 

在setContentView中,如果mContentParent为空,会去调用installDecor,最后将布局infalte到mContentParent.在来看一下installDecor

  1. //PhoneWindow 
  2.  // This is the view in which the window contents are placed. It is either 
  3.  // mDecor itself, or a child of mDecor where the contents go. 
  4.  ViewGroup mContentParent; 
  5.   
  6.  private DecorView mDecor; 
  7.   
  8.  private void installDecor() { 
  9.  mForceDecorInstall = false
  10.  if (mDecor == null) { 
  11.  mDecor = generateDecor(-1); 
  12.  } else { 
  13.  mDecor.setWindow(this); 
  14.  } 
  15.  if (mContentParent == null) { 
  16.  mContentParent = generateLayout(mDecor); 
  17.  } 
  18.  } 
  19.  protected DecorView generateDecor(int featureId) { 
  20.  return new DecorView(context, featureId, this, getAttributes()); 
  21.  } 

在installDecor,创建了一个DecorView.看mContentParent的注释我们可以知道,他本身就是mDecor或者是mDecor的contents部分.

综上,我们大概知道了三者的关系,

  • Activity包含了一个PhoneWindow,
  • PhoneWindow就是继承于Window
  • Activity通过setContentView将View设置到了PhoneWindow上
  • PhoneWindow里面包含了DecorView,最终布局被添加到Decorview上.

理解ViewRootImpl,WindowManager,WindowManagerService(WMS)之间的关系

看了上述三者的关系后,我们知道布局最终被添加到了DecorView上.那么DecorView是怎么被添加到系统的Framework层.

当Activity准备好后,最终会调用到Activity中的makeVisible,并通过WindowManager添加View,代码如下

  1. //Activity  
  2.  void makeVisible() { 
  3.  if (!mWindowAdded) { 
  4.  ViewManager wm = getWindowManager(); 
  5.  wm.addView(mDecor, getWindow().getAttributes()); 
  6.  mWindowAdded = true
  7.  } 
  8.  mDecor.setVisibility(View.VISIBLE); 
  9.  } 

那他们到底是什么关系呢? (下面提到到客户端服务端是Binder通讯中的客户端服务端概念. )

以下内容是重点需要理解的部分

  • ViewRootImpl(客户端):View中持有与WMS链接的mAttachInfo,mAttachInfo持有ViewRootImpl.ViewRootImpl是ViewRoot的的实现,WMS管理窗口时,需要通知客户端进行某种操作,比如事件响应等.ViewRootImpl有个内部类W,W继承IWindow.Stub,实则就是一个Binder,他用于和WMS IPC交互。ViewRootHandler也是其内部类继承Handler,用于与远程IPC回来的数据进行异步调用.
  • WindowManger(客户端):客户端需要创建一个窗口,而具体创建窗口的任务是由WMS完成,WindowManger就像一个部门经理,谁有什么需求就告诉它,它和WMS交互,客户端不能直接和WMS交互.
  • WindowManagerService(WMS)(服务端):负责窗口的创建,显示等.

View的重绘

从上述关系中,ViewRootImpl是用于接收WMS传递来的消息.那么我们来看一下ViewRootImpl里面的几个关于View绘制的代码.

在这里在强调一下,ViewRootImpl 两个重要的内部类

  • W类 继承Binder 用于接收WMS 传递来的消息
  • ViewRootHandler类继承Handler 接收W类的异步消息

下面看一下ViewRootHandler类.(以View的setVisible为例.)

  1. // ViewRootHandler(ViewRootImpl的内部类,用于异步消息处理,和Acitivity的启动很像) 
  2. //第一步 Handler接收W(Binder)传递来的消息 
  3. @Override 
  4. public void handleMessage(Message msg) { 
  5.  switch (msg.what) { 
  6.  case MSG_INVALIDATE: 
  7.  ((View) msg.obj).invalidate(); 
  8.  break; 
  9.  case MSG_INVALIDATE_RECT: 
  10.  final View.AttachInfo.InvalidateInfo info = (View.AttachInfo.InvalidateInfo) msg.obj; 
  11.  info.target.invalidate(info.left, info.top, info.right, info.bottom); 
  12.  info.recycle(); 
  13.  break; 
  14.  case MSG_DISPATCH_APP_VISIBILITY://处理Visible 
  15.  handleAppVisibility(msg.arg1 != 0); 
  16.  break; 
  17.  }  
  18.   
  19. void handleAppVisibility(boolean visible) { 
  20.  if (mAppVisible != visible) { 
  21.  mAppVisible = visible; 
  22.  scheduleTraversals(); 
  23.  if (!mAppVisible) { 
  24.  WindowManagerGlobal.trimForeground(); 
  25.  } 
  26.  } 
  27.   
  28.  void scheduleTraversals() { 
  29.  if (!mTraversalScheduled) { 
  30.  mTraversalScheduled = true
  31.  mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); 
  32.  //开启下次刷新,就遍历View树 
  33.  mChoreographer.postCallback( 
  34.  Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); 
  35.  if (!mUnbufferedInputDispatch) { 
  36.  scheduleConsumeBatchedInput(); 
  37.  } 
  38.  notifyRendererOfFramePending(); 
  39.  pokeDrawLockIfNeeded(); 
  40.  } 

看一下mTraversalRunnable

  1. final class TraversalRunnable implements Runnable { 
  2.  @Override 
  3.  public void run() { 
  4.  doTraversal(); 
  5.  } 
  6.  } 
  7. final TraversalRunnable mTraversalRunnable = new TraversalRunnable(); 
  8.   
  9.  void doTraversal() { 
  10.  if (mTraversalScheduled) { 
  11.  mTraversalScheduled = false
  12.  mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier); 
  13.  performTraversals(); 
  14.  } 
  15.  }  

在TraversalRunnable中,执行doTraversal.并在doTraversal执行performTraversals(),是不是看到了我们熟悉的performTraversals()了?是的,在这里才开始View的绘制工作.

在ViewRootImpl中的performTraversals(),这个方法代码很长(大约800行代码),大致流程是

  1. 判断是否需要重新计算视图大小,如果需要就执行performMeasure()
  2. 是否需要重新安置所在的位置,performLayout()
  3. 是否需要重新绘制performDraw()

那么是什么导致View的重绘呢?这里总结了3个主要原因

  1. 视图本身内部状态(enable,pressed等)变化,可能引起重绘
  2. View内部添加或者删除了View
  3. View本身的大小和可见性发生了变化

View的绘制流程

在上一小节了,讲述了performTraversals()的是被WMS IPC调用执行的.View的绘制流程一般是

从performTraversals -> performMeasure() -> performLayout() -> performDraw().

下面看一下performMeasure()

  1. //ViewRootImpl 
  2. private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) { 
  3.  if (mView == null) { 
  4.  return
  5.  } 
  6.  Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure"); 
  7.  try { 
  8.  mView.measure(childWidthMeasureSpec, childHeightMeasureSpec); 
  9.  } finally { 
  10.  Trace.traceEnd(Trace.TRACE_TAG_VIEW); 
  11.  } 
  12.  } 
  13.   
  14.  public final void measure(int widthMeasureSpec, int heightMeasureSpec) { 
  15.  MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.EXACTLY 
  16.  && MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.EXACTLY; 
  17.  final boolean matchesSpecSize = getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec) 
  18.  && getMeasuredHeight() == MeasureSpec.getSize(heightMeasureSpec); 
  19.  final boolean needsLayout = specChanged 
  20.  && (sAlwaysRemeasureExactly || !isSpecExactly || !matchesSpecSize); 
  21.  if (forceLayout || needsLayout) { 
  22.  mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET; 
  23.  resolveRtlPropertiesIfNeeded(); 
  24.  int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key); 
  25.  if (cacheIndex < 0 || sIgnoreMeasureCache) { 
  26.  //在这里调用了onMeasure 方法 
  27.  onMeasure(widthMeasureSpec, heightMeasureSpec); 
  28.  mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT; 
  29.  }  
  30.  } 
  31.  } 

最终调用了View的measure方法,而View中的measure()方法被定义成final类型,保证整个流程的执行.performLayout()和performDraw()也是类似的过程.

而对于程序员,自定义View只需要关注他提供出来几个对应的方法,onMeasure/onLayout/onDraw. 关于这方面知识的网上介绍的资料很多,也可以很容易的看到View及ViewGroup里面的代码,推荐看LinerLayout的源码理解这部分知识,在这里不详细展开.

Android的绘图原理浅析

Android屏幕绘制

关于绘制,就要从performDraw()说起,我们来看一下这个流程到底是怎么绘制的.

  1. //ViewRootImpl 
  2. //1 
  3.  private void performDraw() { 
  4.  try { 
  5.  draw(fullRedrawNeeded); 
  6.  } finally { 
  7.  mIsDrawing = false
  8.  Trace.traceEnd(Trace.TRACE_TAG_VIEW); 
  9.  } 
  10.  } 
  11.   
  12.  //2 
  13.  private void draw(boolean fullRedrawNeeded) { 
  14.  Surface surface = mSurface; 
  15.  if (!surface.isValid()) { 
  16.  return
  17.  } 
  18.   
  19.  if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) { 
  20.  return
  21.  } 
  22.  } 
  23.   
  24.  //3 
  25.  private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff, 
  26.  boolean scalingRequired, Rect dirty) { 
  27.  Canvas canvas = mSurface.lockCanvas(dirty); 
  28.  }  

看代码执行流程,1—>2->3, 最终拿到了Java层的canvas,然后进行一系列绘制操作.而canvas是通过Suface.lockCanvas()得到的.

那么Surface又是一个什么呢?在这里Surface只是一个抽象,在APP创建窗口时,会调用WindowManager向WMS服务发起一个请求,携带上surface对象,只有他被分配完一段屏幕缓冲区才能真正对应屏幕上的一个窗口.

来看一下Framework中的绘图架构.更好的理解Surface

Android 绘制原理浅析「干货」

Surface本质上仅仅代表了一个平面,绘制不同图案显然是一种操作,而不是一段数据,Android使用了Skia绘图驱动库来进行平面上的绘制,在程序中使用canvas来表示这个功能.

双缓冲技术的介绍

在ViewRootImpl中,我们看到接收到绘制消息后,不是立刻绘制而是调用scheduleTraversals,在scheduleTraversals调用Choreographer.postCallback(),这又是因为什么呢?这其实涉及到屏幕绘制原理(除了Android其他平台也是类似的).

Android 绘制原理浅析「干货」

我们都知道显示器以固定的频率刷新,比如 iPhone的 60Hz、iPad Pro的 120Hz。当一帧图像绘制完毕后准备绘制下一帧时,显示器会发出一个垂直同步信号(VSync),所以 60Hz的屏幕就会一秒内发出 60次这样的信号。

并且一般地来说,计算机系统中,CPU、GPU和显示器以一种特定的方式协作:CPU将计算好的显示内容提交给 GPU,GPU渲染后放入帧缓冲区,然后视频控制器按照 VSync信号从帧缓冲区取帧数据传递给显示器显示.

但是如果屏幕的缓冲区只有一块,那么这个VSync同步信号发出时, 开始刷新屏幕,那么你看到的屏幕就是一条一条的数据在变化.为了让屏幕看上去是一帧一帧的数据,一般都有两块缓冲区(也被成为双缓冲区).当数据要刷新时,直接替换另一个缓冲区的数据.

双缓冲技术里面,如果不能特定时间刷新完的话(如果60HZ的话,就是16ms内)把这个缓冲区数据刷新完成,屏幕发出VSync同步信号,无法完成两个缓冲区的切换,那么就会造成卡顿现象。

回到scheduleTraversals()上,这个地方就是使用了双缓冲技术(或者三缓冲技术),Choreographer接收VSync的同步信号,当屏幕刷新来时,开始屏幕的刷新操作。

【编辑推荐】

  1. Android 应用架构—— 那些因为年轻犯的错
  2. Android消息机制Handler,有必要再讲一次
  3. Android 性能优化系列:APK极致优化
  4. Android第三方库解析
  5. 我们究竟需要学习哪些Android知识?知识图谱
【责任编辑:未丽燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

这就是5G

这就是5G

5G那些事儿
共15章 | armmay

74人订阅学习

16招轻松掌握PPT技巧

16招轻松掌握PPT技巧

GET职场加薪技能
共16章 | 晒书包

349人订阅学习

20个局域网建设改造案例

20个局域网建设改造案例

网络搭建技巧
共20章 | 捷哥CCIE

727人订阅学习

读 书 +更多

Absolute C++中文版(原书第2版)  

本书是讲解C++语言程序设计的优秀教程。全书围绕C++语言来组织,开始章节介绍编程的普通感念,接下来详细介绍C++中的继承、多态、异常处理...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO播客