Android中SurfaceView使用詳解


1.什么是SurfaceView?

    Surface意為表層、表面,顧名思義SurfaceView就是指一個在表層的View對象。為什么說是在表層呢,這是因為它有點特殊跟其他View不一樣,其他View是繪制在“表層”的上面,而它就是充當“表層”本身。SDK的文檔 說到:SurfaceView就是在窗口上挖一個洞,它就是顯示在這個洞里,其他的View是顯示在窗口上,所以View可以顯式在 SurfaceView之上,你也可以添加一些層在SurfaceView之上。 從API中可以看出SurfaceView屬於View的子類 它是專門為制作游戲而產生的,它的功能非常強大,最重要的是它支持OpenGL ES庫,2D和3D的效果都可以實現。創建SurfaceView的時候需要實現SurfaceHolder.Callback接口,它可以用來監聽SurfaceView的狀態,比如:SurfaceView的改變 、SurfaceView的創建 、SurfaceView 銷毀等,我們可以在相應的方法中做一些比如初始化的操作或者清空的操作等等。

Android系統提供了View進行繪圖處理,我們通過自定義的View可以滿足大部分的繪圖需求,但是這有個問題就是我們通常自定義的View是用於主動更新情況的,用戶無法控制其繪制的速度,由於View是通過invalidate方法通知系統去調用view.onDraw方法進行重繪,而Android系統是通過發出VSYNC信號來進行屏幕的重繪,刷新的時間是16ms,如果在16ms內View完成不了執行的操作,用戶就會看着卡頓,比如當draw方法里執行的邏輯過多,需要頻繁刷新的界面上,例如游戲界面,那么就會不斷的阻塞主線程,從而導致畫面卡頓。而SurfaceView相當於是另一個繪圖線程,它是不會阻礙主線程,並且它在底層實現機制中實現了雙緩沖機制。

2.如何使用SurfaceView?

        首先SurfaceView也是一個View,它也有自己的生命周期。因為它需要另外一個線程來執行繪制操作,所以我們可以在它生命周期的初始化階 段開辟一個新線程,然后開始執行繪制,當生命周期的結束階段我們插入結束繪制線程的操作。這些是由其內部一個SurfaceHolder對象完成的。  

SurfaceView它的繪制原理是繪制前先鎖定畫布(獲取畫布),然后等都繪制結束以后在對畫布進行解鎖 ,最后在把畫布內容顯示到屏幕上。       

通常情況下,使用以下步驟來創建一個SurfaceView的模板:

(1)創建SurfaceView

創建自定義的SurfaceView繼承自SurfaceView,並實現兩個接口:SurfaceHolder.Callback和Runnable.代碼如下:

[java]  view plain  copy
  1.       
  2. public class MySurfaceView extends SurfaceView implements SurfaceHolder.Callback,Runnable  

通過實現這兩個接口,就需要在自定義的SurfaceView中實現接口的方法,對於SurfaceHolder.Callback方法,需要實現如下方法,其實就是SurfaceView的生命周期:

[java]  view plain  copy
  1. @Override  
  2.  public void surfaceCreated(SurfaceHolder holder) {  
  3.      
  4.   
  5.  }  
  6. @Override  
  7.  public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {  
  8.   
  9.  }  
  10.   
  11.  @Override  
  12.  public void surfaceDestroyed(SurfaceHolder holder) {  
  13.   
  14.  }  

對於Runnable接口,需要實現run()方法,

[java]  view plain  copy
  1.  @Override  
  2.     public void run() {  
  3.   
  4. }  

(2)初始化SurfaceView

在自定義的MySurfaceView的構造方法中,需要對SurfaceView進行初始化,包括SurfaceHolder的初始化、畫筆的初始化等。在自定義的SurfaceView中,通常需要定義以下三個成員變量:

[java]  view plain  copy
  1. private SurfaceHolder mHolder;  
  2. private Canvas mCanvas;//繪圖的畫布  
  3. private boolean mIsDrawing;//控制繪畫線程的標志位  
  SurfaceHolder,顧名思義,它里面保存了一個對Surface對象的引用,而我們執行繪制方法本質上就是操控Surface。SurfaceHolder因為保存了對Surface的引用,所以使用它來處理Surface的生命周期。(說到底 SurfaceView的生命周期其實就是Surface的生命周期)例如使用 SurfaceHolder來處理生命周期的初始化。

初始化代碼如下:

[java]  view plain  copy
  1. public MySurfaceView(Context context, AttributeSet attrs) {  
  2.        super(context, attrs);  
  3.        initView();  
  4.    }  
  5.   
  6.    public MySurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {  
  7.        super(context, attrs, defStyleAttr);  
  8.        initView();  
  9.    }  
  10.   
  11.    public MySurfaceView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {  
  12.        super(context, attrs, defStyleAttr);  
  13.    }  
  14.   
  15.    private void initView() {  
  16.        mHolder = getHolder();//獲取SurfaceHolder對象  
  17.        mHolder.addCallback(this);//注冊SurfaceHolder的回調方法  
  18.        setFocusable(true);  
  19.        setFocusableInTouchMode(true);  
  20.        this.setKeepScreenOn(true);  
  21.    }  

(3)使用SurfaceView

通過SurfaceHolder對象的lockCanvans()方法,我們可以獲取當前的Canvas繪圖對象。接下來的操作就和自定義View中的繪圖操作一樣了。需要注意的是這里獲取到的Canvas對象還是繼續上次的Canvas對象,而不是一個新的對象。因此,之前的繪圖操作都會被保留,如果需要擦除,則可以在繪制前,通過drawColor()方法來進行清屏操作。

繪制的時候,在surfaceCreated()方法中開啟子線程進行繪制,而子線程使用一個while(mIsDrawing)的循環來不停的進行繪制,在繪制的邏輯中通過lockCanvas()方法獲取Canvas對象進行繪制,通過unlockCanvasAndPost(mCanvas)方法對畫布內容進行提交。整體代碼模板如下:

[java]  view plain  copy
  1. import android.content.Context;  
  2. import android.graphics.Canvas;  
  3. import android.util.AttributeSet;  
  4. import android.view.SurfaceHolder;  
  5. import android.view.SurfaceView;  
  6.   
  7. public class MySurfaceView  extends SurfaceView  
  8.         implements SurfaceHolder.Callback, Runnable {  
  9.   
  10.     // SurfaceHolder  
  11.     private SurfaceHolder mHolder;  
  12.     // 用於繪圖的Canvas  
  13.     private Canvas mCanvas;  
  14.     // 子線程標志位  
  15.     private boolean mIsDrawing;  
  16.   
  17.     public MySurfaceView(Context context) {  
  18.         super(context);  
  19.         initView();  
  20.     }  
  21.   
  22.     public MySurfaceView(Context context, AttributeSet attrs) {  
  23.         super(context, attrs);  
  24.         initView();  
  25.     }  
  26.   
  27.     public MySurfaceView(Context context, AttributeSet attrs, int defStyle) {  
  28.         super(context, attrs, defStyle);  
  29.         initView();  
  30.     }  
  31.   
  32.     private void initView() {  
  33.         mHolder = getHolder();  
  34.         mHolder.addCallback(this);  
  35.         setFocusable(true);  
  36.         setFocusableInTouchMode(true);  
  37.         this.setKeepScreenOn(true);  
  38.         //mHolder.setFormat(PixelFormat.OPAQUE);  
  39.     }  
  40.   
  41.     @Override  
  42.     public void surfaceCreated(SurfaceHolder holder) {  
  43.         mIsDrawing = true;  
  44.         new Thread(this).start();  
  45.     }  
  46.   
  47.     @Override  
  48.     public void surfaceChanged(SurfaceHolder holder,  
  49.                                int format, int width, int height) {  
  50.     }  
  51.   
  52.     @Override  
  53.     public void surfaceDestroyed(SurfaceHolder holder) {  
  54.         mIsDrawing = false;  
  55.     }  
  56.   
  57.     @Override  
  58.     public void run() {  
  59.         while (mIsDrawing) {  
  60.             draw();  
  61.         }  
  62.     }  
  63.     //繪圖操作  
  64.     private void draw() {  
  65.         try {  
  66.             mCanvas = mHolder.lockCanvas();  
  67.             // draw sth繪制過程  
  68.         } catch (Exception e) {  
  69.         } finally {  
  70.             if (mCanvas != )  
  71.                 mHolder.unlockCanvasAndPost(mCanvas);//保證每次都將繪圖的內容提交  
  72.         }  
  73.     }  
  74. }  

這里說一個優化的地方,這就是在run方法中。

在我們的draw()方法每一次更新所耗費的時間是不確定的。舉個例子 比如第一次循環draw() 耗費了1000毫秒 ,第二次循環draw() 耗時2000毫秒。很明顯這樣就會造成運行刷新時間時快時慢,可能出現卡頓現象。為此最好保證每次刷新的時間是相同的,這樣可以保證整體畫面過渡流暢。

[java]  view plain  copy
  1. <span style="white-space:pre;"> </span>/**每30幀刷新一次屏幕**/  
  2.        public static final int TIME_IN_FRAME = 30;  
  3. @Override  
  4. public void run() {  
  5.     while (mIsRunning) {  
  6.   
  7.     /**取得更新之前的時間**/  
  8.     long startTime = System.currentTimeMillis();  
  9.   
  10.     /**在這里加上線程安全鎖**/  
  11.     synchronized (mSurfaceHolder) {  
  12.         /**拿到當前畫布 然后鎖定**/  
  13.         mCanvas =mSurfaceHolder.lockCanvas();  
  14.         draw();  
  15.         /**繪制結束后解鎖顯示在屏幕上**/  
  16.         mSurfaceHolder.unlockCanvasAndPost(mCanvas);  
  17.     }  
  18.   
  19.     /**取得更新結束的時間**/  
  20.     long endTime = System.currentTimeMillis();  
  21.   
  22.     /**計算出一次更新的毫秒數**/  
  23.     int diffTime  = (int)(endTime - startTime);  
  24.   
  25.     /**確保每次更新時間為30幀**/  
  26.     while(diffTime <=TIME_IN_FRAME) {  
  27.         diffTime = (int)(System.currentTimeMillis() - startTime);  
  28.         /**線程等待**/  
  29.         Thread.yield();  
  30.     }  
  31.   
  32.     }  
  33. }  
這里說一下Thread.yield(): 與Thread.sleep(long millis):的區別:

Thread.yield(): 是暫停當前正在執行的線程對象 ,並去執行其他線程。

Thread.sleep(long millis):則是使當前線程暫停參數中所指定的毫秒數然后在繼續執行線程。

3.SurfaceView的使用實例
(1)正弦曲線

要繪制一個正弦曲線,只需要不斷修改橫縱坐標的值,並讓他們滿足正弦函數即可。因此,我們需要一個Path對象來保存正弦函數上的坐標點,在子線程的while循環中,不斷改變橫縱坐標值。代碼如下:

[java]  view plain  copy
  1. public static final int TIME_IN_FRAME = 30;  
  2.     @Override  
  3.     public void run() {  
  4.         long startTime = System.currentTimeMillis();  
  5.          while(mIsDrawing){  
  6.              draw();  
  7. //             x+=1;  
  8. //             y=(int)(100*Math.sin(x*2*Math.PI/180)+400);  
  9. //             mPath.lineTo(x,y);  
  10.          }  
  11.           
  12.         /**取得更新結束的時間**/  
  13.         long endTime = System.currentTimeMillis();  
  14.   
  15.         /**計算出一次更新的毫秒數**/  
  16.         int diffTime  = (int)(endTime - startTime);  
  17.   
  18.         /**確保每次更新時間為30幀**/  
  19.         while(diffTime <=TIME_IN_FRAME) {  
  20.             diffTime = (int)(System.currentTimeMillis() - startTime);  
  21.             /**線程等待**/  
  22.             Thread.yield();  
  23.         }  
  24.     }  

(2)畫圖板

我們也可以通過使用SurfaceView來實現一個簡單的繪圖板,繪圖的方法與View中進行繪圖所使用的方法一樣,也是通過Path對象記錄手指滑動的路徑來進行繪圖。在SurfaceView的onTouchEvent()方法中記錄Path路徑,代碼如下所示:

[java]  view plain  copy
  1. @Override  
  2.    public boolean onTouchEvent(MotionEvent event) {  
  3.        int x=(int)event.getX();  
  4.        int y=(int)event.getY();  
  5.        switch (event.getAction()){  
  6.            case MotionEvent.ACTION_DOWN:  
  7.                mPath.moveTo(x,y);  
  8.                break;  
  9.            case MotionEvent.ACTION_MOVE:  
  10.                mPath.lineTo(x,y);  
  11.                break;  
  12.            case MotionEvent.ACTION_UP:  
  13.                break;  
  14.   
  15.        }  
  16.        return true;//表示此View攔截處理觸摸事件  
  17.    }  
並在draw方法中進行繪制:

[java]  view plain  copy
  1. private void draw() {  
  2.        try{  
  3.            mCanvas=mHolder.lockCanvas();//獲取Canvas對象進行繪制  
  4.            //SurfaceView背景  
  5.            mCanvas.drawColor(Color.WHITE);  
  6.            mCanvas.drawPath(mPath,mPaint);  
  7.        }catch (Exception e){  
  8.            e.printStackTrace();  
  9.        }finally {  
  10.            if (mCanvas!=){  
  11.                mHolder.unlockCanvasAndPost(mCanvas);//保證繪制的畫布內容提交  
  12.            }  
  13.        }  
  14.    }  

4.SurfaceView和View的區別

總的歸納起來SurfaceView和View不同之處有:

1. SurfaceView允許其他線程更新視圖對象(執行繪制方法)而View不允許這么做,它只允許UI線程更新視圖對象。

2. SurfaceView是放在其他最底層的視圖層次中,所有其他視圖層都在它上面,所以在它之上可以添加一些層,而且它不能是透明的。

3. 它執行動畫的效率比View高,而且你可以控制幀數。

4. SurfaceView在繪圖時使用l了雙緩沖機制,而View沒有。

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com