android/source/src/java/org/mozilla/gecko/gfx/RenderControllerThread.java

   1 package org.mozilla.gecko.gfx;
   2
   3 import android.opengl.GLSurfaceView;
   4
   5 import java.util.concurrent.LinkedBlockingQueue;
   6
   7 /**
   8  * Thread which controls the rendering to OpenGL context. Render commands are queued and
   9  * processed and delegated by this thread.
  10  */
  11 public class RenderControllerThread extends Thread implements LayerView.Listener {
  12     private LinkedBlockingQueue<RenderCommand> queue = new LinkedBlockingQueue<RenderCommand>();
  13     private GLController controller;
  14     private boolean renderQueued = false;
  15     private int width;
  16     private int height;
  17
  18     public RenderControllerThread(GLController controller) {
  19         this.controller = controller;
  20     }
  21
  22     @Override
  23     public void run() {
  24         while (true) {
  25             RenderCommand command;
  26             try {
  27                 command = queue.take();
  28                 execute(command);
  29                 if (command == RenderCommand.SHUTDOWN) {
  30                     return;
  31                 }
  32             } catch (InterruptedException exception) {
  33                 throw new RuntimeException(exception);
  34             }
  35         }
  36     }
  37
  38     void execute(RenderCommand command) {
  39         switch (command) {
  40             case SHUTDOWN:
  41                 doShutdown();
  42                 break;
  43             case RENDER_FRAME:
  44                 doRenderFrame();
  45                 break;
  46             case SIZE_CHANGED:
  47                 doSizeChanged();
  48                 break;
  49             case SURFACE_CREATED:
  50                 doSurfaceCreated();
  51                 break;
  52             case SURFACE_DESTROYED:
  53                 doSurfaceDestroyed();
  54                 break;
  55         }
  56     }
  57
  58     public void shutdown() {
  59         queue.add(RenderCommand.SHUTDOWN);
  60     }
  61
  62     @Override
  63     public void compositorCreated() {
  64
  65     }
  66
  67     @Override
  68     public void renderRequested() {
  69         synchronized (this) {
  70             if (!renderQueued) {
  71                 queue.add(RenderCommand.RENDER_FRAME);
  72                 renderQueued = true;
  73             }
  74         }
  75     }
  76
  77     @Override
  78     public void compositionPauseRequested() {
  79         queue.add(RenderCommand.SURFACE_DESTROYED);
  80     }
  81
  82     @Override
  83     public void surfaceChanged(int width, int height) {
  84         this.width = width;
  85         this.height = height;
  86         queue.add(RenderCommand.SIZE_CHANGED);
  87     }
  88
  89     public void surfaceCreated() {
  90         queue.add(RenderCommand.SURFACE_CREATED);
  91     }
  92
  93     private GLSurfaceView.Renderer getRenderer() {
  94         return controller.getView().getRenderer();
  95     }
  96
  97     private void doShutdown() {
  98         controller.disposeGLContext();
  99         controller = null;
 100     }
 101
 102     private void doRenderFrame() {
 103         synchronized (this) {
 104             renderQueued = false;
 105         }
 106         if (controller.getEGLSurface() == null) {
 107             return;
 108         }
 109         GLSurfaceView.Renderer renderer = getRenderer();
 110         if (renderer != null) {
 111             renderer.onDrawFrame(controller.getGL());
 112         }
 113         controller.swapBuffers();
 114     }
 115
 116     private void doSizeChanged() {
 117         GLSurfaceView.Renderer renderer = getRenderer();
 118         if (renderer != null) {
 119             renderer.onSurfaceChanged(controller.getGL(), width, height);
 120         }
 121     }
 122
 123     private void doSurfaceCreated() {
 124         if (!controller.hasSurface()) {
 125             controller.initGLContext();
 126         }
 127     }
 128
 129     private void doSurfaceDestroyed() {
 130         controller.disposeGLContext();
 131     }
 132
 133     public enum RenderCommand {
 134         SHUTDOWN,
 135         RECREATE_SURFACE,
 136         RENDER_FRAME,
 137         SIZE_CHANGED,
 138         SURFACE_CREATED,
 139         SURFACE_DESTROYED,
 140     }
 141 }