title: Openg GL 2.0 Android error 0x501 (GL_INVALID_VALUE)
body: <p>I am trying to build a little Open GL2.0 demo application on android but i am getting the following errors</p>
  
  <p>in log cat</p>
  
  <pre><code>07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context     (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context         (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context     (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  07-02 20:50:40.110: E/libEGL(1252): call to OpenGL ES API with no current context (logged once per thread)
  </code></pre>
  
  <p>in the Console</p>
  
  <pre><code>[2012-07-02 20:50:44 - Emulator]     development/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp:glGetAttribLoc    ation:826 error 0x501
  [2012-07-02 20:50:44 - Emulator]     development/tools/emulator/opengl/host/libs/Translator/GLES_V2/GLESv2Imp.cpp:glGetUniformLocation:1383 error 0x501
  </code></pre>
  
  <p>my code </p>
  
  <p>View</p>
  
  <pre><code>package limitliss.graphics.play;
  
  
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.nio.FloatBuffer;
  
  import javax.microedition.khronos.egl.EGLConfig;
  import javax.microedition.khronos.opengles.GL10;
  
  import android.content.Context;
  import android.opengl.GLES20;
  import android.opengl.GLSurfaceView;
  import android.opengl.GLSurfaceView.Renderer;
  import android.opengl.GLU;
  
  public class OGLView extends GLSurfaceView implements Renderer {
  
  private int mColorType = 0;
  
  private float rotx = 0.0f;
  private float roty = 0.0f;    
  Triangle tri = new Triangle();
  
  public OGLView(Context context) {
      super(context);
      setEGLContextClientVersion(2);
  
      this.setRenderer(this); 
      setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
      // TODO Auto-generated constructor stub
  }
  
  
  
  public static int loadShader(int type, String shaderCode){
  
      // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
      // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
      int shader = GLES20.glCreateShader(type);
  
      // add the source code to the shader and compile it
      GLES20.glShaderSource(shader, shaderCode);
      GLES20.glCompileShader(shader);
  
      return shader;
  }
  
  
  
  
  
  public void onSurfaceCreated(GL10 unused, EGLConfig config) {
      // Set the background frame color
      GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
      tri.draw();
  }
  
  public void onDrawFrame(GL10 unused) {
      // Redraw background color
      GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
      tri.draw();
  }
  
  public void onSurfaceChanged(GL10 unused, int width, int height) {
      GLES20.glViewport(0, 0, width, height);
  }
  }
  
  
  Triangle
  
  package limitliss.graphics.play;
  
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.nio.FloatBuffer;
  
  import javax.microedition.khronos.opengles.GL10;
  
  import android.opengl.GLES20;
  
  
  
  public class Triangle {
  
  float color[] = { 0.63671875f, 0.76953125f, 0.22265625f, 1.0f };
  
  private FloatBuffer vertexBuffer;
  int mProgram;
  int mPositionHandle;
  private final String vertexShaderCode =
          "attribute vec4 vPosition;" +
          "void main() {" +
          "  gl_Position = vPosition;" +
          "}";
  
      private final String fragmentShaderCode =
          "precision mediump float;" +
          "uniform vec4 vColor;" +
          "void main() {" +
          "  gl_FragColor = vColor;" +
          "}";
  // number of coordinates per vertex in this array
  static final int COORDS_PER_VERTEX = 3;
  static float triangleCoords[] = { // in counterclockwise order:
       0.0f,  0.622008459f, 0.0f,   // top
      -0.5f, -0.311004243f, 0.0f,   // bottom left
       0.5f, -0.311004243f, 0.0f};   // bottom right
  
  public Triangle() {
      // initialize vertex byte buffer for shape coordinates
      ByteBuffer bb = ByteBuffer.allocateDirect(
              // (number of coordinate values * 4 bytes per float)
              triangleCoords.length * 4);
      // use the device hardware's native byte order
      bb.order(ByteOrder.nativeOrder());
  
      // create a floating point buffer from the ByteBuffer
      vertexBuffer = bb.asFloatBuffer();
      // add the coordinates to the FloatBuffer
      vertexBuffer.put(triangleCoords);
      // set the buffer to read the first coordinate
      vertexBuffer.position(0);
  
      int vertexShader =  OGLView.loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
      int fragmentShader =  OGLView.loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
  
      mProgram = GLES20.glCreateProgram();             // create empty OpenGL ES Program
      GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
      GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
      GLES20.glLinkProgram(mProgram);    
  }
  
  public void draw() {
  
      // Add program to OpenGL ES environment
      GLES20.glUseProgram(mProgram);
  
      // get handle to vertex shader's vPosition member
      mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
  
      // Enable a handle to the triangle vertices
      GLES20.glEnableVertexAttribArray(mPositionHandle);
  
      // Prepare the triangle coordinate data
      GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX,
                                   GLES20.GL_FLOAT, false,
                                   COORDS_PER_VERTEX, vertexBuffer);
  
      // get handle to fragment shader's vColor member
      int mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
  
      // Set color for drawing the triangle
      GLES20.glUniform4fv(mColorHandle, 1, color, 0);
  
      // Draw the triangle
      GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
  
      // Disable vertex array
      GLES20.glDisableVertexAttribArray(mPositionHandle);
  }
  
  public void render(GL10 gl){
  
      gl.glPushMatrix();
      gl.glColor4f(this.color[0],this.color[1],this.color[2],this.color[3]); 
      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
      gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, 3);
      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
      gl.glPopMatrix();
  }
  }
  </code></pre>