This is a few highly related questions but it boils down to:

TLDR - Can I get my app to use GLES2 on older phones that don't support GLES3 at runtime?

I have made an app (written in c++ using Visual Studio's Native Application project) which sorta grows Fractals (some 2d, some 3d) I originally made using GLES1 which simply wasn't good enough for what I needed so I set about getting it to work with GLES3 which I did. When it was 'done' I decided to try it one some other phones I had lying around and it crashed on start. I checked Logcat and foudn this:

Olof I like your idea of simply having 2 versions with the manifest., it's definitely the simplest way to do it (and probably the idea I am most keen on going with myself). I like the idea of loading the libraries myself on the fly but this is on the fringes of what I know how to do at the moment.

NoodleBowl, I will try your suggestion, right now I do:

#ifdef USING_GLES3
const EGLint attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE };
#else
const EGLint attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
#endif
context = eglCreateContext(display, config, NULL, attribs2);

Edit: Unfortunately it doesn't get as far as that without failing first (from not finding the lib). It doesn't even get as far as launching the main thread .

Ok I am well on my way but I have one problem.

So far I statically link against libGLES2.so. Then I try to dynamically link libGLES3.so. If that works then GLES3 is available:

// work out what version of GLES the device supports
DeviceCapabilities* device = DeviceCapabilities::GetInstance();
// GLES 2 is our minimum (set in manifest)
device->SetGLESVersion(2);
// Try to load the GLES3 lib
void* handle = dlopen("libGLESv3.so", RTLD_NOW);
// if it loaded then GLES3 is available
if (handle != NULL)
{
   Logger::Log(LoggerPriorityInfo, "GLES3 support detected");
   device->SetGLESVersion(3);
}
else
{
   Logger::Log(LoggerPriorityInfo, "GLES2 support only");
}

Then if GLES3 is available I load the function addresses:

if (glesVersion == 3)
{
   glGenVertexArrays = (glGenVertexArraysProc)eglGetProcAddress("glGenVertexArrays");
   glBindVertexArray = (glBindVertexArrayProc)eglGetProcAddress("glBindVertexArray");
   glDeleteVertexArrays = (glDeleteVertexArraysProc)eglGetProcAddress("glDeleteVertexArrays");
}

INDEX_TYPE* indices = (INDEX_TYPE*)malloc(numSegments * 2 * sizeof(INDEX_TYPE));

unsigned int numSegments = m_NumLineSegments * 2;
INDEX_TYPE* indices = (INDEX_TYPE*)malloc(numSegments * 2 * sizeof(INDEX_TYPE));
for (unsigned int i = 0; i < numSegments; i++)
{
   indices[i * 2 + 0] = i;
   indices[i * 2 + 1] = i + 1;
}

Thanks for the help so far, it definitely led me down the right path, I've been scratching my head for days thinking how to tackle this, I ask the one question and suddenly make leaps and bounds .

I tried the following which works in the test but not in practice :/ Visual Studio tells me there was a segmentation fault when I use it in my actual class.

void AssignValue(void* index, size_t indexSize, unsigned int value)
{
   if (indexSize == sizeof(unsigned short))
   {
      unsigned short* ind = (unsigned short*)index;
      *ind = value;
   }
   else if (indexSize == sizeof(unsigned int))
   {
      unsigned int* ind = (unsigned int*)index;
      *ind = value;
   }
}

unsigned int uInt[4];
unsigned short uShort[4];
for (unsigned int i = 0; i < 4; i++)
{
   uInt[i] = i;
   uShort[i] = i;
}
char* uIntMem = (char*)uInt;
char* uShortMem = (char*)uShort;
size_t uIntSize = sizeof(unsigned int);
size_t uShortSize = sizeof(unsigned short);
for (unsigned int i = 0; i < 4; i++)
{
   AssignValue(uIntMem + i*uIntSize, uIntSize, 3 - i);
   AssignValue(uShortMem + i*uShortSize, uShortSize, 3 - i);
}

Ok I have no idea why or how but it actually works. This can only be black magic. The same app runs on both my phones and uses VAO + unsigned int indices on the Nexus 5 and uses normal binding and unsigned short indices on the rubbish phone I have.

I am very impressed with myself and your help. I am worried I am doing something stupid with the way I am dealing with memory though...