SurfaceView

  SurfaceView由于可以直接从内存或者DMA（见备注）等硬件接口取得图像数据，因此是个非常重要的绘图容器，这次我就用两篇文章来介绍SurfaceView的用法。网上介绍SurfaceView的用法有很多，写法也层出不同，例如继承SurfaceView类，或者继承SurfaceHolder.Callback类等，这个可以根据功能实际需要自己选择，我这里就直接在普通的用户界面调用SurfaceHolder的lockCanvas和unlockCanvasAndPost。

        先来看看程序运行的截图：

截图1主要演示了直接把正弦波绘画在SurfaceView上

对比上面的左右两图，右图用.lockCanvas(null)，而左图用.lockCanvas(new Rect(oldX, 0, oldX + length,
    getWindowManager().getDefaultDisplay().getHeight()))，对比一下两个效果，由于左图是按指定Rect绘画，所以效率会比右图的全控件绘画高些，并且在清屏之后(canvas.drawColor(Color.BLACK))不会留有上次绘画的残留。

 

接下来贴出main.xml的源码:

[xhtml] view plaincopyprint?

    <?xml version="1.0" encoding="utf-8"?>  
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
        android:layout_width="fill_parent" android:layout_height="fill_parent"  
        android:orientation="vertical">  
      
        <LinearLayout android:id="@+id/LinearLayout01"  
            android:layout_width="wrap_content" android:layout_height="wrap_content">  
            <Button android:id="@+id/Button01" android:layout_width="wrap_content"  
                android:layout_height="wrap_content" android:text="简单绘画"></Button>  
            <Button android:id="@+id/Button02" android:layout_width="wrap_content"  
                android:layout_height="wrap_content" android:text="定时器绘画"></Button>  
        </LinearLayout>  
        <SurfaceView android:id="@+id/SurfaceView01"  
            android:layout_width="fill_parent" android:layout_height="fill_parent"></SurfaceView>  
    </LinearLayout>  

接下来贴出程序源码：

[java] view plaincopyprint?

    package com.testSurfaceView;  
      
    import java.util.Timer;  
    import java.util.TimerTask;  
      
    import android.app.Activity;  
    import android.graphics.Canvas;  
    import android.graphics.Color;  
    import android.graphics.Paint;  
    import android.graphics.Rect;  
    import android.os.Bundle;  
    import android.util.Log;  
    import android.view.SurfaceHolder;  
    import android.view.SurfaceView;  
    import android.view.View;  
    import android.widget.Button;  
      
    public class testSurfaceView extends Activity {  
        /** Called when the activity is first created. */  
        Button btnSimpleDraw, btnTimerDraw;  
        SurfaceView sfv;  
        SurfaceHolder sfh;  
      
        private Timer mTimer;  
        private MyTimerTask mTimerTask;  
        int Y_axis[],//保存正弦波的Y轴上的点  
        centerY,//中心线  
        oldX,oldY,//上一个XY点   
        currentX;//当前绘制到的X轴上的点  
      
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.main);  
      
            btnSimpleDraw = (Button) this.findViewById(R.id.Button01);  
            btnTimerDraw = (Button) this.findViewById(R.id.Button02);  
            btnSimpleDraw.setOnClickListener(new ClickEvent());  
            btnTimerDraw.setOnClickListener(new ClickEvent());  
            sfv = (SurfaceView) this.findViewById(R.id.SurfaceView01);  
            sfh = sfv.getHolder();  
      
            //动态绘制正弦波的定时器  
            mTimer = new Timer();  
            mTimerTask = new MyTimerTask();  
      
            // 初始化y轴数据  
            centerY = (getWindowManager().getDefaultDisplay().getHeight() - sfv  
                    .getTop()) / 2;  
            Y_axis = new int[getWindowManager().getDefaultDisplay().getWidth()];  
            for (int i = 1; i < Y_axis.length; i++) {// 计算正弦波  
                Y_axis[i - 1] = centerY  
                        - (int) (100 * Math.sin(i * 2 * Math.PI / 180));  
            }  
        }  
      
        class ClickEvent implements View.OnClickListener {  
      
            @Override  
            public void onClick(View v) {  
      
                if (v == btnSimpleDraw) {  
                    SimpleDraw(Y_axis.length-1);//直接绘制正弦波  
                  
                } else if (v == btnTimerDraw) {  
                    oldY = centerY;  
                    mTimer.schedule(mTimerTask, 0, 5);//动态绘制正弦波  
                }  
      
            }  
      
        }  
      
        class MyTimerTask extends TimerTask {  
            @Override  
            public void run() {  
      
                SimpleDraw(currentX);  
                currentX++;//往前进  
                if (currentX == Y_axis.length - 1) {//如果到了终点，则清屏重来  
                    ClearDraw();  
                    currentX = 0;  
                    oldY = centerY;  
                }  
            }  
      
        }  
          
        /*
         * 绘制指定区域
         */  
        void SimpleDraw(int length) {  
            if (length == 0)  
                oldX = 0;  
            Canvas canvas = sfh.lockCanvas(new Rect(oldX, 0, oldX + length,  
                    getWindowManager().getDefaultDisplay().getHeight()));// 关键:获取画布  
            Log.i("Canvas:",  
                    String.valueOf(oldX) + "," + String.valueOf(oldX + length));  
      
            Paint mPaint = new Paint();  
            mPaint.setColor(Color.GREEN);// 画笔为绿色  
            mPaint.setStrokeWidth(2);// 设置画笔粗细  
      
            int y;  
            for (int i = oldX + 1; i < length; i++) {// 绘画正弦波  
                y = Y_axis[i - 1];  
                canvas.drawLine(oldX, oldY, i, y, mPaint);  
                oldX = i;  
                oldY = y;  
            }  
            sfh.unlockCanvasAndPost(canvas);// 解锁画布，提交画好的图像  
        }  
      
        void ClearDraw() {  
            Canvas canvas = sfh.lockCanvas(null);  
            canvas.drawColor(Color.BLACK);// 清除画布  
            sfh.unlockCanvasAndPost(canvas);  
      
        }  
    }  

注意一下 for (int i = oldX + 1; i < length; i++) {// 绘画正弦波 这句，在.lockCanvas()指定Rect内减少循环画线的次数，可以提高绘图效率。

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

SurfaceView与多线程混搭，是为了防止动画闪烁而实现的一种多线程应用。android的多线程用法与JAVA的多线程用法完全一样，本文不做多线程方面的介绍了。直接讲解SurfaceView与多线程的混合使用，即开一条线程专门读取图片，另外一条线程专门绘图。

        本文程序运行截图如下，左边是开单个线程读取并绘图，右边是开两个线程，一个专门读取图片，一个专门绘图：

对比一下，右边动画的帧速明显比左边的快，左右两者都没使用Thread.sleep()。为什么要开两个线程一个读一个画，而不去开两个线程像左边那样都“边读边画”呢？因为SurfaceView每次绘图都会锁定Canvas,也就是说同一片区域这次没画完下次就不能画，因此要提高动画播放的效率，就得开一条线程专门画图，开另外一条线程做预处理的工作。

main.xml的源码：

[xhtml] view plaincopyprint?

    <?xml version="1.0" encoding="utf-8"?>  
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
        android:layout_width="fill_parent" android:layout_height="fill_parent"  
        android:orientation="vertical">  
      
        <LinearLayout android:id="@+id/LinearLayout01"  
            android:layout_width="wrap_content" android:layout_height="wrap_content">  
            <Button android:id="@+id/Button01" android:layout_width="wrap_content"  
                android:layout_height="wrap_content" android:text="单个独立线程"></Button>  
            <Button android:id="@+id/Button02" android:layout_width="wrap_content"  
                android:layout_height="wrap_content" android:text="两个独立线程"></Button>  
        </LinearLayout>  
        <SurfaceView android:id="@+id/SurfaceView01"  
            android:layout_width="fill_parent" android:layout_height="fill_parent"></SurfaceView>  
    </LinearLayout>  

本文程序的源码：

 
[java] view plaincopyprint?

    package com.testSurfaceView;  
      
    import java.lang.reflect.Field;  
    import java.util.ArrayList;  
    import android.app.Activity;  
    import android.graphics.Bitmap;  
    import android.graphics.BitmapFactory;  
    import android.graphics.Canvas;  
    import android.graphics.Paint;  
    import android.graphics.Rect;  
    import android.os.Bundle;  
    import android.util.Log;  
    import android.view.SurfaceHolder;  
    import android.view.SurfaceView;  
    import android.view.View;  
    import android.widget.Button;  
      
    public class testSurfaceView extends Activity {  
        /** Called when the activity is first created. */  
        Button btnSingleThread, btnDoubleThread;  
        SurfaceView sfv;  
        SurfaceHolder sfh;  
        ArrayList<Integer> imgList = new ArrayList<Integer>();  
        int imgWidth, imgHeight;  
        Bitmap bitmap;//独立线程读取，独立线程绘图  
      
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.main);  
      
            btnSingleThread = (Button) this.findViewById(R.id.Button01);  
            btnDoubleThread = (Button) this.findViewById(R.id.Button02);  
            btnSingleThread.setOnClickListener(new ClickEvent());  
            btnDoubleThread.setOnClickListener(new ClickEvent());  
            sfv = (SurfaceView) this.findViewById(R.id.SurfaceView01);  
            sfh = sfv.getHolder();  
            sfh.addCallback(new MyCallBack());// 自动运行surfaceCreated以及surfaceChanged  
        }  
      
        class ClickEvent implements View.OnClickListener {  
      
            @Override  
            public void onClick(View v) {  
      
                if (v == btnSingleThread) {  
                    new Load_DrawImage(0, 0).start();//开一条线程读取并绘图  
                } else if (v == btnDoubleThread) {  
                    new LoadImage().start();//开一条线程读取  
                    new DrawImage(imgWidth + 10, 0).start();//开一条线程绘图  
                }  
      
            }  
      
        }  
      
        class MyCallBack implements SurfaceHolder.Callback {  
      
            @Override  
            public void surfaceChanged(SurfaceHolder holder, int format, int width,  
                    int height) {  
                Log.i("Surface:", "Change");  
      
            }  
      
            @Override  
            public void surfaceCreated(SurfaceHolder holder) {  
                Log.i("Surface:", "Create");  
      
                // 用反射机制来获取资源中的图片ID和尺寸  
                Field[] fields = R.drawable.class.getDeclaredFields();  
                for (Field field : fields) {  
                    if (!"icon".equals(field.getName()))// 除了icon之外的图片  
                    {  
                        int index = 0;  
                        try {  
                            index = field.getInt(R.drawable.class);  
                        } catch (IllegalArgumentException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        } catch (IllegalAccessException e) {  
                            // TODO Auto-generated catch block  
                            e.printStackTrace();  
                        }  
                        // 保存图片ID  
                        imgList.add(index);  
                    }  
                }  
                // 取得图像大小  
                Bitmap bmImg = BitmapFactory.decodeResource(getResources(),  
                        imgList.get(0));  
                imgWidth = bmImg.getWidth();  
                imgHeight = bmImg.getHeight();  
            }  
      
            @Override  
            public void surfaceDestroyed(SurfaceHolder holder) {  
                Log.i("Surface:", "Destroy");  
      
            }  
      
        }  
      
        /*
         * 读取并显示图片的线程
         */  
        class Load_DrawImage extends Thread {  
            int x, y;  
            int imgIndex = 0;  
      
            public Load_DrawImage(int x, int y) {  
                this.x = x;  
                this.y = y;  
            }  
      
            public void run() {  
                while (true) {  
                    Canvas c = sfh.lockCanvas(new Rect(this.x, this.y, this.x  
                            + imgWidth, this.y + imgHeight));  
                    Bitmap bmImg = BitmapFactory.decodeResource(getResources(),  
                            imgList.get(imgIndex));  
                    c.drawBitmap(bmImg, this.x, this.y, new Paint());  
                    imgIndex++;  
                    if (imgIndex == imgList.size())  
                        imgIndex = 0;  
      
                    sfh.unlockCanvasAndPost(c);// 更新屏幕显示内容  
                }  
            }  
        };  
      
        /*
         * 只负责绘图的线程
         */  
        class DrawImage extends Thread {  
            int x, y;  
      
            public DrawImage(int x, int y) {  
                this.x = x;  
                this.y = y;  
            }  
      
            public void run() {  
                while (true) {  
                    if (bitmap != null) {//如果图像有效  
                        Canvas c = sfh.lockCanvas(new Rect(this.x, this.y, this.x  
                                + imgWidth, this.y + imgHeight));  
      
                        c.drawBitmap(bitmap, this.x, this.y, new Paint());  
      
                        sfh.unlockCanvasAndPost(c);// 更新屏幕显示内容  
                    }  
                }  
            }  
        };  
      
        /*
         * 只负责读取图片的线程
         */  
        class LoadImage extends Thread {  
            int imgIndex = 0;  
      
            public void run() {  
                while (true) {  
                    bitmap = BitmapFactory.decodeResource(getResources(),  
                            imgList.get(imgIndex));  
                    imgIndex++;  
                    if (imgIndex == imgList.size())//如果到尽头则重新读取  
                        imgIndex = 0;  
                }  
            }  
        };  


＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

 备注：

Direct Memory Access（存储器直接访问）是指一种高速的数据传输操作，允许在外部设备和存储器之间直接读写数据，既不通过CPU，也不需要CPU干预。整个数据传输操作在一个称为“DMA控制器”的控制下进行。CPU除了在数据传输开始和结束时做一点处理外，在传输过程中还可以进行其他的工作。这样，在大部分时间里，CPU和输入输出都处于并行操作，因此使整个计算机系统的效率大大提高。
DMA的概念:DMA是在专门的硬件（ DMA）控制下，实现高速外设和主存储器之间自动成批交换数据尽量减少CPU干预的输入/输出操作方式。通常有两种方式： ◎独占总线方式 ◎周期挪用方式
DMA的组成： ◎主存地址寄存器 ◎数据数量计数器 ◎DMA的控制/状态逻辑 ◎DMA请求触发器 ◎数据缓冲寄存器 ◎中断机构
DMA的传送数据的过程：由三个阶段组成 ◎传送前的预处理：由CPU完成以下步骤 向DMA卡送入设备识别信号，启动设备，测试设备运行状态，送入内存地址初值，传送数据个数， DMA的功能控制信号。 ◎数据传送：在DMA卡控制下自动完成◎传送结束处理 DMA 卡上应包括通用接口卡的全部组成部分,并多出如下内容: 主存地址寄存器，传送字数计数器，DMA控制逻辑，DMA请求，DMA响应，DMA工作方式，DMA优先级及排队逻辑等 一次完整的DMA传送过程： DMA 预处理，CPU向DMA送命令,如DMA方式，主存地址，传送的字数等，之后CPU执行原来的程序 DMA 控制在 I/O 设备与主存间交换数据： 准备一个数据, 向CPU发DMA请求,取得总线控制权，进行数据传送，修改卡上主存地址，修改字数计数器内且检查其值是否为零,不为零则继续传送，若已为零，则向 CPU发中断请求.
DMA技术的弊端：因为DMA允许外设直接访问内存，从而形成对总线的独占。这在实时性强的硬实时系统的嵌入式开发中将会造成中断延时过长。这在军事等系统中是不允许的