How to use

GLSurfaceView

in

android.opengl

@Override
public void onResume() {
 super.onResume();
 if (orientationSensor != null) {
  sensorManager.registerListener(
    phoneOrientationListener, orientationSensor, SensorManager.SENSOR_DELAY_FASTEST);
 }
}

@Override
public void onPause() {
 if (orientationSensor != null) {
  sensorManager.unregisterListener(phoneOrientationListener);
 }
 super.onPause();
}

/**
 * Sets the GLSurfaceView which will display the preview.
 *
 * @param view the GLSurfaceView
 */
public void setGLSurfaceView(final GLSurfaceView view) {
  surfaceType = SURFACE_TYPE_SURFACE_VIEW;
  glSurfaceView = view;
  glSurfaceView.setEGLContextClientVersion(2);
  glSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
  glSurfaceView.getHolder().setFormat(PixelFormat.RGBA_8888);
  glSurfaceView.setRenderer(renderer);
  glSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
  glSurfaceView.requestRender();
}

GLSurfaceView view = new GLSurfaceView(context);
logger.log(Level.INFO, "Android Build Version: {0}", Build.VERSION.SDK_INT);
if (androidInput == null) {
view.setEGLContextClientVersion(2);
view.setFocusableInTouchMode(true);
view.setFocusable(true);
if (curAlphaBits >= 8) {
  logger.log(Level.FINE, "Pixel Format: TRANSLUCENT");
  view.getHolder().setFormat(PixelFormat.TRANSLUCENT);
  view.setZOrderOnTop(true);
} else if (curAlphaBits >= 1) {
  logger.log(Level.FINE, "Pixel Format: TRANSPARENT");
  view.getHolder().setFormat(PixelFormat.TRANSPARENT);
} else {
  logger.log(Level.FINE, "Pixel Format: OPAQUE");
  view.getHolder().setFormat(PixelFormat.OPAQUE);
view.setEGLConfigChooser(configChooser);
view.setRenderer(this);
  view.setPreserveEGLContextOnPause(true);

public void initGL(){
  mGLView= (GLSurfaceView) findViewById(R.id.mGLView);
  mGLView.setEGLContextClientVersion(2);
  mGLView.setRenderer(render=new VaryRender(getResources()));
  mGLView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}

mEqua= (TextView) findViewById(R.id.mEqua);
mGLView= (GLSurfaceView) findViewById(R.id.mGLView);
mGLView.setEGLContextClientVersion(2);
mGLView.setEGLConfigChooser(8,8,8,8,16,8);
mGLView.setRenderer(this);
mGLView.getHolder().setFormat(PixelFormat.TRANSPARENT);
mGLView.setZOrderOnTop(true);
mGLView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);

public InvertedColorsVideoRenderer(Context context) {
  this.mContext = context;
  mView = new GLSurfaceView(context);
  mView.setEGLContextClientVersion(2);
  mRenderer = new MyRenderer();
  mView.setRenderer(mRenderer);
  mView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  // Create our surface view and set it as the content of our
  // Activity
  mGLSurfaceView = new GLSurfaceView(this);
  mGLSurfaceView.setRenderer(new Renderer());
  setContentView(mGLSurfaceView);
}

 public class ClearActivity extends Activity {
  ... snip ...

  @Override
  protected void onPause() {
    super.onPause();
    mGLView.onPause();
  }

  @Override
  protected void onResume() {
    super.onResume();
    mGLView.onResume();
  }

  private GLSurfaceView mGLView;
}

public GlPreviewRenderer(GLSurfaceView glView) {
  this.glView = glView;
  this.glView.setEGLConfigChooser(new GLES20ConfigChooser(false));
  this.glView.setEGLContextFactory(new GLES20ContextFactory());
  this.glView.setRenderer(this);
  this.glView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
  Matrix.setIdentityM(STMatrix, 0);
}

@Override
public void onFrameAvailable(SurfaceTexture surfaceTexture) {
  synchronized(this) {
    updateSurface = true;
  }
  mView.requestRender();
}

 public class MyGLActivity extends Activity {
  //...    
  private GLSurfaceView glView;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    glView = new GLSurfaceView(this);
    glView.setEGLConfigChooser(8 , 8, 8, 8, 16, 0);
    glView.setRenderer(new MyGlRenderer(this));
    this.setContentView(glView);
  }
  //...
}

private VideoRendererGui(GLSurfaceView surface) {
 this.surface = surface;
 // Create an OpenGL ES 2.0 context.
 surface.setPreserveEGLContextOnPause(true);
 surface.setEGLContextClientVersion(2);
 surface.setRenderer(this);
 surface.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
 yuvImageRenderers = new ArrayList<YuvImageRenderer>();
}

mGLView.setEGLConfigChooser(true);
mGLView.setRenderer(myRenderer); // set the surfaceView to use the renderer

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

    mGLSurfaceView = new GLSurfaceView(this);
    mGLSurfaceView.setEGLContextClientVersion(2);
    mGLSurfaceView.setRenderer(new GLRenderer());
    setContentView(mGLSurfaceView);
  }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  mGLSurfaceView = new GLSurfaceView(this);
  mGLSurfaceView.setGLWrapper(new GLSurfaceView.GLWrapper() {
    public GL wrap(GL gl) {
      return new MatrixTrackingGL(gl);
    }});
  mGLSurfaceView.setRenderer(new SpriteTextRenderer(this));
  setContentView(mGLSurfaceView);
}

@Override
public void setSurfaceRenderer(ISurfaceRenderer renderer) throws IllegalStateException {
  if (mRendererDelegate != null) throw new IllegalStateException("A renderer has already been set for this view.");
  initialize();
  final RendererDelegate delegate = new SurfaceView.RendererDelegate(renderer, this);
  super.setRenderer(delegate);
  mRendererDelegate = delegate; // Done to make sure we dont publish a reference before its safe.
  // Render mode cant be set until the GL thread exists
  setRenderMode(mRenderMode);
  onPause(); // We want to halt the surface view until we are ready
}

 GLSurfaceView glview = (GLSurfaceView)findViewById(R.id.surface);
glview.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
glview.getHolder().setFormat(PixelFormat.RGBA_8888);
glview.setZOrderMediaOverlay(true);
glview.setEGLContextClientVersion(2);

@Override
public void setRenderMode(int mode) {
  mRenderMode = mode;
  if (mRendererDelegate != null) {
    super.setRenderMode(mRenderMode);
  }
}

@Override
protected void configureGLSurfaceView() {
  //we override this method so we can create a special glsurfaceview that
  //can provide its onTouchListener. This way we can override the ontouchlistener
  //to provide different functionality for long press, without altering the original
  //tangram library (which is a very big pain)
  glSurfaceView = new MyGLSurfaceView(getContext());
  glSurfaceView.setEGLContextClientVersion(2);
  glSurfaceView.setPreserveEGLContextOnPause(true);
  glSurfaceView.setEGLConfigChooser(new ConfigChooser(8, 8, 8, 0, 16, 8));
  addView(glSurfaceView);
}