1/*
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#include <android_runtime/AndroidRuntime.h>
19#include <android_runtime/android_view_Surface.h>
20#include <utils/misc.h>
21
22#include <EGL/egl.h>
23#include <GLES/gl.h>
24
25#include <surfaceflinger/Surface.h>
26#include <SkBitmap.h>
27#include <SkPixelRef.h>
28
29namespace android {
30
31static jclass gDisplay_class;
32static jclass gContext_class;
33static jclass gSurface_class;
34static jclass gConfig_class;
35
36static jmethodID gConfig_ctorID;
37
38static jfieldID gDisplay_EGLDisplayFieldID;
39static jfieldID gContext_EGLContextFieldID;
40static jfieldID gSurface_EGLSurfaceFieldID;
41static jfieldID gSurface_NativePixelRefFieldID;
42static jfieldID gConfig_EGLConfigFieldID;
43static jfieldID gSurface_SurfaceFieldID;
44static jfieldID gBitmap_NativeBitmapFieldID;
45
46static __attribute__((noinline))
47void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
48{
49    jclass npeClazz = env->FindClass(exc);
50    env->ThrowNew(npeClazz, msg);
51}
52
53static __attribute__((noinline))
54bool hasException(JNIEnv *env) {
55    if (env->ExceptionCheck() != 0) {
56        env->ExceptionDescribe();
57        return true;
58    }
59    return false;
60}
61
62static __attribute__((noinline))
63jclass make_globalref(JNIEnv* env, const char classname[]) {
64    jclass c = env->FindClass(classname);
65    return (jclass)env->NewGlobalRef(c);
66}
67
68static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) {
69    if (!o) return EGL_NO_DISPLAY;
70    return (EGLDisplay)env->GetIntField(o, gDisplay_EGLDisplayFieldID);
71}
72static inline EGLSurface getSurface(JNIEnv* env, jobject o) {
73    if (!o) return EGL_NO_SURFACE;
74    return (EGLSurface)env->GetIntField(o, gSurface_EGLSurfaceFieldID);
75}
76static inline EGLContext getContext(JNIEnv* env, jobject o) {
77    if (!o) return EGL_NO_CONTEXT;
78    return (EGLContext)env->GetIntField(o, gContext_EGLContextFieldID);
79}
80static inline EGLConfig getConfig(JNIEnv* env, jobject o) {
81    if (!o) return 0;
82    return (EGLConfig)env->GetIntField(o, gConfig_EGLConfigFieldID);
83}
84static void nativeClassInit(JNIEnv *_env, jclass eglImplClass)
85{
86    gDisplay_class = make_globalref(_env, "com/google/android/gles_jni/EGLDisplayImpl");
87    gContext_class = make_globalref(_env, "com/google/android/gles_jni/EGLContextImpl");
88    gSurface_class = make_globalref(_env, "com/google/android/gles_jni/EGLSurfaceImpl");
89    gConfig_class  = make_globalref(_env, "com/google/android/gles_jni/EGLConfigImpl");
90
91    gConfig_ctorID  = _env->GetMethodID(gConfig_class,  "<init>", "(I)V");
92
93    gDisplay_EGLDisplayFieldID = _env->GetFieldID(gDisplay_class, "mEGLDisplay", "I");
94    gContext_EGLContextFieldID = _env->GetFieldID(gContext_class, "mEGLContext", "I");
95    gSurface_EGLSurfaceFieldID = _env->GetFieldID(gSurface_class, "mEGLSurface", "I");
96    gSurface_NativePixelRefFieldID = _env->GetFieldID(gSurface_class, "mNativePixelRef", "I");
97    gConfig_EGLConfigFieldID   = _env->GetFieldID(gConfig_class,  "mEGLConfig",  "I");
98
99    jclass bitmap_class = _env->FindClass("android/graphics/Bitmap");
100    gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I");
101}
102
103static const jint gNull_attrib_base[] = {EGL_NONE};
104
105static bool validAttribList(JNIEnv *_env, jintArray attrib_list) {
106    if (attrib_list == NULL) {
107        return true;
108    }
109    jsize len = _env->GetArrayLength(attrib_list);
110    if (len < 1) {
111        return false;
112    }
113    jint item = 0;
114    _env->GetIntArrayRegion(attrib_list, len-1, 1, &item);
115    return item == EGL_NONE;
116}
117
118static jint* beginNativeAttribList(JNIEnv *_env, jintArray attrib_list) {
119    if (attrib_list != NULL) {
120        return (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
121    } else {
122        return(jint*) gNull_attrib_base;
123    }
124}
125
126static void endNativeAttributeList(JNIEnv *_env, jintArray attrib_list, jint* attrib_base) {
127    if (attrib_list != NULL) {
128        _env->ReleasePrimitiveArrayCritical(attrib_list, attrib_base, JNI_ABORT);
129    }
130}
131
132static jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,
133        jintArray major_minor) {
134    if (display == NULL || (major_minor != NULL &&
135            _env->GetArrayLength(major_minor) < 2)) {
136        doThrow(_env, "java/lang/IllegalArgumentException");
137        return JNI_FALSE;
138    }
139
140    EGLDisplay dpy = getDisplay(_env, display);
141    jboolean success = eglInitialize(dpy, NULL, NULL);
142    if (success && major_minor) {
143        int len = _env->GetArrayLength(major_minor);
144        if (len) {
145            // we're exposing only EGL 1.0
146            jint* base = (jint *)_env->GetPrimitiveArrayCritical(major_minor, (jboolean *)0);
147            if (len >= 1) base[0] = 1;
148            if (len >= 2) base[1] = 0;
149            _env->ReleasePrimitiveArrayCritical(major_minor, base, JNI_ABORT);
150        }
151    }
152    return success;
153}
154
155static jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display,
156        jobject context, jint attribute, jintArray value) {
157    if (display == NULL || context == NULL || value == NULL
158        || _env->GetArrayLength(value) < 1) {
159        doThrow(_env, "java/lang/IllegalArgumentException");
160        return JNI_FALSE;
161    }
162    EGLDisplay dpy = getDisplay(_env, display);
163    EGLContext ctx = getContext(_env, context);
164    jboolean success = JNI_FALSE;
165    int len = _env->GetArrayLength(value);
166    if (len) {
167        jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);
168        success = eglQueryContext(dpy, ctx, attribute, base);
169        _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);
170    }
171    return success;
172}
173
174static jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display,
175        jobject surface, jint attribute, jintArray value) {
176    if (display == NULL || surface == NULL || value == NULL
177        || _env->GetArrayLength(value) < 1) {
178        doThrow(_env, "java/lang/IllegalArgumentException");
179        return JNI_FALSE;
180    }
181    EGLDisplay dpy = getDisplay(_env, display);
182    EGLContext sur = getSurface(_env, surface);
183
184    jboolean success = JNI_FALSE;
185    int len = _env->GetArrayLength(value);
186    if (len) {
187        jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);
188        success = eglQuerySurface(dpy, sur, attribute, base);
189        _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);
190    }
191    return success;
192}
193
194static jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,
195        jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) {
196    if (display == NULL
197        || !validAttribList(_env, attrib_list)
198        || (configs != NULL && _env->GetArrayLength(configs) < config_size)
199        || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {
200        doThrow(_env, "java/lang/IllegalArgumentException");
201        return JNI_FALSE;
202    }
203    EGLDisplay dpy = getDisplay(_env, display);
204    jboolean success = JNI_FALSE;
205
206    if (configs == NULL) {
207        config_size = 0;
208    }
209    EGLConfig nativeConfigs[config_size];
210
211    int num = 0;
212    jint* attrib_base = beginNativeAttribList(_env, attrib_list);
213    success = eglChooseConfig(dpy, attrib_base, configs ? nativeConfigs : 0, config_size, &num);
214    endNativeAttributeList(_env, attrib_list, attrib_base);
215
216    if (num_config != NULL) {
217        _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);
218    }
219
220    if (success && configs!=NULL) {
221        for (int i=0 ; i<num ; i++) {
222            jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);
223            _env->SetObjectArrayElement(configs, i, obj);
224        }
225    }
226    return success;
227}
228
229static jint jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,
230        jobject config, jobject share_context, jintArray attrib_list) {
231    if (display == NULL || config == NULL || share_context == NULL
232        || !validAttribList(_env, attrib_list)) {
233        doThrow(_env, "java/lang/IllegalArgumentException");
234        return JNI_FALSE;
235    }
236    EGLDisplay dpy = getDisplay(_env, display);
237    EGLConfig  cnf = getConfig(_env, config);
238    EGLContext shr = getContext(_env, share_context);
239    jint* base = beginNativeAttribList(_env, attrib_list);
240    EGLContext ctx = eglCreateContext(dpy, cnf, shr, base);
241    endNativeAttributeList(_env, attrib_list, base);
242    return (jint)ctx;
243}
244
245static jint jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display,
246        jobject config, jintArray attrib_list) {
247    if (display == NULL || config == NULL
248        || !validAttribList(_env, attrib_list)) {
249        doThrow(_env, "java/lang/IllegalArgumentException");
250        return JNI_FALSE;
251    }
252    EGLDisplay dpy = getDisplay(_env, display);
253    EGLConfig  cnf = getConfig(_env, config);
254    jint* base = beginNativeAttribList(_env, attrib_list);
255    EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base);
256    endNativeAttributeList(_env, attrib_list, base);
257    return (jint)sur;
258}
259
260static PixelFormat convertPixelFormat(SkBitmap::Config format)
261{
262    switch (format) {
263    case SkBitmap::kARGB_8888_Config:   return PIXEL_FORMAT_RGBA_8888;
264    case SkBitmap::kARGB_4444_Config:   return PIXEL_FORMAT_RGBA_4444;
265    case SkBitmap::kRGB_565_Config:     return PIXEL_FORMAT_RGB_565;
266    case SkBitmap::kA8_Config:          return PIXEL_FORMAT_A_8;
267    default:                            return PIXEL_FORMAT_NONE;
268    }
269}
270
271static void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur,
272        jobject display, jobject config, jobject native_pixmap,
273        jintArray attrib_list)
274{
275    if (display == NULL || config == NULL || native_pixmap == NULL
276        || !validAttribList(_env, attrib_list)) {
277        doThrow(_env, "java/lang/IllegalArgumentException");
278        return;
279    }
280    EGLDisplay dpy = getDisplay(_env, display);
281    EGLConfig  cnf = getConfig(_env, config);
282    jint* base = 0;
283
284    SkBitmap const * nativeBitmap =
285            (SkBitmap const *)_env->GetIntField(native_pixmap,
286                    gBitmap_NativeBitmapFieldID);
287    SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0;
288    if (ref == NULL) {
289        doThrow(_env, "java/lang/IllegalArgumentException", "Bitmap has no PixelRef");
290        return;
291    }
292
293    ref->safeRef();
294    ref->lockPixels();
295
296    egl_native_pixmap_t pixmap;
297    pixmap.version = sizeof(pixmap);
298    pixmap.width  = nativeBitmap->width();
299    pixmap.height = nativeBitmap->height();
300    pixmap.stride = nativeBitmap->rowBytes() / nativeBitmap->bytesPerPixel();
301    pixmap.format = convertPixelFormat(nativeBitmap->config());
302    pixmap.data   = (uint8_t*)ref->pixels();
303
304    base = beginNativeAttribList(_env, attrib_list);
305    EGLSurface sur = eglCreatePixmapSurface(dpy, cnf, &pixmap, base);
306    endNativeAttributeList(_env, attrib_list, base);
307
308    if (sur != EGL_NO_SURFACE) {
309        _env->SetIntField(out_sur, gSurface_EGLSurfaceFieldID, (int)sur);
310        _env->SetIntField(out_sur, gSurface_NativePixelRefFieldID, (int)ref);
311    } else {
312        ref->unlockPixels();
313        ref->safeUnref();
314    }
315}
316
317static jint jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,
318        jobject config, jobject native_window, jintArray attrib_list) {
319    if (display == NULL || config == NULL
320        || !validAttribList(_env, attrib_list)) {
321        doThrow(_env, "java/lang/IllegalArgumentException");
322        return JNI_FALSE;
323    }
324    EGLDisplay dpy = getDisplay(_env, display);
325    EGLContext cnf = getConfig(_env, config);
326    sp<ANativeWindow> window;
327    if (native_window == NULL) {
328not_valid_surface:
329        doThrow(_env, "java/lang/IllegalArgumentException",
330                "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");
331        return 0;
332    }
333
334    window = android_Surface_getNativeWindow(_env, native_window);
335    if (window == NULL)
336        goto not_valid_surface;
337
338    jint* base = beginNativeAttribList(_env, attrib_list);
339    EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base);
340    endNativeAttributeList(_env, attrib_list, base);
341    return (jint)sur;
342}
343
344static jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display,
345        jobject config, jint attribute, jintArray value) {
346    if (display == NULL || config == NULL
347        || (value == NULL || _env->GetArrayLength(value) < 1)) {
348        doThrow(_env, "java/lang/IllegalArgumentException");
349        return JNI_FALSE;
350    }
351    EGLDisplay dpy = getDisplay(_env, display);
352    EGLContext cnf = getConfig(_env, config);
353    jboolean success = JNI_FALSE;
354    jint localValue;
355    success = eglGetConfigAttrib(dpy, cnf, attribute, &localValue);
356    if (success) {
357        _env->SetIntArrayRegion(value, 0, 1, &localValue);
358    }
359    return success;
360}
361
362static jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display,
363        jobjectArray configs, jint config_size, jintArray num_config) {
364    if (display == NULL || (configs != NULL && _env->GetArrayLength(configs) < config_size)
365        || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {
366        doThrow(_env, "java/lang/IllegalArgumentException");
367        return JNI_FALSE;
368    }
369    EGLDisplay dpy = getDisplay(_env, display);
370    jboolean success = JNI_FALSE;
371    if (configs == NULL) {
372        config_size = 0;
373    }
374    EGLConfig nativeConfigs[config_size];
375    int num;
376    success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, &num);
377    if (num_config != NULL) {
378        _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);
379    }
380    if (success && configs) {
381        for (int i=0 ; i<num ; i++) {
382            jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);
383            _env->SetObjectArrayElement(configs, i, obj);
384        }
385    }
386    return success;
387}
388
389static jint jni_eglGetError(JNIEnv *_env, jobject _this) {
390    EGLint error = eglGetError();
391    return error;
392}
393
394static jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {
395    return (jint)eglGetCurrentContext();
396}
397
398static jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {
399    return (jint)eglGetCurrentDisplay();
400}
401
402static jint jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) {
403    if (!(readdraw == EGL_READ) || (readdraw == EGL_DRAW)) {
404        doThrow(_env, "java/lang/IllegalArgumentException");
405        return 0;
406    }
407    return (jint)eglGetCurrentSurface(readdraw);
408}
409
410static jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) {
411    if (display == NULL || context == NULL) {
412        doThrow(_env, "java/lang/IllegalArgumentException");
413        return JNI_FALSE;
414    }
415    EGLDisplay dpy = getDisplay(_env, display);
416    EGLContext ctx = getContext(_env, context);
417    return eglDestroyContext(dpy, ctx);
418}
419
420static jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
421    if (display == NULL || surface == NULL) {
422        doThrow(_env, "java/lang/IllegalArgumentException");
423        return JNI_FALSE;
424    }
425    EGLDisplay dpy = getDisplay(_env, display);
426    EGLSurface sur = getSurface(_env, surface);
427
428    if (sur) {
429        SkPixelRef* ref = (SkPixelRef*)(_env->GetIntField(surface,
430                gSurface_NativePixelRefFieldID));
431        if (ref) {
432            ref->unlockPixels();
433            ref->safeUnref();
434        }
435    }
436    return eglDestroySurface(dpy, sur);
437}
438
439static jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {
440    return (jint)eglGetDisplay(EGL_DEFAULT_DISPLAY);
441}
442
443static jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {
444    if (display == NULL || draw == NULL || read == NULL || context == NULL) {
445        doThrow(_env, "java/lang/IllegalArgumentException");
446        return JNI_FALSE;
447    }
448    EGLDisplay dpy = getDisplay(_env, display);
449    EGLSurface sdr = getSurface(_env, draw);
450    EGLSurface srd = getSurface(_env, read);
451    EGLContext ctx = getContext(_env, context);
452    return eglMakeCurrent(dpy, sdr, srd, ctx);
453}
454
455static jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) {
456    if (display == NULL) {
457        doThrow(_env, "java/lang/IllegalArgumentException");
458        return NULL;
459    }
460    EGLDisplay dpy = getDisplay(_env, display);
461    const char* chars = eglQueryString(dpy, name);
462    return _env->NewStringUTF(chars);
463}
464
465static jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
466    if (display == NULL || surface == NULL) {
467        doThrow(_env, "java/lang/IllegalArgumentException");
468        return JNI_FALSE;
469    }
470    EGLDisplay dpy = getDisplay(_env, display);
471    EGLSurface sur = getSurface(_env, surface);
472    return eglSwapBuffers(dpy, sur);
473}
474
475static jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) {
476    if (display == NULL) {
477        doThrow(_env, "java/lang/IllegalArgumentException");
478        return JNI_FALSE;
479    }
480    EGLDisplay dpy = getDisplay(_env, display);
481    return eglTerminate(dpy);
482}
483
484static jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display,
485        jobject surface, jobject native_pixmap) {
486    if (display == NULL || surface == NULL || native_pixmap == NULL) {
487        doThrow(_env, "java/lang/IllegalArgumentException");
488        return JNI_FALSE;
489    }
490    // TODO: Implement this
491    return JNI_FALSE;
492}
493
494static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {
495    return eglWaitGL();
496}
497
498static jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {
499    return eglWaitNative(engine);
500}
501
502
503static const char *classPathName = "com/google/android/gles_jni/EGLImpl";
504
505#define DISPLAY "Ljavax/microedition/khronos/egl/EGLDisplay;"
506#define CONTEXT "Ljavax/microedition/khronos/egl/EGLContext;"
507#define CONFIG  "Ljavax/microedition/khronos/egl/EGLConfig;"
508#define SURFACE "Ljavax/microedition/khronos/egl/EGLSurface;"
509#define OBJECT  "Ljava/lang/Object;"
510#define STRING  "Ljava/lang/String;"
511
512static JNINativeMethod methods[] = {
513{"_nativeClassInit","()V", (void*)nativeClassInit },
514{"eglWaitGL",       "()Z", (void*)jni_eglWaitGL },
515{"eglInitialize",   "(" DISPLAY "[I)Z", (void*)jni_eglInitialize },
516{"eglQueryContext", "(" DISPLAY CONTEXT "I[I)Z", (void*)jni_eglQueryContext },
517{"eglQuerySurface", "(" DISPLAY SURFACE "I[I)Z", (void*)jni_eglQuerySurface },
518{"eglChooseConfig", "(" DISPLAY "[I[" CONFIG "I[I)Z", (void*)jni_eglChooseConfig },
519{"_eglCreateContext","(" DISPLAY CONFIG CONTEXT "[I)I", (void*)jni_eglCreateContext },
520{"eglGetConfigs",   "(" DISPLAY "[" CONFIG "I[I)Z", (void*)jni_eglGetConfigs },
521{"eglTerminate",    "(" DISPLAY ")Z", (void*)jni_eglTerminate },
522{"eglCopyBuffers",  "(" DISPLAY SURFACE OBJECT ")Z", (void*)jni_eglCopyBuffers },
523{"eglWaitNative",   "(I" OBJECT ")Z", (void*)jni_eglWaitNative },
524{"eglGetError",     "()I", (void*)jni_eglGetError },
525{"eglGetConfigAttrib", "(" DISPLAY CONFIG "I[I)Z", (void*)jni_eglGetConfigAttrib },
526{"_eglGetDisplay",   "(" OBJECT ")I", (void*)jni_eglGetDisplay },
527{"_eglGetCurrentContext",  "()I", (void*)jni_eglGetCurrentContext },
528{"_eglGetCurrentDisplay",  "()I", (void*)jni_eglGetCurrentDisplay },
529{"_eglGetCurrentSurface",  "(I)I", (void*)jni_eglGetCurrentSurface },
530{"_eglCreatePbufferSurface","(" DISPLAY CONFIG "[I)I", (void*)jni_eglCreatePbufferSurface },
531{"_eglCreatePixmapSurface", "(" SURFACE DISPLAY CONFIG OBJECT "[I)V", (void*)jni_eglCreatePixmapSurface },
532{"_eglCreateWindowSurface", "(" DISPLAY CONFIG OBJECT "[I)I", (void*)jni_eglCreateWindowSurface },
533{"eglDestroyContext",      "(" DISPLAY CONTEXT ")Z", (void*)jni_eglDestroyContext },
534{"eglDestroySurface",      "(" DISPLAY SURFACE ")Z", (void*)jni_eglDestroySurface },
535{"eglMakeCurrent",         "(" DISPLAY SURFACE SURFACE CONTEXT")Z", (void*)jni_eglMakeCurrent },
536{"eglQueryString",         "(" DISPLAY "I)" STRING, (void*)jni_eglQueryString },
537{"eglSwapBuffers",         "(" DISPLAY SURFACE ")Z", (void*)jni_eglSwapBuffers },
538};
539
540} // namespace android
541
542int register_com_google_android_gles_jni_EGLImpl(JNIEnv *_env)
543{
544    int err;
545    err = android::AndroidRuntime::registerNativeMethods(_env,
546            android::classPathName, android::methods, NELEM(android::methods));
547    return err;
548}
549
550