Hi this is how my 3dcuboid looks, I have attached the complete code.
I want to label this cuboid using different names across sides, how is this possible using opengl on android?

public class MyGLRenderer implements Renderer {
    Context context;  
    Cuboid rect; 
     private float mCubeRotation;
    // private static float angleCube = 0;    // Rotational angle in degree for cube (NEW)
    // private static float speedCube = -1.5f;   // Rotational speed for cube (NEW)

     public MyGLRenderer(Context context) {
          rect = new Cuboid();
          this.context = context;

       }

    public void onDrawFrame(GL10 gl) {
        // TODO Auto-generated method stub


          gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
          gl.glLoadIdentity();                // Reset the model-view matrix
          gl.glTranslatef(0.2f, 0.0f, -8.0f); // Translate right and into the screen
          gl.glScalef(0.8f, 0.8f, 0.8f);      // Scale down (NEW)
          gl.glRotatef(mCubeRotation, 1.0f, 1.0f, 1.0f);

          // gl.glRotatef(angleCube, 1.0f, 1.0f, 1.0f); // rotate about the axis (1,1,1) (NEW)

          rect.draw(gl);
          mCubeRotation -= 0.15f; 


         //angleCube += speedCube;      
    }

    public void onSurfaceChanged(GL10 gl, int width, int height) {
        // TODO Auto-generated method stub
          if (height == 0) height = 1;   // To prevent divide by zero
          float aspect = (float)width / height;

          // Set the viewport (display area) to cover the entire window
          gl.glViewport(0, 0, width, height);

          // Setup perspective projection, with aspect ratio matches viewport
          gl.glMatrixMode(GL10.GL_PROJECTION); // Select projection matrix
          gl.glLoadIdentity();                 // Reset projection matrix
          // Use perspective projection
          GLU.gluPerspective(gl, 45, aspect, 0.1f, 100.f);

          gl.glMatrixMode(GL10.GL_MODELVIEW);  // Select model-view matrix
          gl.glLoadIdentity();                 // Reset
    }

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        // TODO Auto-generated method stub
          gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);  // Set color's clear-value to black
          gl.glClearDepthf(1.0f);            // Set depth's clear-value to farthest
          gl.glEnable(GL10.GL_DEPTH_TEST);   // Enables depth-buffer for hidden surface removal
          gl.glDepthFunc(GL10.GL_LEQUAL);    // The type of depth testing to do
          gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);  // nice perspective view
          gl.glShadeModel(GL10.GL_SMOOTH);   // Enable smooth shading of color
          gl.glDisable(GL10.GL_DITHER);      // Disable dithering for better performance

    }}



public class Cuboid{

            private FloatBuffer mVertexBuffer;
            private FloatBuffer mColorBuffer;
            private ByteBuffer  mIndexBuffer;

            private float vertices[] = {
                                      //width,height,depth 
                                        -2.5f, -1.0f, -1.0f,
                                        1.0f, -1.0f, -1.0f,
                                        1.0f,  1.0f, -1.0f,
                                        -2.5f, 1.0f, -1.0f,
                                        -2.5f, -1.0f,  1.0f,
                                        1.0f, -1.0f,  1.0f,
                                        1.0f,  1.0f,  1.0f,
                                        -2.5f,  1.0f,  1.0f
                                        };
            private float colors[] = {
                                      // R,G,B,A COLOR
                                       0.0f,  1.0f,  0.0f,  1.0f,
                                       0.0f,  1.0f,  0.0f,  1.0f,
                                       1.0f,  0.5f,  0.0f,  1.0f,
                                       1.0f,  0.5f,  0.0f,  1.0f,
                                       1.0f,  0.0f,  0.0f,  1.0f,
                                       1.0f,  0.0f,  0.0f,  1.0f,
                                       0.0f,  0.0f,  1.0f,  1.0f,
                                       1.0f,  0.0f,  1.0f,  1.0f
                                    };

            private byte indices[] = {
                                    // VERTEX 0,1,2,3,4,5,6,7 REPRESENTATION FOR FACES 
                                      0, 4, 5, 0, 5, 1,
                                      1, 5, 6, 1, 6, 2,
                                      2, 6, 7, 2, 7, 3,
                                      3, 7, 4, 3, 4, 0,
                                      4, 7, 6, 4, 6, 5,
                                      3, 0, 1, 3, 1, 2
                                      };

            public Cuboid() {
                    ByteBuffer byteBuf = ByteBuffer.allocateDirect(vertices.length * 4);
                    byteBuf.order(ByteOrder.nativeOrder());
                    mVertexBuffer = byteBuf.asFloatBuffer();
                    mVertexBuffer.put(vertices);
                    mVertexBuffer.position(0);

                    byteBuf = ByteBuffer.allocateDirect(colors.length * 4);
                    byteBuf.order(ByteOrder.nativeOrder());
                    mColorBuffer = byteBuf.asFloatBuffer();
                    mColorBuffer.put(colors);
                    mColorBuffer.position(0);

                    mIndexBuffer = ByteBuffer.allocateDirect(indices.length);
                    mIndexBuffer.put(indices);
                    mIndexBuffer.position(0);
            }

            public void draw(GL10 gl) {             
                    gl.glFrontFace(GL10.GL_CW);

                    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);
                    gl.glColorPointer(4, GL10.GL_FLOAT, 0, mColorBuffer);

                    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
                    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

                    gl.glDrawElements(GL10.GL_TRIANGLES, 36, GL10.GL_UNSIGNED_BYTE, 
                                    mIndexBuffer);

                    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
                    gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
            }
        }


public class Draw3drect extends Activity {

    private GLSurfaceView glView;   // Use GLSurfaceView

       // Call back when the activity is started, to initialize the view
       @Override
       protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          glView = new GLSurfaceView(this);           // Allocate a GLSurfaceView
          glView.setRenderer(new MyGLRenderer(this)); // Use a custom renderer
          this.setContentView(glView);                // This activity sets to GLSurfaceView
       }

       // Call back when the activity is going into the background
       @Override
       protected void onPause() {
          super.onPause();
          glView.onPause();
       }

       // Call back after onPause()
       @Override
       protected void onResume() {
          super.onResume();
          glView.onResume();
       }
    }