SurfaceView

最新推荐文章于 2022-06-09 18:22:55 发布

rabbit_in_android

最新推荐文章于 2022-06-09 18:22:55 发布

阅读量542

点赞数

分类专栏：进击的兔子之Android基础

进击的兔子之Android基础专栏收录该内容

92 篇文章 0 订阅

订阅专栏

SurfaceView

View的绘图机制存在如下缺陷:

View缺乏双缓冲机制
View每次重绘的时候都会绘制所有组件
新线程无法直接更新UI组件

由于上述的几个缺陷，通过自定义的View来绘图性能底下，Android提供了一个SurfaceView来替代View,在游戏绘图方面表现的更加出色。

由于View的绘图必须在当前UI下（这也是使用Handler更新View的原因），如果程序要花较长时间来绘制，那么UI线程会被阻塞。而SurfaceView则不会，因为是用SurfaceHolder启动新的线程去更新SurfaceView的绘制。

SurfaceView的绘图机制

SurfaceView一般会与SurfaceHolder结合使用，SurfaceHolder用于向与之关联的SurfaceView上绘图，调用getHolder()方法获取SurfaceView上关联的SurfaceHolder。

SurfaceHolder提供了如下的方法来获取Canvas对象：

Canvas lockCanvas():锁定整个SurfaceView对象，获取该Surface上的Canvas。
Canvas lockCanvas(Rectdirty):锁定SurfaceView上Rect划分的区域，获取该Surface上的Canvas。

如果将上面两种方法用于同一个SurfaceView时，返回的是同一个canvas对象，但是当程序调用第二个方法取指定区域的canvas时，SurfaceView将只对Rect规定的区域进行重新绘制，这样就能提高View的重绘效率。

获得了相应的canvas对象之后，接下来就进行绘图工作，绘图完成了再调用unlockCanvasAndPost(canvas)方法。需要注意的是当调用unlockCanvasAndPost后，之前绘制的图像还处于缓冲之中，再次调用lockCanvas()方法锁定的区域可能会“遮挡”它。导致刷新失败。

<pre name="code" class="javascript">//用于向SurfaceView上绘制图像，组件等
private SurfaceHolder holder;
//画笔工具，用于绘制
private Paint paint;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    paint = new Paint();
    SurfaceView surface = (SurfaceView) findViewById(R.id.show);

    //SurfaceHolder对象
    holder = surface.getHolder();

    /**
     * 给SurfaceHolder添加一个CallBack实例
     * 重写了surfaceCreated(SurfaceHolder holder)方法
     */
    holder.addCallback(new SurfaceHolder.Callback() {
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            //将整个SurfaceView上的canvas获取到，在canvas上绘图
            Canvas canvas = holder.lockCanvas();
            //将背景加载为Bitmap
            Bitmap bg = BitmapFactory.decodeResource(
                    MainActivity.this.getResources()
                    ,R.mipmap.ic_launcher);
            //开始绘制
            canvas.drawBitmap(bg, 0, 0, null);
            //unlock画布
            holder.unlockCanvasAndPost(canvas);
// 再次锁定，防止被覆盖 
canvas = holder.lockCanvas(new Rect(0, 0, 0, 0)); 
holder.unlockCanvasAndPost(canvas); 
}
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        }
        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
        }
    });
    surface.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (event.getAction() == MotionEvent.ACTION_DOWN) {
                int cx = (int) event.getX();
                int cy = (int) event.getY();
                //局部锁定SurfaceView,只更新一部分图像
                Canvas canvas = holder.lockCanvas(new Rect(cx - 50,
                        cy - 50, cx + 50, cy + 50));
                //保存当前canvas状态
                canvas.save();
                //旋转画布，设置画笔的颜色
                canvas.rotate(30,cx,cy);
                paint.setColor(Color.RED);
                //绘制一个长方形
                canvas.drawRect(cx - 40, cy - 40, cx, cy, paint);
                //恢复canvas之前保存的状态
                canvas.restore();
                paint.setColor(Color.GREEN);
                canvas.drawRect(cx, cy, cx + 40, cy + 40, paint);
                holder.unlockCanvasAndPost(canvas);
            }
            return false;
        }
    });
}

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

surface是surfaceview中的一个可见部分。我们知道，我们看到的屏幕上的图形，是二维的，我们看到的就是长和宽，其实，在内部实际上是三维的，另一个维度，就是层layer。我们用visio绘图，都会看到这种情况，一个图形会将另个图形遮住，是因为这个图形在上层。

这样看来，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。

在应用中，画图可以是一次性的，也可以是由定时器触发的定时的画。

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

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

SurfaceView是View类的子类，可以直接从内存或者DMA等硬件接口取得图像数据，是个非常重要的绘图视图。它的特性是：可以在主线程之外的线程中向屏幕绘图上。这样可以避免画图任务繁重的时候造成主线程阻塞，从而提高了程序的反应速度。在游戏开发中多用到SurfaceView，游戏中的背景、人物、动画等等尽量在画布canvas中画出。

2.实现方法

1）实现步骤

a．继承SurfaceView

b．实现SurfaceHolder.Callback接口

2）需要重写的方法

（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) {}　　//销毁时激发，一般在这里将画图的线程停止、释放。

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）总结整个过程

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

下面是一个完整的案例：

public class ViewTest extends Activity {

　　　 @Override
      public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(new MyView(this));
      }

     //视图内部类
      class MyView extends SurfaceView implements SurfaceHolder.Callback
      {
         private SurfaceHolder holder;
         private MyThread myThread; 
         public MyView(Context context) {
             super(context);
             // TODO Auto-generated constructor stub
             holder = this.getHolder();
             holder.addCallback(this);
             myThread = new MyThread(holder);//创建一个绘图线程
         }
  
         @Override
         public void surfaceChanged(SurfaceHolder holder, int format, int width,
                  int height) {
             // TODO Auto-generated method stub
               
         }
  
         @Override
         public void surfaceCreated(SurfaceHolder holder) {
              // TODO Auto-generated method stub
             myThread.isRun = true;
             myThread.start();
        }
  
        @Override
         public void surfaceDestroyed(SurfaceHolder holder) {
            // TODO Auto-generated method stub
            myThread.isRun = false;
        }
      }
      //线程内部类
      class MyThread extends Thread
      {
          private SurfaceHolder holder;
          public boolean isRun ;
          public  MyThread(SurfaceHolder holder)
          {
              this.holder =holder; 
              isRun = true;
          }
          @Override
          public void run()
          {
              int count = 0;
              while(isRun)
              {
                  Canvas c = null;
                  try
                  {
                      synchronized (holder){
                      　　c = holder.lockCanvas();//锁定画布，一般在锁定后就可以通过其返回的画布对象Canvas，在其上面画图等操作了。
            　　　　　　　　c.drawColor(Color.BLACK);//设置画布背景颜色
            　　　　　　　　Paint p = new Paint(); //创建画笔
            　　　　　　　　p.setColor(Color.WHITE);
            　　　　　　　　Rect r = new Rect(100, 50, 300, 250);
            　　　　　　　　c.drawRect(r, p);
            　　　　　　　　c.drawText("这是第"+(count++)+"秒", 100, 310, p);
            　　　　　　　　Thread.sleep(1000);//睡眠时间为1秒
            　　　　　　}
        　　　　　　}
        　　　　　　catch (Exception e) {
            　　　　　　e.printStackTrace();
        　　　　　　}
        　　　　　　finally
        　　　　　　{
             　　　　　　if(c!= null)
        　　　　　　　　 {
         　　　　　　　　　　holder.unlockCanvasAndPost(c);//结束锁定画图，并提交改变。
      　　　　　　　　　　}
 　　　　　　　　　　}
 　　　　　　　　}
 　　　　　　}
 　　　　}
　　}

rabbit_in_android

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SurfaceView

SurfaceViewView的绘图机制存在如下缺陷:View缺乏双缓冲机制View每次重绘的时候都会绘制所有组件新线程无法直接更新UI组件由于上述的几个缺陷，通过自定义的View来绘图性能底下，Android提供了一个SurfaceView来替代View,在游戏绘图方面表现的更加出色。由于View的绘图必须在当前UI下（这也是使用Handler更新View的原
复制链接

扫一扫

专栏目录