SurfaceView原理分析与应用

SurfaceView的简单分析和使用

• SurfaceView
• SurfaceHolder
• SurfaceView的简单使用

---

SurfaceView的原理分析

• 最近公司有一个任务是优化一个复杂场景的动画，动画UI的更新靠的是一个做了大量耗时操作的回调，导致主线程被阻塞，动画卡顿非常明显。要想优化这里的动画无非两个思路，第一就是减轻主线程的压力，第二是将动画在其他线程处理。第一种方法比较传统，能达到优化的效果，但不彻底，而且目前这个回调用的是广播这种异步的方式，延迟和阻塞在所难免。第二种方式可以根本性的解决这个问题，Android中有个特殊的View可以在主线程(UI线程)之外向屏幕绘制图形，那就是SurfaceView,说起SurfaceView,大家好像都知道有这么回事，但似乎都用的比较少，所以我来简单总结下这个View的相关内容.

看下SurfaceView的源代码：

public class SurfaceView extends View {
    static private final String TAG = "SurfaceView";

    final ArrayList<SurfaceHolder.Callback> mCallbacks
            = new ArrayList<SurfaceHolder.Callback>();

    final ReentrantLock mSurfaceLock = new ReentrantLock();
    final Surface mSurface = new Surface();       // Current surface in use
    final Surface mNewSurface = new Surface();    // New surface we are switching to

从源码中可以看到，SurfaceView继承了View，所以他会有普通View的所有特性，包括onMeasure、onLayout、onDraw等生命周期。普通的View会在当前window中的Surface中绘制（每个window对应一个Surface），而SurfaceView，可以从他的成员变量里看出，他拥有自己的Surface，这样做的目的也正是他的特殊之处，你可以创建一个专门的渲染线程在他的Surface上进行绘制，这样说并不严谨，每个Surface持有一个对应的Canvas，应该说是让Canvas来绘制。

SurfaceHolder

public interface SurfaceHolder {

    public interface Callback {

        public void surfaceCreated(SurfaceHolder holder);

        public void surfaceChanged(SurfaceHolder holder, int format, int width,
                int height);

        public void surfaceDestroyed(SurfaceHolder holder);
    }


    public void addCallback(Callback callback);

    public void removeCallback(Callback callback);

    public boolean isCreating();


    public Canvas lockCanvas();

    public Canvas lockCanvas(Rect dirty);

    public void unlockCanvasAndPost(Canvas canvas);

    public Rect getSurfaceFrame();

    public Surface getSurface();
}

• 每个SurfaceView中有一个SurfaceHolder，可以通过getHolder来得到他，他的作用是用来操作Surface，比较重要的两个方法是lockCanvas（）和unlockCanvas()；lockCanvas()可以锁定并得到Surface中的Canvas，我们可以直接操作Canvas绘制出我们想要的效果。
• SurfaceHolder有一个callback用于监听surface的创建，变化，和销毁。

protected void updateWindow(boolean force, boolean redrawNeeded) {
        ...
        mSurfaceLock.lock();

        try {
            redrawNeeded |= creating | reportDrawNeeded;

            SurfaceHolder.Callback callbacks[] = null;

            final boolean surfaceChanged = (relayoutResult
                    & WindowManagerGlobal.RELAYOUT_RES_SURFACE_CHANGED) != 0;
            if (mSurfaceCreated && (surfaceChanged || (!visible && visibleChanged))) {
                mSurfaceCreated = false;
                if (mSurface.isValid()) {
                    if (DEBUG) Log.i(TAG, "visibleChanged -- surfaceDestroyed");
                    callbacks = getSurfaceCallbacks();
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceDestroyed(mSurfaceHolder);
                    }
                }
            }

            mSurface.transferFrom(mNewSurface);

            if (visible && mSurface.isValid()) {
                if (!mSurfaceCreated && (surfaceChanged || visibleChanged)) {
                    mSurfaceCreated = true;
                    mIsCreating = true;
                    if (DEBUG) Log.i(TAG, "visibleChanged -- surfaceCreated");
                    if (callbacks == null) {
                        callbacks = getSurfaceCallbacks();
                    }
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceCreated(mSurfaceHolder);
                    }
                }
                if (creating || formatChanged || sizeChanged
                        || visibleChanged || realSizeChanged) {
                    if (DEBUG) Log.i(TAG, "surfaceChanged -- format=" + mFormat
                            + " w=" + myWidth + " h=" + myHeight);
                    if (callbacks == null) {
                        callbacks = getSurfaceCallbacks();
                    }
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceChanged(mSurfaceHolder, mFormat, myWidth, myHeight);
                    }
                }

            }
    }

• 可以看到三个回调的调用时机，销毁时，如果Surface状态改变了，变成了不可见，那么Surface就销毁。判断完销毁后会有一个transferfrom转换Surface的过程，如果旧的Surface销毁了，会把新的Surface当做目前的Surface，至于转换过程有点看不懂，似乎只是拷贝一份NewSurface，旧的用完就释放掉。接下来的surfaceCreated非常简单，如果surface变得可见并且有效，则表示已经创建，而如果surface的格式、大小、可见性等发生变化，则调用surfaceChanged()。

SurfaceView的简单使用

SurfaceView的使用也比较简单，我们继承SurfaceView就可以解决问题。

public class ZZZSurfaceView extends SurfaceView implements SurfaceHolder.Callback {

        private SurfaceHolder holder;
        private MyThread mThread;

        public ZZZSurfaceView(Context context) {
            super(context);
            //获取holder
            holder = this.getHolder();
            //添加回调
            holder.addCallback(this);
            //新建渲染线程
            mThread = new MyThread();
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            mThread.start();
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            //释放一些资源，停线程等
        }


        private class MyThread extends Thread {
            @Override
            public void run() {
                while (isDraw) {
                    drawAnim();
                }
                super.run();
            }
        }


        public void drawAnim() {
            Canvas canvas = holder.lockCanvas();
            try {
                drawZZZ(canvas);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                holder.unlockCanvasAndPost(canvas);
            }
        }

        private void drawZZZ(Canvas canvas) {
            //计算并绘制ZZZ动画
        }
    }

SurfaceView在一些UI线程可能会阻塞的情况下是一个优秀的动画解决方案，希望以后他可以在工作中帮到大家。