Create samples showing how to call OpenGL from JNI libraries.

    for (;;) {

    for (;;) {

        renderFrame();

        renderFrame();

        eglSwapBuffers(dpy, surface);

        eglSwapBuffers(dpy, surface);

        checkEglError("eglSwapBuffers");

    }

    }

    return 0;

    return 0;

#########################################################################

# OpenGL ES JNI sample

# This makefile builds both an activity and a shared library.

#########################################################################

ifneq ($(TARGET_SIMULATOR),true) # not 64 bit clean

TOP_LOCAL_PATH:= $(call my-dir)

# Build activity

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := user

LOCAL_SRC_FILES := $(call all-subdir-java-files)

LOCAL_PACKAGE_NAME := GL2JNI

LOCAL_JNI_SHARED_LIBRARIES := libgl2jni

include $(BUILD_PACKAGE)

#########################################################################

# Build JNI Shared Library

#########################################################################

LOCAL_PATH:= $(LOCAL_PATH)/jni

include $(CLEAR_VARS)

# Optional tag would mean it doesn't get installed by default

LOCAL_MODULE_TAGS := optional

LOCAL_CFLAGS := -Werror

LOCAL_SRC_FILES:= \

  gl_code.cpp

LOCAL_SHARED_LIBRARIES := \

	libutils \

	libEGL \

	libGLESv2

LOCAL_MODULE := libgl2jni

LOCAL_ARM_MODE := arm

LOCAL_PRELINK_MODULE := false

include $(BUILD_SHARED_LIBRARY)

endif # TARGET_SIMULATOR

<?xml version="1.0" encoding="utf-8"?>

<!--

/*

**

** Copyright 2009, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License"); 

** you may not use this file except in compliance with the License. 

** You may obtain a copy of the License at 

**

**     http://www.apache.org/licenses/LICENSE-2.0 

**

** Unless required by applicable law or agreed to in writing, software 

** distributed under the License is distributed on an "AS IS" BASIS, 

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

** See the License for the specific language governing permissions and 

** limitations under the License.

*/

-->

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.android.gl2jni">

    <application

            android:label="@string/gl2jni_activity">

        <activity android:name="GL2JNIActivity"

                android:theme="@android:style/Theme.NoTitleBar.Fullscreen"

            	android:launchMode="singleTask"

            	android:configChanges="orientation|keyboardHidden">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

    </application>

</manifest>

// OpenGL ES 2.0 code

#include <nativehelper/jni.h>

#define LOG_TAG "GL2JNI gl_code.cpp"

#include <utils/Log.h>

#include <EGL/egl.h>

#include <GLES2/gl2.h>

#include <GLES2/gl2ext.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

static void printGLString(const char *name, GLenum s) {

    const char *v = (const char *) glGetString(s);

    LOGI("GL %s = %s\n", name, v);

}

static void checkGlError(const char* op) {

    for (GLint error = glGetError(); error; error

            = glGetError()) {

        LOGI("after %s() glError (0x%x)\n", op, error);

    }

}

static const char gVertexShader[] = "attribute vec4 vPosition;\n"

    "void main() {\n"

    "  gl_Position = vPosition;\n"

    "}\n";

static const char gFragmentShader[] = "precision mediump float;\n"

    "void main() {\n"

    "  gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"

    "}\n";

GLuint loadShader(GLenum shaderType, const char* pSource) {

    GLuint shader = glCreateShader(shaderType);

    if (shader) {

        glShaderSource(shader, 1, &pSource, NULL);

        glCompileShader(shader);

        GLint compiled = 0;

        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);

        if (!compiled) {

            GLint infoLen = 0;

            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);

            if (infoLen) {

                char* buf = (char*) malloc(infoLen);

                if (buf) {

                    glGetShaderInfoLog(shader, infoLen, NULL, buf);

                    LOGE("Could not compile shader %d:\n%s\n",

                            shaderType, buf);

                    free(buf);

                }

                glDeleteShader(shader);

                shader = 0;

            }

        }

    }

    return shader;

}

GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) {

    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);

    if (!vertexShader) {

        return 0;

    }

    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);

    if (!pixelShader) {

        return 0;

    }

    GLuint program = glCreateProgram();

    if (program) {

        glAttachShader(program, vertexShader);

        checkGlError("glAttachShader");

        glAttachShader(program, pixelShader);

        checkGlError("glAttachShader");

        glLinkProgram(program);

        GLint linkStatus = GL_FALSE;

        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);

        if (linkStatus != GL_TRUE) {

            GLint bufLength = 0;

            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);

            if (bufLength) {

                char* buf = (char*) malloc(bufLength);

                if (buf) {

                    glGetProgramInfoLog(program, bufLength, NULL, buf);

                    LOGE("Could not link program:\n%s\n", buf);

                    free(buf);

                }

            }

            glDeleteProgram(program);

            program = 0;

        }

    }

    return program;

}

GLuint gProgram;

GLuint gvPositionHandle;

bool setupGraphics(int w, int h) {

    printGLString("Version", GL_VERSION);

    printGLString("Vendor", GL_VENDOR);

    printGLString("Renderer", GL_RENDERER);

    printGLString("Extensions", GL_EXTENSIONS);

    LOGI("setupGraphics(%d, %d)", w, h);

    gProgram = createProgram(gVertexShader, gFragmentShader);

    if (!gProgram) {

        LOGE("Could not create program.");

        return false;

    }

    gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");

    checkGlError("glGetAttribLocation");

    LOGI("glGetAttribLocation(\"vPosition\") = %d\n",

            gvPositionHandle);

    glViewport(0, 0, w, h);

    checkGlError("glViewport");

    return true;

}

const GLfloat gTriangleVertices[] = { 0.0f, 0.5f, -0.5f, -0.5f,

        0.5f, -0.5f };

void renderFrame() {

    static float grey;

    grey += 0.01f;

    if (grey > 1.0f) {

        grey = 0.0f;

    }

    glClearColor(grey, grey, grey, 1.0f);

    checkGlError("glClearColor");

    glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    checkGlError("glClear");

    glUseProgram(gProgram);

    checkGlError("glUseProgram");

    glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, gTriangleVertices);

    checkGlError("glVertexAttribPointer");

    glEnableVertexAttribArray(gvPositionHandle);

    checkGlError("glEnableVertexAttribArray");

    glDrawArrays(GL_TRIANGLES, 0, 3);

    checkGlError("glDrawArrays");

}

extern "C" {

    JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_init(JNIEnv * env, jobject obj,  jint width, jint height);

    JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_step(JNIEnv * env, jobject obj);

};

JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_init(JNIEnv * env, jobject obj,  jint width, jint height)

{

    setupGraphics(width, height);

}

JNIEXPORT void JNICALL Java_com_android_gl2jni_GL2JNILib_step(JNIEnv * env, jobject obj)

{

    renderFrame();

}

<?xml version="1.0" encoding="utf-8"?>

<!--

/*

**

** Copyright 2006, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License"); 

** you may not use this file except in compliance with the License. 

** You may obtain a copy of the License at 

**

**     http://www.apache.org/licenses/LICENSE-2.0 

**

** Unless required by applicable law or agreed to in writing, software 

** distributed under the License is distributed on an "AS IS" BASIS, 

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

** See the License for the specific language governing permissions and 

** limitations under the License.

*/

-->

<!-- This file contains resource definitions for displayed strings, allowing

     them to be changed based on the locale and options. -->

<resources>

    <!-- Simple strings. -->

    <string name="gl2jni_activity">GL2JNI</string>

</resources>