Android進階5：SurfaceView實現原理分析
SurfaceView的概念
第一次接觸SurfaceView，找了不少資料才理解SurfaceView概念，總結查資料的結果。Android中有一種特殊的視圖，稱爲SurefaceView，與平時時候的 TextView、Button的區別：java
- 它擁有獨立的特殊的繪製表面，即 它不與其宿主窗口共享一個繪製表面
- SurefaceView的UI能夠在一個獨立的線程中進行繪製
- 由於不會佔用主線程資源，一方面能夠實現複雜而高效的UI，二是不會致使用戶輸入得不到及時響應。
綜合這些特色，SurfaceView 通常用來實現動態的或者比較複雜的圖像還有動畫的顯示。android
爲何須要SurfaceView
普通空間，TextView,Button等，都是講本身的UI繪製在宿主窗口的繪製表面Surface之上，意味着他們的UI在應用程序的主線程中繪製的。可是主線程除了繪製UI以外，還要及時響應用戶輸入，手勢等，不然，系統會認爲應用程序沒響應，ANR。web
所以，對一些遊戲畫面，或者攝像頭，視頻播放等，UI都比較複雜，要求可以進行高效的繪製，所以，他們的UI不適合在主線程中繪製。這時候就必需要給那些須要複雜而高效的UI視圖生成一個獨立的繪製表面Surface,而且使用獨立的線程來繪製這些視圖UI。canvas
理解SurfaceView的造成
每一個窗口在SurfaceFlinger服務中都對應有一個layer，用來描述它的繪製表面surface。對於那些具備SurfaceView的窗口來講，每一個SurfaceFlinger服務中還對應一個獨立的Layer或者LayerBuffer，用來單獨描述它的繪製表面，以區別它的宿主窗口的繪製表面。app
不管是LayerBuffer，仍是Layer，它們都是以LayerBase爲基類的，也就是說，SurfaceFlinger服務把全部的LayerBuffer和Layer都抽象爲LayerBase，所以就能夠用統一的流程來繪製和合成它們的UI。因爲LayerBuffer的繪製和合成與Layer的繪製和合成是相似的ide
爲了接下來能夠方便地描述SurfaceView的實現原理分析，咱們假設在一個Activity窗口的視圖結構中，除了有一個DecorView頂層視圖以外，還有兩個TextView控件，以及一個SurfaceView視圖，這樣該Activity窗口在SurfaceFlinger服務中就對應有兩個Layer或者一個Layer的一個LayerBuffer，如圖1所示
函數
在圖1中，Activity窗口的頂層視圖DecorView及其兩個TextView控件的UI都是繪製在SurfaceFlinger服務中的同一個Layer上面的，而SurfaceView的UI是繪製在SurfaceFlinger服務中的另一個Layer或者LayerBuffer上的。佈局
注意，用來描述SurfaceView的Layer或者LayerBuffer的Z軸位置是小於用來其宿主Activity窗口的Layer的Z軸位置的，可是前者會在後者的上面挖一個「洞」出來，以便它的UI能夠對用戶可見。實際上，SurfaceView在其宿主Activity窗口上所挖的「洞」只不過是在其宿主Activity窗口上設置了一塊透明區域。post
從整體上描述了SurfaceView的大體實現原理以後，接下來咱們就詳細分析它的具體實現過程，包括它的繪圖表面的建立過程、在宿主窗口上面進行挖洞的過程，以及繪製過程。參考連接:https://blog.csdn.net/luoshengyang/article/details/8661317/動畫
SurfaceView的繪製過程
SurfaceView雖然具備獨立的繪圖表面，不過它仍然是宿主窗口的視圖結構中的一個結點，所以，它仍然是能夠參與到宿主窗口的繪製流程中去的。從前面Android應用程序窗口（Activity）的測量（Measure）、佈局（Layout）和繪製（Draw）過程分析一文能夠知道，窗口在繪製的過程當中，每個子視圖的成員函數draw或者dispatchDraw都會被調用到，以便它們能夠繪製本身的UI。
SurfaceView類的成員函數draw和dispatchDraw的實現以下所示：
@Override
public void draw(Canvas canvas) {
if (mDrawFinished && !isAboveParent()) {
// draw() is not called when SKIP_DRAW is set
if ((mPrivateFlags & PFLAG_SKIP_DRAW) == 0) {
// punch a whole in the view-hierarchy below us
canvas.drawColor(0, PorterDuff.Mode.CLEAR);
}
}
super.draw(canvas);
}
@Override
protected void dispatchDraw(Canvas canvas) {
if (mDrawFinished && !isAboveParent()) {
// draw() is not called when SKIP_DRAW is set
if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
// punch a whole in the view-hierarchy below us
canvas.drawColor(0, PorterDuff.Mode.CLEAR);
}
}
super.dispatchDraw(canvas);
}
複製代碼
SurfaceView類的成員函數draw和dispatchDraw的參數canvas所描述的都是創建在宿主窗口的繪圖表面上的畫布，所以，在這塊畫布上繪製的任何UI都是出如今宿主窗口的繪圖表面上的.
原本SurfaceView類的成員函數draw是用來將本身的UI繪製在宿主窗口的繪圖表面上的，可是這裏咱們能夠看到，若是當前正在處理的SurfaceView不是用做宿主窗口面板的時候，即其成員變量mWindowType的值不等於WindowManager.LayoutParams.TYPE_APPLICATION_PANEL的時候，SurfaceView類的成員函數draw只是簡單地將它所佔據的區域繪製爲黑色。
原本SurfaceView類的成員函數dispatchDraw是用來繪製SurfaceView的子視圖的，可是這裏咱們一樣看到，若是當前正在處理的SurfaceView不是用做宿主窗口面板的時候 ，那麼SurfaceView類的成員函數dispatchDraw只是簡單地將它所佔據的區域繪製爲黑色，同時，它還會經過調用另一個成員函數updateWindow更新本身的UI，實際上就是請求WindowManagerService服務對本身的UI進行佈局，以及建立繪圖表面
從SurfaceView類的成員函數draw和dispatchDraw的實現就能夠看出，SurfaceView在其宿主窗口的繪圖表面上面所作的操做就是將本身所佔據的區域繪爲黑色，除此以外，就沒有其它更多的操做了，這是由於SurfaceView的UI是要展示在它本身的繪圖表面上面的。接下來咱們就分析如何在SurfaceView的繪圖表面上面進行UI繪製。
從前面Android應用程序窗口（Activity）的測量（Measure）、佈局（Layout）和繪製（Draw）過程分析一文能夠知道，若是要在一個繪圖表面進行UI繪製，那麼就順序執行如下的操做：
(1). 在繪圖表面的基礎上創建一塊畫布，即得到一個Canvas對象。
(2). 利用Canvas類提供的繪圖接口在前面得到的畫布上繪製任意的UI。
(3). 將已經填充好了UI數據的畫布緩衝區提交給SurfaceFlinger服務，以便SurfaceFlinger服務能夠將它合成到屏幕上去。
複製代碼
分析源碼
分析 Surface，SurfaceHolder，SurfaceView 三個類
Surface:
處理被屏幕排序的原生的buffer，Android中的Surface就是一個用來畫圖形（graphics）或圖像（image）的地方，對於View及其子類，都是畫在Surface上，各Surface對象經過Surfaceflinger合成到frameBuffer，每一個Surface都是雙緩衝（實際上就是兩個線程，一個渲染線程，一個UI更新線程），它有一個backBuffer和一個frontBuffer，Surface中建立了Canvas對象，用來管理Surface繪圖操做，Canvas對應Bitmap，存儲Surface中的內容。
SurfaceView:
SurfaceView是View的子類，且實現了Parcelable接口且實現了Parcelable接口，其中內嵌了一個專門用於繪製的Surface，SurfaceView能夠控制這個Surface的格式和尺寸，以及Surface的繪製位置。能夠理解爲Surface就是管理數據的地方，SurfaceView就是展現數據的地方。
SurfaceHolder:
一個管理SurfaceHolder的容器。SurfaceHolder是一個接口，可理解爲一個Surface的監聽器。 經過回調方法addCallback（SurfaceHolder.Callback callback )監聽Surface的建立 經過獲取Surface中的Canvas對象，並鎖定之。所獲得的Canvas對象 經過當修改Surface中的數據完成後，釋放同步鎖，並提交改變Surface的狀態及圖像，將新的圖像數據進行展現。-
而最後綜合：SurfaceView中調用getHolder方法，能夠得到當前SurfaceView中的Surface對應的SurfaceHolder，SurfaceHolder開始對Surface進行管理操做。這裏其實按MVC模式理解的話，能夠更好理解。M:Surface(圖像數據)，V:SurfaceView(圖像展現)，C:SurfaceHolder(圖像數據管理)。
Surface源碼
/**
* Handle onto a raw buffer that is being managed by the screen compositor.
*/
public class Surface implements Parcelable {
// code......
}
複製代碼
首先來看 Surface 這個類，它實現了 Parcelable 接口進行序列化（這裏主要用來在進程間傳遞 surface 對象），用來處理屏幕顯示緩衝區的數據，源碼中對它的註釋爲： Handle onto a raw buffer that is being managed by the screen compositor. Surface是原始圖像緩衝區（raw buffer）的一個句柄，而原始圖像緩衝區是由屏幕圖像合成器（screen compositor）管理的。
- 由屏幕顯示內容合成器(screen compositor)所管理的原生緩衝器的句柄（相似句柄） - 名詞解釋：句柄，英文：HANDLE，數據對象進入內存以後獲取到內存地址，可是所在的內存地址並非固定的，須要用句柄來存儲內容所在的內存地址。從數據類型上來看它只是一個32位(或64位)的無符號整數。 - Surface 充當句柄的角色，用來獲取源生緩衝區以及其中的內容 - 源生緩衝區（raw buffer）用來保存當前窗口的像素數據 - 因而可知 Surface 就是 Android 中用來繪圖的的地方，具體來講應該是 Surface 中的 Canvas Surface 中定義了畫布相關的 Canvas 對象
private final Canvas mCanvas = new CompatibleCanvas();
複製代碼
Java中，繪圖一般在一個 Canvas 對象上進行的，Surface 中也包含了一個 Canvas 對象，這裏的 CompatibleCanvas 是Surface.java 中的一個內部類，其中包含一個矩陣對象Matrix（變量名mOrigMatrix）。矩陣Matrix就是一塊內存區域，針對View的各類繪畫操做都保存在此內存中。
Surface 內部有一個 CompatibleCanvas 的內部類，這個內部類的做用是爲了可以兼容 Android 各個分辨率的屏幕，根據不一樣屏幕的分辨率處理不一樣的圖像數據。
private final class CompatibleCanvas extends Canvas {
// A temp matrix to remember what an application obtained via {@link getMatrix}
private Matrix mOrigMatrix = null;
@Override
public void setMatrix(Matrix matrix) {
if (mCompatibleMatrix == null || mOrigMatrix == null || mOrigMatrix.equals(matrix)) {
// don't scale the matrix if it's not compatibility mode, or
// the matrix was obtained from getMatrix.
super.setMatrix(matrix);
} else {
Matrix m = new Matrix(mCompatibleMatrix);
m.preConcat(matrix);
super.setMatrix(m);
}
}
@SuppressWarnings("deprecation")
@Override
public void getMatrix(Matrix m) {
super.getMatrix(m);
if (mOrigMatrix == null) {
mOrigMatrix = new Matrix();
}
mOrigMatrix.set(m);
}
}
複製代碼
1.Surface的兩個重要方法：
Surface中的不少方法都是原生方法，lockCanvas和unlockCanvasAndPost也是原生的，這裏不是指SurfaceHolder中的lockCanvas和unlockCanvasAndPost，SurfaceHolder只是作了封裝。
- lockCanvas(…) + Gets a Canvas for drawing into this surface. 獲取進行繪畫的 Canvas 對象 + After drawing into the provided Canvas, the caller must invoke unlockCanvasAndPost to post the new contents to the surface. 繪製完一幀的數據以後須要調用 unlockCanvasAndPost 方法把畫布解鎖，而後把畫好的圖像 Post 到當前屏幕上去顯示 + 當一個 Canvas 在被繪製的時候，它是出於被鎖定的狀態，就是說必須等待正在繪製的這一幀繪製完成以後並解鎖畫布以後才能進行別的操做 + 實際鎖住 Canvas 的過程是在 jni 層完成的
- unlockCanvasAndPost(…) + Posts the new contents of the Canvas to the surface and releases the Canvas.將新繪製的圖像內容傳給 surface 以後這個 Canvas 對象會被釋放掉（實際釋放的過程是在 jni 層完成的）
urface 的 lockCanvas 和 unlockCanvasAndPost 兩個方法最終都是調用 jni 層的方法來處理，有興趣能夠看下相關的源碼：
/frameworks/native/libs/gui/Surface.cpp /frameworks/base/core/jni/android_view_Surface.cpp
複製代碼
SurfaceHolder源碼
SurfaceHolder 其實是一個接口，它充當的是 Controller 的角色。
package android.view;
import android.graphics.Canvas;
import android.graphics.Rect;
/**
* Abstract interface to someone holding a display surface. Allows you to
* control the surface size and format, edit the pixels in the surface, and
* monitor changes to the surface. This interface is typically available
* through the {@link SurfaceView} class.
*
* <p>When using this interface from a thread other than the one running
* its {@link SurfaceView}, you will want to carefully read the
* methods
* {@link #lockCanvas} and {@link Callback#surfaceCreated Callback.surfaceCreated()}.
*/
public interface SurfaceHolder {
...otherCodes
public interface Callback {
public void surfaceCreated(SurfaceHolder holder);
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height);
public void surfaceDestroyed(SurfaceHolder holder);
}
/**
* Additional callbacks that can be received for {@link Callback}.
*/
public interface Callback2 extends Callback {
void surfaceRedrawNeeded(SurfaceHolder holder);
default void surfaceRedrawNeededAsync(SurfaceHolder holder, Runnable drawingFinished) {
surfaceRedrawNeeded(holder);
drawingFinished.run();
}
}
public void addCallback(Callback callback);
public void removeCallback(Callback callback);
public boolean isCreating();
@Deprecated
public void setType(int type);
public void setFixedSize(int width, int height);
public void setSizeFromLayout();
public void setFormat(int format);
public void setKeepScreenOn(boolean screenOn);
public Canvas lockCanvas();
public Canvas lockCanvas(Rect dirty);
default Canvas lockHardwareCanvas() {
throw new IllegalStateException("This SurfaceHolder doesn't support lockHardwareCanvas");
}
public void unlockCanvasAndPost(Canvas canvas);
public Rect getSurfaceFrame();
public Surface getSurface();
}
複製代碼
- 關鍵接口 Callback
callback 是 SurfaceHolder 內部的一個接口，例子中就實現了這個接口來控制繪製動畫的線程。
接口中有如下三個方法
- public void surfaceCreated(SurfaceHolder holder); + Surface 第一次被建立時被調用，例如 SurfaceView 從不可見狀態到可見狀態時
- 在這個方法被調用到 surfaceDestroyed 方法被調用以前的這段時間，Surface 對象是能夠被操做的，拿 SurfaceView 來講就是若是 SurfaceView 只要是在界面上可見的狀況下，就能夠對它進行繪圖和繪製動畫
- 這裏還有一點須要注意，Surface 在一個線程中處理須要渲染的圖像數據，若是你已經在另外一個線程裏面處理了數據渲染，就不須要在這裏開啓線程對 Surface 進行繪製了
- public void surfaceChanged(SurfaceHolder holder, int format, int width, int height);
- Surface 大小和格式改變時會被調用，例如橫豎屏切換時若是須要對 Sufface 的圖像和動畫進行處理，就須要在這裏實現
- 這個方法在 surfaceCreated 以後至少會被調用一次
- public void surfaceDestroyed(SurfaceHolder holder);
- Surface 被銷燬時被調用，例如 SurfaceView 從可見到不可見狀態時
- 在這個方法被調用過以後，就不可以再對 Surface 對象進行任何操做，因此須要保證繪圖的線程在這個方法調用以後再也不對 Surface 進行操做，不然會報錯
SurfaceView源碼
SurfaceView，就是用來顯示 Surface 數據的 View，經過 SurfaceView 來看到 Surface 的數據。
public class SurfaceView extends View implements ViewRootImpl.WindowStoppedCallback {
//OtherCodes
final ArrayList<SurfaceHolder.Callback> mCallbacks
= new ArrayList<SurfaceHolder.Callback>();//重要的回調集合
final int[] mLocation = new int[2];
final ReentrantLock mSurfaceLock = new ReentrantLock();
// Current surface in use
final Surface mSurface = new Surface();
//OtherCodes
/**
* Return the SurfaceHolder providing access and control over this
* SurfaceView's underlying surface.
*
* @return SurfaceHolder The holder of the surface.
*/
//獲取當前持有的holder
public SurfaceHolder getHolder() {
return mSurfaceHolder;
}
//surfaceView持有mSurfaceHolder的final類。對上面的surface進行管理
private final SurfaceHolder mSurfaceHolder = new SurfaceHolder() {
private static final String LOG_TAG = "SurfaceHolder";
@Override
public boolean isCreating() {
return mIsCreating;
}
//把holder.callback添加到上面回調集合
@Override
public void addCallback(Callback callback) {
synchronized (mCallbacks) {
// This is a linear search, but in practice we'll
// have only a couple callbacks, so it doesn't matter.
if (mCallbacks.contains(callback) == false) {
mCallbacks.add(callback);
}
}
}
@Override
public void removeCallback(Callback callback) {
synchronized (mCallbacks) {
mCallbacks.remove(callback);
}
}
@Override
public void setFixedSize(int width, int height) {
if (mRequestedWidth != width || mRequestedHeight != height) {
mRequestedWidth = width;
mRequestedHeight = height;
requestLayout();
}
}
@Override
public void setSizeFromLayout() {
if (mRequestedWidth != -1 || mRequestedHeight != -1) {
mRequestedWidth = mRequestedHeight = -1;
requestLayout();
}
}
@Override
public void setFormat(int format) {
// for backward compatibility reason, OPAQUE always
// means 565 for SurfaceView
if (format == PixelFormat.OPAQUE)
format = PixelFormat.RGB_565;
mRequestedFormat = format;
if (mSurfaceControl != null) {
updateSurface();
}
}
/**
* @deprecated setType is now ignored.
*/
@Override
@Deprecated
public void setType(int type) { }
@Override
public void setKeepScreenOn(boolean screenOn) {
runOnUiThread(() -> SurfaceView.this.setKeepScreenOn(screenOn));
}
/**
* Gets a {@link Canvas} for drawing into the SurfaceView's Surface
*
* After drawing into the provided {@link Canvas}, the caller must
* invoke {@link #unlockCanvasAndPost} to post the new contents to the surface.
*
* The caller must redraw the entire surface.
* @return A canvas for drawing into the surface.
*/
//封裝的鎖Canvas
@Override
public Canvas lockCanvas() {
return internalLockCanvas(null, false);
}
/**
* Gets a {@link Canvas} for drawing into the SurfaceView's Surface
*
* After drawing into the provided {@link Canvas}, the caller must
* invoke {@link #unlockCanvasAndPost} to post the new contents to the surface.
*
* @param inOutDirty A rectangle that represents the dirty region that the caller wants
* to redraw. This function may choose to expand the dirty rectangle if for example
* the surface has been resized or if the previous contents of the surface were
* not available. The caller must redraw the entire dirty region as represented
* by the contents of the inOutDirty rectangle upon return from this function.
* The caller may also pass <code>null</code> instead, in the case where the
* entire surface should be redrawn.
* @return A canvas for drawing into the surface.
*/
@Override
public Canvas lockCanvas(Rect inOutDirty) {
return internalLockCanvas(inOutDirty, false);
}
@Override
public Canvas lockHardwareCanvas() {
return internalLockCanvas(null, true);
}
//內部鎖畫布
private Canvas internalLockCanvas(Rect dirty, boolean hardware) {
mSurfaceLock.lock();
if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " " + "Locking canvas... stopped="
+ mDrawingStopped + ", surfaceControl=" + mSurfaceControl);
Canvas c = null;
if (!mDrawingStopped && mSurfaceControl != null) {
try {
//最終是鎖住持有的surface的canvas，上面說的surface的lockcanvas是jni方法
if (hardware) {
c = mSurface.lockHardwareCanvas();
} else {
c = mSurface.lockCanvas(dirty);
}
} catch (Exception e) {
Log.e(LOG_TAG, "Exception locking surface", e);
}
}
if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " " + "Returned canvas: " + c);
if (c != null) {
mLastLockTime = SystemClock.uptimeMillis();
return c;
}
// If the Surface is not ready to be drawn, then return null,
// but throttle calls to this function so it isn't called more
// than every 100ms.
long now = SystemClock.uptimeMillis();
long nextTime = mLastLockTime + 100;
if (nextTime > now) {
try {
Thread.sleep(nextTime-now);
} catch (InterruptedException e) {
}
now = SystemClock.uptimeMillis();
}
mLastLockTime = now;
mSurfaceLock.unlock();
return null;
}
/**
* Posts the new contents of the {@link Canvas} to the surface and
* releases the {@link Canvas}.
*
* @param canvas The canvas previously obtained from {@link #lockCanvas}.
*/
//封裝的解鎖canvas，實際也是調用Surafce的解鎖canvas
@Override
public void unlockCanvasAndPost(Canvas canvas) {
mSurface.unlockCanvasAndPost(canvas);
mSurfaceLock.unlock();
}
//獲取當前持有的 surface
@Override
public Surface getSurface() {
return mSurface;
}
@Override
public Rect getSurfaceFrame() {
return mSurfaceFrame;
}
};
}
...otherCodes
複製代碼
SurfaceView的使用
surfaceview提供了兩個線程：UI線程和渲染線程。
- 全部SurfaceView和SurfaceHolder.Callback的方法都應該在UI線程裏調用，通常來講就是應用程序的主線程。渲染線程訪問的各類變量應該作同步處理。
- 因爲surface可能被銷燬，它只在SurfaceHolder.Callback.surfaceCreated()和SurfaceHolder.Callback.surfaceDestroyed()之間有效，因此要確保渲染線程訪問的是合法有效的surface。
SurfaceView是個重要的繪圖容器，它能夠在主線程外的線程中向屏幕繪圖，這樣能夠避免畫圖任務繁重的時候形成主線程阻塞，從而提升了程序的反應速度。在遊戲開發中多用到SurfaceView，遊戲中的背景、人物、動畫等等儘可能在畫布canvas中畫出。
能夠把Surface理解爲顯存的一個映射，寫入到Surface的內容能夠直接複製到顯存從而顯示出來，這會使得顯示速度很是快），Surface被銷燬以前必須結束。
應用過程：
1. class MyView extends SurfaceView implements SurfaceHolder.Callback
2. SurfaceView.getHolder()得到SurfaceHolder對象
3. SurfaceHolder.addCallback(callback)添加回調函數
4. SurfaceHolder.lockCanvas()得到Canvas對象並鎖定畫布
5. Canvas繪畫
6. SurfaceHolder.unlockCanvasAndPost(Canvas canvas)結束鎖定畫圖，並提交改變，將圖形顯示。
複製代碼
其中4,5,6都應該在繪圖線程中執行，1,2,3同步變量而且在主線程中執行。
SurfaceHolder能夠當作是一個surface控制器，用來操縱surface。處理它的Canvas上畫的效果和動畫，控制表面，大小，像素等。
SurfaceView的例子
public class MySurfaceView extends SurfaceView implements Runnable, SurfaceHolder.Callback {
private SurfaceHolder mHolder; // 用於控制SurfaceView
private Thread t; // 聲明一條線程
private volatile boolean flag; // 線程運行的標識，用於控制線程
private Canvas mCanvas; // 聲明一張畫布
private Paint p; // 聲明一支畫筆
float m_circle_r = 10;
public MySurfaceView(Context context) {
super(context);
mHolder = getHolder(); // 得到SurfaceHolder對象
mHolder.addCallback(this); // 爲SurfaceView添加狀態監聽
p = new Paint(); // 建立一個畫筆對象
p.setColor(Color.WHITE); // 設置畫筆的顏色爲白色
setFocusable(true); // 設置焦點
}
/**
* 當SurfaceView建立的時候，調用此函數
*/
@Override
public void surfaceCreated(SurfaceHolder holder) {
t = new Thread(this); // 建立一個線程對象
flag = true; // 把線程運行的標識設置成true
t.start(); // 啓動線程
}
/**
* 當SurfaceView的視圖發生改變的時候，調用此函數
*/
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
}
/**
* 當SurfaceView銷燬的時候，調用此函數
*/
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
flag = false; // 把線程運行的標識設置成false
mHolder.removeCallback(this);
}
/**
* 當屏幕被觸摸時調用
*/
@Override
public boolean onTouchEvent(MotionEvent event) {
return true;
}
/**
* 當用戶按鍵時調用
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
surfaceDestroyed(mHolder);
return super.onKeyDown(keyCode, event);
}
@Override
public void run() {
while (flag) {
try {
synchronized (mHolder) {
Thread.sleep(100); // 讓線程休息100毫秒
Draw(); // 調用自定義畫畫方法
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (mCanvas != null) {
// mHolder.unlockCanvasAndPost(mCanvas);//結束鎖定畫圖，並提交改變。
}
}
}
}
/**
* 自定義一個方法，在畫布上畫一個圓
*/
protected void Draw() {
mCanvas = mHolder.lockCanvas(); // 得到畫布對象，開始對畫布畫畫
if (mCanvas != null) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(Color.BLUE);
paint.setStrokeWidth(10);
paint.setStyle(Style.FILL);
if (m_circle_r >= (getWidth() / 10)) {
m_circle_r = 0;
} else {
m_circle_r++;
}
Bitmap pic = ((BitmapDrawable) getResources().getDrawable(
R.drawable.qq)).getBitmap();
mCanvas.drawBitmap(pic, 0, 0, paint);
for (int i = 0; i < 5; i++)
for (int j = 0; j < 8; j++)
mCanvas.drawCircle(
(getWidth() / 5) * i + (getWidth() / 10),
(getHeight() / 8) * j + (getHeight() / 16),
m_circle_r, paint);
mHolder.unlockCanvasAndPost(mCanvas); // 完成畫畫，把畫布顯示在屏幕上
}
}
}
複製代碼
參考連接
- https://tech.youzan.com/surfaceview-sourcecode/
- https://blog.csdn.net/luoshengyang/article/details/8303098
- https://www.zhihu.com/question/30922650
- https://blog.csdn.net/jam96/article/details/53180093
- https://www.jianshu.com/p/15060fc9ef18
- 1. Android視圖SurfaceView的實現原理分析
- 2. Android SurfaceView源碼分析
- 3. Android Handler 機制實現原理分析
- 4. KVO原理分析及使用進階
- 5. React Native for Android 原理分析與實踐：實現原理
- 6. 【進階3-5期】深度解析 new 原理及模擬實現
- 7. 【vuejs進階】 vuejs路由實現原理
- 8. Android進階：5、RxJava2源碼解析 2
- 9. Android進階7：內存優化——LeakCanary原理分析
- 10. HashMap實現原理分析
- 更多相關文章...
- • Git 分支管理 - Git 教程
- • MyBatis的工作原理 - MyBatis教程
- • Java Agent入門實戰（三）-JVM Attach原理與使用
- • ☆基於Java Instrument的Agent實現
-
每一个你不满意的现在，都有一个你没有努力的曾经。