Android教程-使用SurfaceView多线程绘制动画


Android教程之使用SurfaceView中的Surface对象进行绘图，其本质就是利用SurfaceHolder的lockCanvas获取到Canvas对象进行绘制的，对于绘制动画来说，必须使用双缓冲，或者采用双线程，一个线程负责专门的预处理，比如图片数据读取，另外一个线程负责进行专绘制图形。因为SurfaceView每次绘图都会锁定Canvas,也就是说同一片区域这次没画完下次就不能画，因此要提高动画播放的效率，就得开一条线程专门画图，开另外一条线程做预处理的工作。

下在给出一个例子，讲解一下如何利用双线程提高绘图速度：

以下可以看到的动画是一张解码后的图片从最屏幕最左边快速移到右边，重新开始则清屏进行显示

  1. package com.test.surfaceview;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.util.ArrayList;  
  5. import android.app.Activity;  
  6. import android.content.Context;  
  7. import android.graphics.Bitmap;  
  8. import android.graphics.BitmapFactory;  
  9. import android.graphics.Canvas;  
  10. import android.graphics.Color;  
  11. import android.graphics.Paint;  
  12. import android.graphics.Rect;  
  13. import android.os.Bundle;  
  14. import android.util.Log;  
  15. import android.view.SurfaceHolder;  
  16. import android.view.SurfaceView;  
  17.   
  18. public class TestsurfaceviewActivity extends Activity {  
  19.     private final static String TAG = "TestsurfaceviewActivity";  
  20.   
  21.     /** Called when the activity is first created. */  
  22.     @Override  
  23.     public void onCreate(Bundle savedInstanceState) {  
  24.         super.onCreate(savedInstanceState);  
  25.         setContentView(R.layout.main);  
  26.         // setContentView(new MySurfaceView(this)); // 这里以MySurfaceView作为显示View   
  27.         onTestInit();  
  28.     }  
  29.   
  30.     private SurfaceView drawSV = null;  
  31.     private SurfaceHolder drawSH = null;  
  32.     ArrayList<Integer> imgList = new ArrayList<Integer>();   
  33.     private int mWidth= 0, mHeight = 0;  
  34.     private Bitmap bitmap = null;  
  35.     private LoadImage loadImg = new LoadImage();  
  36.     private DrawImage drawImg = null;  
  37.   
  38.     private void onTestInit() {  
  39.         drawSV = (SurfaceView) this.findViewById(R.id.SurfaceDrawView);  
  40.         drawSH = drawSV.getHolder();  
  41.         drawSH.addCallback(new MySVCallback());  
  42.     }  
  43.       
  44.     private int onTestStart(){  
  45.         if(loadImg != null){  
  46.             loadImg.start();              
  47.         }  
  48.         drawImg = new DrawImage(0,mHeight);  
  49.         drawImg.start();  
  50.         return 0;  
  51.     }  
  52.       
  53.     private void onTestStop(){  
  54.         if(loadImg != null){  
  55.             loadImg.stop();  
  56.         }  
  57.           
  58.         if(drawImg != null){  
  59.             drawImg.stop();  
  60.         }  
  61.     }  
  62.   
  63.     private class MySVCallback implements SurfaceHolder.Callback {  
  64.         @Override  
  65.         public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  66.                 int height) {  
  67.             // TODO Auto-generated method stub   
  68.             Log.i(TAG, "surfaceChanged is called");  
  69.         }  
  70.   
  71.         @Override  
  72.         public void surfaceCreated(SurfaceHolder holder) {  
  73.             // TODO Auto-generated method stub   
  74.             Log.i(TAG, "surfaceCreated is called");  
  75.             // 用反射机制来获取资源中的图片ID和尺寸   
  76.             Field[] fields = R.drawable.class.getDeclaredFields();  
  77.             for (Field field : fields) {  
  78.                 // 除了icon及launcher之外的图片   
  79.                 if (!"icon".equals(field.getName())  
  80.                         && !"ic_launcher".equals(field.getName())) {  
  81.                     int index = 0;  
  82.                     try {  
  83.                         index = field.getInt(R.drawable.class);  
  84.                     } catch (IllegalArgumentException e) {  
  85.                         // TODO Auto-generated catch block   
  86.                         e.printStackTrace();  
  87.                     } catch (IllegalAccessException e) {  
  88.                         // TODO Auto-generated catch block   
  89.                         e.printStackTrace();  
  90.                     }  
  91.                     // 保存图片ID   
  92.                     imgList.add(index);  
  93.                 }  
  94.             }  
  95.               
  96.             Log.i(TAG,"imglist size = "+imgList.size());  
  97.             // 取得图像大小     
  98.             Bitmap bmImg = BitmapFactory.decodeResource(getResources(),    
  99.                     imgList.get(0));  
  100.   
  101.             mWidth  = bmImg.getWidth();   
  102.             mHeight = bmImg.getHeight();  
  103.               
  104.             onTestStart();  
  105.         }  
  106.   
  107.         @Override  
  108.         public void surfaceDestroyed(SurfaceHolder holder) {  
  109.             // TODO Auto-generated method stub   
  110.             Log.i(TAG, "surfaceDestroyed is called");  
  111.         }         
  112.     }  
  113.   
  114.     private class LoadImage extends Thread {  
  115.         private int imgIndex = 0;  
  116.   
  117.         public void run() {  
  118.             while (true) {  
  119.                 bitmap = BitmapFactory.decodeResource(getResources(),  
  120.                         imgList.get(imgIndex));  
  121.                 ++imgIndex;  
  122.                 if (imgIndex == imgList.size()) { // 循环取图片数据   
  123.                     imgIndex = 0;  
  124.                 }  
  125.             }  
  126.         }  
  127.     }  
  128.       
  129.     private class DrawImage extends Thread{  
  130.         private int x,y;  
  131.         public DrawImage(int x,int y){  
  132.             this.x = x;  
  133.             this.y = y;  
  134.         }  
  135.           
  136.         private void ClearScreen(){  
  137.             Canvas canvas = drawSH.lockCanvas(null);  
  138.             canvas.drawColor(Color.BLACK);// 清除画布   
  139.             drawSH.unlockCanvasAndPost(canvas);  
  140.         }  
  141.           
  142.         public void run() {  
  143.             while (true) {  
  144.                 if (bitmap != null) {  
  145.                     /** 
  146.                      * 以下两个有明显的效率差异，lockCanvas()指定Rect内减少循环画线的次数， 
  147.                      * 可以提高绘图效率,全屏刷新时会很闪烁 
  148.                      */  
  149.                     Canvas c = drawSH.lockCanvas(new Rect(this.x, this.y,  
  150.                             this.x + mWidth, this.y + mHeight));  
  151. //                  Canvas c = drawSH.lockCanvas();   
  152.                     c.drawBitmap(bitmap, this.x, this.y, new Paint());  
  153.                     drawSH.unlockCanvasAndPost(c);// 将显示内容上屏   
  154.                       
  155.                     this.x += 10;  
  156.                     //如果到了终点，则清屏重来   
  157.                     if(this.x > 1280 - mWidth){  
  158.                         this.x = 0;  
  159.                         ClearScreen();  
  160.                     }  
  161.                 }  
  162.             }  
  163.         }  
  164.     }  
  165. }

相关内容