float[] tableVerticesWithTriangles = {
        // Triangle 1
        0, 0.5f,
        -0.5f,  0,
        0.5f,  0,
 
        // Triangle 2
        0, 0,
        0.5f, -0.5f,
        -0.5f,  -0.5f
};
 
vertexData = ByteBuffer
        .allocateDirect(tableVerticesWithTriangles.length * BYTES_PER_FLOAT)
        .order(ByteOrder.nativeOrder())
        .asFloatBuffer();
 
vertexData.put(tableVerticesWithTriangles);

@Override
public void onSurfaceChanged(GL10 glUnused, int width, int height) {
    glViewport(0, 0, width, height);
}

attribute vec4 a_Position;
void main()
{
    gl_Position = a_Position;
    gl_PointSize = 10.0;
}

precision mediump float;
uniform vec4 u_Color;
void main()
{
    gl_FragColor = u_Color;
}

private int compileShader(int type, String shaderCode) {
    final int shaderObjectId = glCreateShader(type);
    if (shaderObjectId == 0) {
        Log.w(TAG, "Could not create new shader.");
        return 0;
    }
 
    glShaderSource(shaderObjectId, shaderCode);
    glCompileShader(shaderObjectId);
    final int[] compileStatus = new int[1];
    glGetShaderiv(shaderObjectId, GL_COMPILE_STATUS, compileStatus, 0);
 
    Log.v(TAG, "Results of compiling source:" + "\n" + shaderCode + "\n:"  + glGetShaderInfoLog(shaderObjectId));
 
    if (compileStatus[0] == 0) {
        glDeleteShader(shaderObjectId);
        Log.w(TAG, "Compilation of shader failed.");
        return 0;
    }
    Log.w(TAG, "Compilation of shader was good.");
    return shaderObjectId;
}

public int linkProgram(int vertexShaderId, int fragmentShaderId) {
    final int programObjectId = glCreateProgram();
    if (programObjectId == 0) {
        Log.w(TAG, "Could not create new program");
        return 0;
    }
 
    glAttachShader(programObjectId, vertexShaderId);
    glAttachShader(programObjectId, fragmentShaderId);
    glLinkProgram(programObjectId);
 
    final int[] linkStatus = new int[1];
    glGetProgramiv(programObjectId, GL_LINK_STATUS, linkStatus, 0);
    Log.v(TAG, "Results of linking program:\n" + glGetProgramInfoLog(programObjectId));
    if (linkStatus[0] == 0) {
        glDeleteProgram(programObjectId);
        Log.w(TAG, "Linking of program failed.");
        return 0;
    }
 
    glValidateProgram(programObjectId);
    final int[] validateStatus = new int[1];
    glGetProgramiv(programObjectId, GL_VALIDATE_STATUS, validateStatus, 0);
    Log.v(TAG, "Results of validating program: " + validateStatus[0]
            + "\nLog:" + glGetProgramInfoLog(programObjectId));
    if (validateStatus[0] == 0) {
        Log.w(TAG, "Validation program failed.");
        return 0;
    }
 
    return programObjectId;
}

• Set the color to clear the screen
• Obtain the shaders code in string format
• Link and use the shader program
• As we are working with fixed triangles, assign shader variable values

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
String vertexShaderSource = Utils.ResourcesReader(context, R.raw.vertex);
String fragmentShaderSource = Utils.ResourcesReader(context, R.raw.fragment);
 
int vertexShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
int fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
program = linkProgram(vertexShader, fragmentShader);
glUseProgram(program);
 
uColorLocation = glGetUniformLocation(program, U_COLOR);
aPositionLocation = glGetAttribLocation(program, A_POSITION);
vertexData.position(0);
glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GL_FLOAT,
        false, 0, vertexData);
glEnableVertexAttribArray(aPositionLocation);

glClear(GL_COLOR_BUFFER_BIT);
 
glUniform4f(uColorLocation, 1.0f, 0f, 0f, 1.0f);
glDrawArrays(GL_TRIANGLES, 0, 3);
 
glUniform4f(uColorLocation, 0.0f, 0f, 1f, 1.0f);
glDrawArrays(GL_TRIANGLES, 3, 3);

• two-triangles.zip