【Android GLSurfaceView源码学习】第三天：GLSurfaceView的Surface、GLES与EGLSurface的关联

GLSurfaceView：Surface、GLES与EGLSurface的关联机制

GLSurfaceView是Android系统为简化OpenGL ES（GLES）渲染开发提供的核心组件，其核心价值在于封装了复杂的渲染线程管理、EGL上下文生命周期控制，以及Android Surface与GLES渲染管线的关联逻辑。

本文将从核心概念入手，逐层拆解GLSurfaceView如何将自身生成的Surface、GLES渲染接口、EGLSurface三者深度绑定，揭示其底层实现原理。

核心概念铺垫：理解三者的角色定位

在分析关联机制前，需先明确Surface、GLES、EGLSurface各自的核心作用，以及为什么需要"关联"：

1. Android Surface：渲染的"画布载体"

Surface是Android系统中用于承载图形绘制结果的底层抽象，本质是一块由SurfaceFlinger管理的显存缓冲区（BufferQueue）。

GLSurfaceView继承自SurfaceView，SurfaceView的核心特性是在WindowManager中创建一个独立于UI主线程渲染的Surface，该Surface拥有自己的绘图缓冲区，避免与UI绘制冲突。

• 归属：由SurfaceView通过SurfaceHolder创建，生命周期与GLSurfaceView的视图生命周期绑定；
• 核心作用：为GLES渲染提供"输出目标"，最终将渲染结果提交给SurfaceFlinger合成显示。

2. EGLSurface：GLES与系统Surface的"桥梁"

EGL（Embedded-System Graphics Library）是连接GLES和底层窗口系统的中间层，而EGLSurface是EGL对"渲染表面"的抽象，分为两类：

• Window Surface：绑定到Android Surface的EGL表面（本文核心讨论）；
• Pixmap/Pbuffer Surface：离线渲染的表面（GLSurfaceView中不常用）。
  EGLSurface的核心作用是将GLES的渲染指令映射到底层Surface的缓冲区，是GLES无法直接操作Android Surface的"适配层"。

3. GLES：图形渲染的"指令执行者"

GLES是基于OpenGL的嵌入式图形渲染接口，负责执行顶点着色、片元着色、纹理绘制等核心渲染指令。

但GLES本身不直接与Android窗口系统交互，必须通过EGL提供的上下文（EGLContext）和表面（EGLSurface）才能将渲染结果输出到具体的Surface上。

三者的核心关系可总结为：GLES执行渲染指令 → 经由EGLSurface映射 → 最终输出到Android Surface的缓冲区 → 由SurfaceFlinger合成显示。

GLSurfaceView的核心工作就是自动化完成这一关联流程。

核心架构：关联流程的"骨架"

GLSurfaceView的内部架构围绕"解耦UI线程与渲染线程"设计，核心组件包括：

组件	核心作用
SurfaceHolder	管理GLSurfaceView的Surface生命周期（创建、销毁、尺寸变化）
GLThread	独立的渲染线程，所有GLES/EGL操作均在此线程执行，避免阻塞UI线程
EglHelper	封装EGL的核心操作（EGLDisplay/EGLContext/EGLSurface的创建与管理）
Renderer接口	暴露给开发者的渲染回调（onSurfaceCreated/onSurfaceChanged/onDrawFrame）
EGLConfigChooser	选择合适的EGL配置（如颜色缓冲区位数、深度缓冲区位数）

整个关联流程的核心逻辑集中在GLThread和EglHelper中，接下来我们拆解具体的关联步骤。

关联流程全解析

GLSurfaceView中Surface、GLES、EGLSurface的关联是一个分阶段、多步骤的过程，可分为"初始化阶段"和"运行阶段"两大环节。

阶段1：初始化准备------Surface创建与EGL环境搭建

步骤1：GLSurfaceView初始化，创建Surface

当GLSurfaceView被添加到视图树时，其内部的SurfaceView会通过SurfaceHolder创建一个独立的Surface：

// GLSurfaceView初始化核心逻辑（简化）
private void init() {
    SurfaceHolder holder = getHolder();
    holder.addCallback(this); // 注册Surface生命周期回调
    // 设置Surface类型为GPU渲染（低版本需手动设置）
    holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}

此时创建的Surface是Android系统层面的缓冲区载体，尚未与EGL/GLES产生任何关联。

步骤2：设置Renderer，启动GLThread

开发者调用setRenderer(Renderer)时，GLSurfaceView会完成两个关键操作：

1. 初始化EGL相关配置（如EGLConfigChooser、EGLContext版本）；
2. 创建并启动GLThread渲染线程：

public void setRenderer(Renderer renderer) {
    mRenderer = renderer;
    mGLThread = new GLThread(mThisWeakRef); // 传入自身弱引用，避免内存泄漏
    mGLThread.start(); // 启动渲染线程
}

GLThread启动后会进入等待状态，直到Surface创建完成。

步骤3：Surface创建回调，触发EGL初始化

当SurfaceHolder监听到Surface创建完成（surfaceCreated回调），会通知GLThread：

// GLSurfaceView的SurfaceHolder.Callback回调
public void surfaceCreated(SurfaceHolder holder) {
    mGLThread.surfaceCreated(); // 通知GLThread Surface已就绪
}

GLThread接收到通知后，会唤醒等待的渲染循环，开始执行EGL环境初始化，核心逻辑在EglHelper.eglInitialize()中：

1. 获取EGLDisplay ：绑定到Android系统的默认显示设备（屏幕）：

   mEgl = (EGL10) EGLContext.getEGL();
   mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
   mEgl.eglInitialize(mEglDisplay, version); // 初始化EGLDisplay

2. 选择EGLConfig ：通过EGLConfigChooser筛选符合要求的EGL配置（如RGB888、深度缓冲区16位）：

   mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);

3. 创建EGLContext ：GLES的渲染上下文，所有GLES指令均在该上下文下执行：

   mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);

至此，EGL的基础环境已搭建完成，但尚未与Surface关联。

阶段2：核心关联------Surface与EGLSurface/GLES绑定

这是整个流程的核心步骤，GLThread在确认Surface就绪后，执行"Android Surface → EGLSurface → GLES"的绑定：

步骤1：创建EGLSurface，绑定Android Surface

通过EGL的eglCreateWindowSurface方法，将Android Surface（从SurfaceHolder获取）封装为EGLSurface：

// EglHelper中创建EGLSurface的核心逻辑
public EGLSurface createWindowSurface(Surface surface) {
    // 将Android Surface作为原生窗口传入，创建Window类型的EGLSurface
    return mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surface, null);
}

此时，EGLSurface与Android Surface完成绑定------EGLSurface成为GLES操作Surface的"代理"。

步骤2：绑定EGL上下文与EGLSurface到GLThread

通过eglMakeCurrent将EGLContext、EGLSurface绑定到当前GLThread，这是GLES能够"感知"EGLSurface的关键：

// EglHelper中绑定上下文的核心逻辑
public boolean makeCurrent() {
    // 将EGLContext、EGLSurface（读/写）绑定到当前线程
    return mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
}

调用该方法后，GLThread成为"GLES渲染线程"：所有在该线程中执行的GLES指令（如glClear、glDrawArrays）都会输出到绑定的EGLSurface（即对应的Android Surface）。

步骤3：GLES接口初始化，关联渲染回调

EGL上下文绑定完成后，GLThread会获取GLES接口实例（如GL10/GL20），并调用开发者实现的onSurfaceCreated回调：

// GLThread中触发Renderer回调的逻辑
private void renderFrame() {
    GL gl = mEglHelper.getGL(); // 获取绑定了EGL上下文的GLES实例
    mRenderer.onSurfaceCreated((GL10) gl, mEglHelper.getEGLConfig());
}

此时，开发者通过gl对象执行的所有GLES指令，都会经由EGLSurface映射到Android Surface的缓冲区，三者的关联彻底完成。

阶段3：运行阶段------关联状态的维护

GLSurfaceView在运行过程中会持续维护三者的关联状态，核心场景包括：

1. 尺寸变化：重新关联Surface尺寸

当Surface尺寸变化（如屏幕旋转），surfaceChanged回调会触发GLThread更新EGLSurface的尺寸，并调用onSurfaceChanged：

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
    mGLThread.onWindowResize(w, h); // 通知GLThread尺寸变化
}
// GLThread中处理尺寸变化
private void onWindowResize(int w, int h) {
    mWidth = w;
    mHeight = h;
    mRenderer.onSurfaceChanged((GL10) mGL, w, h); // 开发者调整视口/投影矩阵
}

2. 渲染循环：持续输出GLES结果

GLThread的核心循环会不断执行"GLES渲染 → EGL缓冲区交换"：

// GLThread的渲染循环核心逻辑
while (!mExit) {
    // 1. 执行开发者的onDrawFrame回调（GLES渲染指令）
    mRenderer.onDrawFrame((GL10) mGL);
    // 2. 交换EGLSurface缓冲区，将GLES渲染结果输出到Android Surface
    mEglHelper.swapBuffers();
}

eglSwapBuffers是关键：它将EGLSurface的后台渲染缓冲区（GLES绘制的内容）切换到前台，由SurfaceFlinger合成显示到屏幕。

3. Surface销毁：解除关联，释放资源

当GLSurfaceView被销毁（如Activity退出），surfaceDestroyed回调会触发GLThread解除关联：

public void surfaceDestroyed(SurfaceHolder holder) {
    mGLThread.surfaceDestroyed();
}
// GLThread中释放资源
private void surfaceDestroyed() {
    mEglHelper.destroySurface(); // 销毁EGLSurface
    mEglHelper.finish(); // 释放EGLContext/EGLDisplay
}

解除关联后，GLES指令不再输出到Surface，避免内存泄漏或渲染异常。

关键细节与异常处理

GLSurfaceView为了保证关联的稳定性，还处理了以下核心场景：

1. EGL上下文丢失（Context Lost）

当系统内存不足时，EGLContext可能被销毁（即"上下文丢失"），GLSurfaceView会：

1. 检测到eglSwapBuffers返回EGL_CONTEXT_LOST；
2. 销毁旧的EGLSurface/EGLContext；
3. 重新创建EGL环境，再次绑定Surface；
4. 调用onSurfaceCreated，让开发者重新初始化GLES资源（如纹理、着色器）。

2. 暂停/恢复（onPause/onResume）

• 暂停时：默认销毁EGLSurface/EGLContext（可通过setPreserveEGLContextOnPause保留上下文），解除Surface关联；
• 恢复时：重新创建EGLSurface，绑定Surface，恢复GLES渲染。

3. 弱引用避免内存泄漏

GLThread持有GLSurfaceView的弱引用（WeakReference<GLSurfaceView>），而非强引用：

public GLThread(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
    mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
}

这避免了GLThread长期存活导致GLSurfaceView无法被GC回收的问题。

总结与最佳实践

核心总结

GLSurfaceView中Surface、GLES、EGLSurface的关联本质是"三层抽象的逐层绑定"：

1. Android Surface提供物理缓冲区；
2. EGLSurface封装Surface为GLES可识别的渲染表面；
3. EGLContext将GLES指令绑定到EGLSurface；
4. GLThread保证所有操作在独立线程执行，避免UI阻塞。

最佳实践

1. 避免在UI线程执行GLES操作 ：所有GLES指令必须在Renderer的回调中执行（GLThread线程）；
2. 处理EGL上下文丢失 ：在onSurfaceCreated中重新初始化纹理、VBO等GLES资源；
3. 合理选择渲染模式 ：静态画面使用RENDERMODE_WHEN_DIRTY（按需渲染），减少性能消耗；
4. 及时释放资源 ：在Activity的onDestroy中调用GLSurfaceView.onPause()，避免EGL资源泄漏。