源码分析-GLSurfaceView的内部实现

发表于 |

前言

GLSurfaceView类是继承自SurfaceView的，并且实现了SurfaceHolder.Callback2接口。GLSurfaceView内部管理着一个surface，专门负责OpenGL渲染。GLSurfaceView内部通过GLThread和EGLHelper为我们完成了EGL环境渲染和渲染线程的创建及管理，使我们只需要在外部实现渲染器Renderer即可使用OpenGL ES进行绘图。所以，了解GLSurfaceView的内部逻辑对于我们使用OpenGL ES来绘图还是很有必要的。

GLSurfaceView的初始化

首先，我们在最外使用GLSurfaceView的时候，实例化GLSurfaceView时其会对自身进行初始化：

1
2
3
4
private void init() {
  SurfaceHolder holder = getHolder();
  holder.addCallback(this);
}

可以看到这里主要对自身的Holder设置了Callback2接口，然后在自身内部实现了Callback2的四个回调方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void surfaceCreated(SurfaceHolder holder) {
  mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
  mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
  mGLThread.onWindowResize(w,h);
}
public void surfaceRedrawNeeded(SurfaceHolder holder) {
  if(mGLThread != null) {
    mGLThread.requestRenderAndWait();
  }
}

可以看到四个回调方法最终都共同指向了GLThread，其实这里的GLThread是GLSurfaceView内部的绘制线程，使绘制工作可以独立于主线程（GLThread承担了SurfaceView中大部分的工作，具体的后面再细说）。至此，GLSurfaceView的初始化工作完成，但到这里渲染环境的初始化工作却还没有开始。

当实例化GLSurfaceView后，接着都会进行两个步骤，那就是设置OpenGL的版本号和渲染器：

1
2
this.setEGLContextClientVersion(2);	//设置OpenGL的版本号2.0
setRenderer(new MyRenderer());	//设置OpenGL的渲染器

这里重点要看setRenderer()这个方法，通过这个方法我们不仅为GLSurfaceView设置了renderer，还会对EGL环境进行初步的设置工作，最后还有调起GLThread，开启绘制线程。所以在GLSurfaceView的整个生命周期中，setRenderer()只能被调用一次。源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void setRenderer(Renderer renderer) {
  checkRenderThreadState();
  if(mEGLConfigChooser == null) {
    mEGLConfigChooser = new SimpleEGLConfigChooser(true);
  }
  if(mEGLContextFactory == null) {
    mEGLContextFactory = new DefaultContextFactory();
  }
  if(mEGLWindowSurfaceFactory == null) {
    mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
  }
  mRenderer = renderer;
  mGLThread = new GLThread(mThisWeakRef);
  mGLThread.start();
}

设置渲染器时，首先会对渲染线程的状态进行检查，如果GLThread已经存在即setRenderer已经被调用过，则抛出异常，这也是为什么setRenderer()只能在GLSurfaceView的整个生命周期中调用一次。然后会对mEGLConfigChooser、mEGLContextFactory、mEGLWindowSurfaceFactory进行实例化，再实例化GLThread并执行该渲染线程，其中传入的mThisWeakRef是当前GLSurfaceView的弱引用。

GLThread——GLSurfaceView内部的渲染线程

GLThread是一个继承Thread的类，主要的运行代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
while(true) {
  synchronized(sGLThreadManager) {
    while(true) {
      ......
      mEglHelper.start();
      ......
      sGLThreadManager.wait();
    }
  }
  ......
  mEglHelper.createSurface();
  ......
  gl = (GL10) mEglHelper.createGL();
  ......
  mRenderer.onSurfaceCreated(gl, mEglHelper.getEglConfig());
  ......
  mRenderer.onSurfaceChanged(gl, w, h);
  ......
  mRenderer.onDrawFrame(gl);
}

其中被synchronized(sGLThreadManager)同步的代码块是用于线程之间通信的，外部线程可以停止和恢复这个线程。这部分同步代码块的主要职责是创建EGL环境，GLThread对EGL的所有操作都是通过EglHelper来实现的。

EglHelper——创建EGL环境的帮助类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
private static class EglHelper {
  
  /**
   * Initialize EGL for a given configuration spec
   */
  public void start() {
    ......
    mEgl = (EGL10) EGLContext.getEGL();
    mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
    ......
    mEgl.eglInitialize(mEglDisplay, version);
    ......
    mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
    mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
  }
  
  /**
   * Create an egl surface for the current SurfaceHolder surface. If a surfce
   * already exists, destroy it before creating the new surface.
   */
  public boolean createSurface() {
    ......
    /*
     * The window size has changed, so we need to create a new surface.
     */
    destroySurfaceImp();
    ......
    /*
     * Create an EGL surface we can render into.
     */
    mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl, mEglDisplay, 
              mEglConfig, view.getHolder());
    ......
    /*
     * Before we can issue GL commands, we need to make sure the context
     * is current and bound to a surface.
     */
    mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
    ......
  }
  
  /**
   * Create a GL object for the current EGL context
   */
  GL createGL() {
    GL gl = mEglContext.getEGL();
    GLSurfaceView view = mGLSurfaceViewWeakRef.get();
    ......
    gl = view.mGLWrapper.wrap(gl);
    ......
    gl = GLDebugHelper.wrap(gl, configFlags, log);
    
    return gl;
  }
  
  ......
}

所以整体看来，就是GLThread在其同步代码块中通过mEglHelper.start()对EGL环境进行初始化，而后在同步块外部先调用mEglHelper.createSurface()为当前的Surface创建一个EGL的surface，再通过mEglHelper.createGL()创建一个GL对象，最后就将GL对象传递给renderer的三个回调方法onSurfaceCreated()、onSurfaceChanged()、onDrawFrame()。所以我们在最外面只需要在这三个回调方法中实现我们真正要绘制的东西即可。

再说GLThread

我们再来看看GLThread内部其他的一些方法，在最开始的时候我们说到给holder传入一个回调接口，而这个回调接口的四个方法的实现最终都指向了GLThread的内部方法，那么我们先来看看这四个方法在GLThread内部的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// GLThread的内部方法
public void surfaceCreated() {
  synchronized(sGLThreadManager) {
    mHasSurface = true;
    mFinishedCreatingEglSurface = false;
    sGLThreadManager.notifyAll();
    while(mWaitingForSurface && !mFinishedCreatingEglSurface && !mExited) {
      try {
        sGLThreadManager.wait();
      } catch (InterruptedException e) {
        Thread.currentThread().interrput();
      }
    }
  }
}
public void surfaceDestroyed() {
  synchronized(sGLThreadManager) {
    mHasSurface = true;
    sGLThreadManager.notifyAll();
    while(!mWaitingForSurface && !mExited) {
      try {
        sGLThreadManager.wait();
      } catch (InterruptedException e) {
        Thread.currentThread().interrput();
      }
    }
  }
}
public void onWindowResize(int w, int h) {
  synchronized(sGLThreadManager) {
    mWidth = w;
    mHeight = h;
    mSizeChanged = true;
    mRequestRender = true;
    mRenderComplete = false;
    
    if(Thread.currentThread() == this) {
      return;
    }
    
    sGLThreadManager.notifyAll();
    
    while(!mExited && !mPaused && !mRenderComplete && ableToDraw) {
      try {
        sGLThreadManager.wait();
      } catch (InterruptedException e) {
        Thread.currentThread().interrput();
      }
    }
  }
}
public void requestRenderAndWait() {
  synchronized(sGLThreadManager) {
    if(Thread.currentThread() == this) {
      return;
    }
    
    mWantRenderNotification = true;
    mRequestRender = true;
    mRenderComplete = false;
    
    sGLThreadManager.notifyAll();
    
    while(!mExited && !mPaused && !RenderComplete && ableToDraw()) {
      try {
        sGLThreadManager.wait();
      } catch (InterruptedException e) {
        Thread.currentThread().interrput();
      }
    }
  }
}

这些供外部调用的方法其最终都只是改变GLThread的一些内部标志，然后通过sGLThreadManager.notifyAll唤醒渲染线程，GLThread内部即通过判断这些标志位去执行对应的参数设置操作，这些参数设置操作都在synchronized(sGLTHreadManager)同步的循环体中进行，当最后已经准备好绘制工作，则跳出内循环体，在外循环体中调用renderer的回调方法onDrawFrame去真正实现绘制，核心代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
while(true) {
  synchronized(sGLThreadManager) {
    while(true) {
      ......
      mEglHelper.start();
      ......
      // 如果已经准备好绘制环境
      if(readyToDraw()) {
        // 再一次检查EglContext和EglSurface的状态，满足则跳出同步代码块的循环体
        // If we don't have an EGL context, try to acquire one
        if(!mHaveEglContext) {
          ......
          if(sGLThreadManager.tryAcquireEglContextLocked(this)) {
            mEglHelper.start();
          }
        }
        if(mHaveEglSurface) {
          ......
          break; // 跳出同步代码块的循环体
        }
      }
      ......
      sGLThreadManager.wait();
    }
  }
  ......
  // 调用Renderer进行绘制
  mEglHelper.createSurface();
  gl = (GL10) mEglHelper.createGL();
  mRenderer.onSurfaceCreated(gl, mEglHelper.getEglConfig());
  mRenderer.onSurfaceChanged(gl, w, h);
  mRenderer.onDrawFrame(gl);
}

最后终于回到了我们的渲染器Renderer，然后，我们只需要在外部实现Renderer的三个回调方法便可使用OpenGL ES来绘图了。当然，在我们弄懂了GLSurfaceView的原理后自己动手封装一个也是没有问题的。不过这里其实没有说得很明白的还有EGL这部分，后面有时间将补上。