SurfaceView

最新推荐文章于 2021-05-10 19:12:41 发布

笑笑杨

最新推荐文章于 2021-05-10 19:12:41 发布

阅读量479

点赞数

文章标签： surface

surface，这个单词的意思是浮在表面的，那么surfaceview就是浮在表面的view了。如果真的这样解释，估计有人要拍砖了。然而，话虽不能这么说，取这个名儿，多少还是有点关系的。surface是一个可见区域。

我们在屏幕上看到的这些view，在屏幕上看到的就是画面，在内存中就是一块内存区。绘图的时候，就是显示的硬件如显卡将内存区的这块图形数据绘制到屏幕上。所以，从内存的角度去看这些东西，会比较好理解。

surface是surfaceview中的一个可见部分。我们知道，我们看到的屏幕上的图形，是二维的，我们看到的就是长和宽，其实，在内部实际上是三维的，另一个维度，就是层layer。我们用visio绘图，都会看到这种情况，一个图形会将另个图形遮住，是因为这个图形在上层。如果有同AutoCAD的经验，对这个更容易理解。我们看到的图形实际上是很多图形一层层的叠加在一起的，这些图形元素完全不可见，或者部分可见部分不可见，或者完全可见。

这样看来，surface就可以这样理解：它是内存中一块区域，它是surfaceview可见不那个部分，绘图操作作用于它，然后它就会被显卡之类的显示控制器绘制到屏幕上。

surface是个啥，大概已经有了些概念了。因为它对应了一个内存区，大家都知道，内存区的对象是有生命周期的，可以动态的申请创建和销毁，当然也可能会更新。于是，就有了作用于这个内存区的操作，这些操作就是surfaceCreated/Changed/Destroyed。三个操作放在一起，就是callback,

所以在很多例子里看到，会有callback。

callback,是回调，意思是自己能干一些活，不过自己不去主动做，而是到别人那里去登记一下，别人需要的时候，就会叫我去做。就这个例子而言，可以打这个比方，某建筑工人队伍A，能盖房子，能装修，也能拆房子。可是他自己不去主动的做这些事情，而是去向开发商B去登记这三种能力，当然了，他把这三种能力打了包，叫做A的能力。啥时候，B有活干了，就叫A去做，或者是盖房子，或者是装修，或者是拆建筑。在这个例子中，能力包就是callback.

说了这个例子，其实就解释了 surface相关的一些东西，callback已经说过了，下面来说说其他的。假设surface就是一栋房子，那么surface拥有surfaceHolder，谁呢？在这个例子中好比建筑队A。盖房子对应的就是surfaceCreated, 拆房子就对应了surfaceDestroyed，装修就对应了surfaceChanged.

surface有生存期，好比房子有生存期，在建造以后就存在，在拆了之后就没有了。装修必须发生在这之间。同样的，surface的change必须发生在created和destroyed之间。

surfaceview知道surface的holder是谁，在surfaceview生成的时候，会调用getHolder得到holder，然后holder会调用addCallback将三个callback函数注册。

holder拥有对于surface的控制权。在很多程序中，会在surfaceCreated的函数实现中创建另一个线程。所以在这里有两个线程，一个是UI线程，另一个负责画图的线程。画图线程由UI线程调用surfaceCreated的时候创建，在surfaceDestroyed调用的时候放回到线程池。在这中间，画图线程负责图形的绘制。

在这种模型下，UI线程和画图线程各司其职，前者主要负责和用户的交互，而后者，在负责绘制图形。这样，绘制图形的时候如果时间较长，不会阻塞用户的输入。

我们知道，线程共享内存数据，所以， surface对于两个线程是共享的。所以，为了避免在画图的时候，UI线程也对surface进行操作，在画图前，需要对surface加锁。这个工作是有holder干的，holder会先锁住surface中的一块holder.lockCanvas，我们叫canvas,然后，在上面绘画，画完之后，会解锁unlockCanvasAndPost。

在应用中，画图可以是一次性的，也可以是由定时器触发的定时的画。实现的都是runnable类中的run方法。关于runnable类，这个Java中定义的，并不是android独有的，可以参考Java的referrence.

这个模型最大的好处就是，画图不依赖于UI线程，不会阻塞UI线程。

而单纯的view是依赖于UI线程画图的。对于完全依赖于用户的输入进行图像显示的更新的，用view是可以的，但是如果能够自动的进行绘图，而不需等待用户的输入，surfaceview无疑是更好的选择。

有图有真相，请看图

=================================================================================================

首先我们先来看下官方API对SurfaceView的介绍

SurfaceView的API介绍

Provides a dedicated drawing surface embedded inside of a view hierarchy. You can control the format of this surface and, if you like, its size; the SurfaceView takes care of placing the surface at the correct location on the screen

The surface is Z ordered so that it is behind the window holding its SurfaceView; the SurfaceView punches a hole in its window to allow its surface to be displayed. The view hierarchy will take care of correctly compositing with the Surface any siblings of the SurfaceView that would normally appear on top of it. This can be used to place overlays such as buttons on top of the Surface, though note however that it can have an impact on performance since a full alpha-blended composite will be performed each time the Surface changes.

Access to the underlying surface is provided via the SurfaceHolder interface, which can be retrieved by calling getHolder().

The Surface will be created for you while the SurfaceView's window is visible; you should implement surfaceCreated(SurfaceHolder) and surfaceDestroyed(SurfaceHolder) to discover when the Surface is created and destroyed as the window is shown and hidden.

One of the purposes of this class is to provide a surface in which a secondary thread can render in to the screen. If you are going to use it this way, you need to be aware of some threading semantics:

•All SurfaceView and SurfaceHolder.Callback methods will be called from the thread running the SurfaceView's window (typically the main thread of the application). They thus need to correctly synchronize with any state that is also touched by the drawing thread.
•You must ensure that the drawing thread only touches the underlying Surface while it is valid -- between SurfaceHolder.Callback.surfaceCreated() and SurfaceHolder.Callback.surfaceDestroyed().
对应的中文翻译
SurfaceView是视图(View)的继承类，这个视图里内嵌了一个专门用于绘制的Surface。你可以控制这个Surface的格式和尺寸。Surfaceview控制这个Surface的绘制位置。
        surface是纵深排序(Z-ordered)的，这表明它总在自己所在窗口的后面。surfaceview提供了一个可见区域，只有在这个可见区域内的surface部分内容才可见，可见区域外的部分不可见。surface的排版显示受到视图层级关系的影响，它的兄弟视图结点会在顶端显示。这意味者 surface的内容会被它的兄弟视图遮挡，这一特性可以用来放置遮盖物(overlays)(例如，文本和按钮等控件)。注意，如果surface上面有透明控件，那么它的每次变化都会引起框架重新计算它和顶层控件的透明效果，这会影响性能。
        你可以通过SurfaceHolder接口访问这个surface，getHolder()方法可以得到这个接口。
        surfaceview变得可见时，surface被创建；surfaceview隐藏前，surface被销毁。这样能节省资源。如果你要查看 surface被创建和销毁的时机，可以重载surfaceCreated(SurfaceHolder)和 surfaceDestroyed(SurfaceHolder)。
        surfaceview的核心在于提供了两个线程：UI线程和渲染线程。这里应注意：
        1> 所有SurfaceView和SurfaceHolder.Callback的方法都应该在UI线程里调用，一般来说就是应用程序主线程。渲染线程所要访问的各种变量应该作同步处理。
        2> 由于surface可能被销毁，它只在SurfaceHolder.Callback.surfaceCreated()和 SurfaceHolder.Callback.surfaceDestroyed()之间有效，所以要确保渲染线程访问的是合法有效的surface。

接下来呢，说说自己对它的理解
1、定义

可以直接从内存或者DMA等硬件接口取得图像数据,是个非常重要的绘图容器。

它的特性是：可以在主线程之外的线程中向屏幕绘图上。这样可以避免画图任务繁重的时候造成主线程阻塞，从而提高了程序的反应速度。在游戏开发中多用到SurfaceView，游戏中的背景、人物、动画等等尽量在画布canvas中画出。

2、实现

首先继承SurfaceView并实现SurfaceHolder.Callback接口
使用接口的原因：因为使用SurfaceView 有一个原则，所有的绘图工作必须得在Surface 被创建之后才能开始(Surface—表面，这个概念在图形编程中常常被提到。基本上我们可以把它当作显存的一个映射，写入到Surface 的内容
可以被直接复制到显存从而显示出来，这使得显示速度会非常快)，而在Surface 被销毁之前必须结束。所以Callback 中的surfaceCreated 和surfaceDestroyed 就成了绘图处理代码的边界。

需要重写的方法

（1）public void surfaceChanged(SurfaceHolder holder,int format,int width,int height){}

　 //在surface的大小发生改变时激发

　（2）public void surfaceCreated(SurfaceHolder holder){}

　 //在创建时激发，一般在这里调用画图的线程。

　（3）public void surfaceDestroyed(SurfaceHolder holder) {}

　 //销毁时激发，一般在这里将画图的线程停止、释放。

整个过程：继承SurfaceView并实现SurfaceHolder.Callback接口 ----> SurfaceView.getHolder()获得SurfaceHolder对象 ---->SurfaceHolder.addCallback(callback)添加回调函数---->SurfaceHolder.lockCanvas()获得Canvas对象并锁定画布----> Canvas绘画 ---->SurfaceHolder.unlockCanvasAndPost(Canvas canvas)结束锁定画图，并提交改变，将图形显示。

3、SurfaceHolder
这里用到了一个类SurfaceHolder,可以把它当成surface的控制器，用来操纵surface。处理它的Canvas上画的效果和动画，控制表面，大小，像素等。
几个需要注意的方法：
(1)、abstract void addCallback(SurfaceHolder.Callback callback);
// 给SurfaceView当前的持有者一个回调对象。
(2)、abstract Canvas lockCanvas();
// 锁定画布，一般在锁定后就可以通过其返回的画布对象Canvas，在其上面画图等操作了。
(3)、abstract Canvas lockCanvas(Rect dirty);
// 锁定画布的某个区域进行画图等..因为画完图后，会调用下面的unlockCanvasAndPost来改变显示内容。
// 相对部分内存要求比较高的游戏来说，可以不用重画dirty外的其它区域的像素，可以提高速度。
(4)、abstract void unlockCanvasAndPost(Canvas canvas);
// 结束锁定画图，并提交改变。
4、实例

这里的例子实现了一个矩形和一个计时器

  1 package xl.test;
  2
  3 import android.app.Activity;
  4 import android.content.Context;
  5 import android.graphics.Canvas;
  6 import android.graphics.Color;
  7 import android.graphics.Paint;
  8 import android.graphics.Rect;
  9 import android.os.Bundle;
10 import android.view.SurfaceHolder;
11 import android.view.SurfaceView;
12
13 public class ViewTest extends Activity {
14      /** Called when the activity is first created. */
15     @Override
16      public void onCreate(Bundle savedInstanceState) {
17          super .onCreate(savedInstanceState);
18         setContentView( new MyView( this ));
19     }
20      // 视图内部类
21      class MyView extends SurfaceView implements SurfaceHolder.Callback
22     {
23          private SurfaceHolder holder;
24          private MyThread myThread;
25          public MyView(Context context) {
26              super (context);
27              // TODO Auto-generated constructor stub
28             holder = this .getHolder();
29             holder.addCallback( this );
30             myThread = new MyThread(holder); // 创建一个绘图线程
31         }
32
33         @Override
34          public void surfaceChanged(SurfaceHolder holder, int format, int width,
35                  int height) {
36              // TODO Auto-generated method stub
37
38         }
39
40         @Override
41          public void surfaceCreated(SurfaceHolder holder) {
42              // TODO Auto-generated method stub
43             myThread.isRun = true ;
44             myThread.start();
45         }
46
47         @Override
48          public void surfaceDestroyed(SurfaceHolder holder) {
49              // TODO Auto-generated method stub
50             myThread.isRun = false ;
51         }
52
53     }
54      // 线程内部类
55      class MyThread extends Thread
56     {
57          private SurfaceHolder holder;
58          public boolean isRun ;
59          public   MyThread(SurfaceHolder holder)
60         {
61              this .holder = holder;
62             isRun = true ;
63         }
64         @Override
65          public void run()
66         {
67              int count = 0 ;
68              while (isRun)
69             {
70                 Canvas c = null ;
71                  try
72                 {
73                      synchronized (holder)
74                     {
75                         c = holder.lockCanvas(); // 锁定画布，一般在锁定后就可以通过其返回的画布对象Canvas，在其上面画图等操作了。
76                         c.drawColor(Color.BLACK); // 设置画布背景颜色
77                         Paint p = new Paint(); // 创建画笔
78                         p.setColor(Color.WHITE);
79                         Rect r = new Rect( 100 , 50 , 300 , 250 );
80                         c.drawRect(r, p);
81                         c.drawText( " 这是第 " + (count ++ ) + " 秒 " , 100 , 310 , p);
82                         Thread.sleep( 1000 ); // 睡眠时间为1秒
83                     }
84                 }
85                  catch (Exception e) {
86                      // TODO: handle exception
87                     e.printStackTrace();
88                 }
89                  finally
90                 {
91                      if (c != null )
92                     {
93                         holder.unlockCanvasAndPost(c); // 结束锁定画图，并提交改变。
94
95                     }
96                 }
97             }
98         }
99     }
100 }

============================================================================================

holder.lockCanvas(Rect dirty);

调用这个函数之后，dirty会被更改，改掉后的值，是真正的dirty区域（因为多个layer覆盖的问题，你的dirty不见得就是系统要的dirty）
上面的关键是多个layer覆盖，比如你第一次dirty是整个View，以后你再怎么调用lockCanvas()dirty都会是整个

View，这个集合论中的或集

===============================================================================================

@Override
           public void surfaceCreated(SurfaceHolder holder)
           {
                Log.d("SurfaceCreated", "surfaceCreated");
               // 锁定整个SurfaceView
               Canvas canvas = holder.lockCanvas();
               // 绘制背景
               Bitmap back = BitmapFactory.decodeResource(
                   SurfaceViewTest.this.getResources()
                   , R.drawable.sun);
               // 绘制背景
               canvas.drawBitmap(back, 0, 0, null);
               // 绘制完成，释放画布，提交修改
               holder.unlockCanvasAndPost(canvas);
               // 重新锁一次，"持久化"上次所绘制的内容
           holder.lockCanvas(new Rect(0, 0, 0, 0));
               holder.unlockCanvasAndPost(canvas);
           }