OpenGL version 1.x has been supported from Android API level 4 with a shared OpenGL ES 1.x library, libGLESv1.so. The headers gl.h and glext.h contain all the necessary APIs for OpenGL functionality.

In the current industry, a developer prefers to use OpenGL ES 2.0 for games, because almost every device supports this OpenGL version, and it provides vertex and fragment shaders useful for games. OpenGL ES 2.0 can be used in Android native development projects by including the libGLESv2.so shared library in the project, as follows:

LOCAL_LDLIBS := -lGLESv2

The headers are gl2.h and gl2ext.h. OpenGL ES 2.0 is supported from Android API level 5.

From Android API level 21, OpenGL ES 3.0 is supported. The developer can include libGLESv3.so to use OpenGL 3.1, as follows:

LOCAL_LDLIBS := -lGLESv3

The headers are gl3.h and gl3ext.h.

From Android API level 21, OpenGL ES 3.1 is supported. The developer can include libGLESv3.so to use OpenGL 3.1, as follows:

LOCAL_LDLIBS := -lGLESv3

The headers are gl31.h and gl3ext.h.

OpenGL ES 3.0 and OpenGL ES 3.1 are not supported by many Android devices. If a developer intends to use them, then there should be an OpenGL version check before using the version. Also, proper version of OpenGL ES must be used to run the game on that particular device. The latest Android N has support for OpenGL ES 3.2.

This piece of Android Java code can be used to implement proper OpenGL ES support for an Android game:

private GLSurfaceView glSurfaceView;
void setOpenGLVersion()
{
  final boolean supportOpenGLEs3 = configurationInfo.reqGlEsVersion >= 0x30000;

  if (supportOpenGLEs3) 
  {
    glSurfaceView = new GLSurfaceView(this);
    glSurfaceView.setEGLContextClientVersion(3);
    glSurfaceView.setRenderer(new RendererWrapper());
    setContentView(glSurfaceView);
  }
  else
  {
  final boolean supportOpenGLEs2 = configurationInfo.reqGlEsVersion >= 0x20000;

  if (supportsOpenGLEs2) 
    {
      glSurfaceView = new GLSurfaceView(this);
      glSurfaceView.setEGLContextClientVersion(2);
      glSurfaceView.setRenderer(new RendererWrapper());
      setContentView(glSurfaceView);
    }
    else
    {
      glSurfaceView = new GLSurfaceView(this);
      glSurfaceView.setEGLContextClientVersion(1);
      glSurfaceView.setRenderer(new RendererWrapper());
      setContentView(glSurfaceView);
    }
  }
}

ATI texture compression is often called ATITC. This compression supports RGB with and without an alpha channel. This is the most common and widely used compression technique for Android.

Power VR texture compression uses 2-bit and 4-bit pixel compression with or without an alpha channel. This is used by many game developers across the globe.

DXTC is also called S3 texture compression, which is also used for OpenGL. This uses a 4-bit or 8-bit ARGB channel.

It is noticed that OpenGL version 3.x is faster than OpenGL version 2.x, which is way faster than OpenGL 1.x. So, it is always better to use the latest possible version in the game.

Texture compression support varies with OpenGL versions. Older versions support older texture compression factors. Also, Android version support is not universal for all OpenGL versions. Again, it is better to use the latest possible version for texture support.

This constraint keeps a developer's feet on the ground. The latest versions of OpenGL are not supported by all devices. So, in order to target a bigger range of devices, the user should change the OpenGL version to 2.0 as most devices support this version.

As the version of OpenGL increases, the feature list becomes an important factor while choosing the OpenGL version. The developer must know the support required for developing the application and accordingly, they must choose the version.

There is a huge coding style and API change among the versions of OpenGL. The developer should choose the version if it can actually be developed in the company with ease.