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 <nativehelper/JNIHelp.h> 19 #include <android_runtime/AndroidRuntime.h> 20 #include <android_runtime/android_view_Surface.h> 21 #include <android_runtime/android_graphics_SurfaceTexture.h> 22 #include <utils/misc.h> 23 24 25 #include <EGL/egl.h> 26 #include <GLES/gl.h> 27 #include <private/EGL/display.h> 28 29 #include <gui/Surface.h> 30 #include <gui/GLConsumer.h> 31 #include <gui/Surface.h> 32 33 #include <GraphicsJNI.h> 34 #include <SkBitmap.h> 35 #include <SkPixelRef.h> 36 37 #include <ui/ANativeObjectBase.h> 38 39 namespace android { 40 41 static jclass gConfig_class; 42 43 static jmethodID gConfig_ctorID; 44 45 static jfieldID gDisplay_EGLDisplayFieldID; 46 static jfieldID gContext_EGLContextFieldID; 47 static jfieldID gSurface_EGLSurfaceFieldID; 48 static jfieldID gConfig_EGLConfigFieldID; 49 50 static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) { 51 if (!o) return EGL_NO_DISPLAY; 52 return (EGLDisplay)env->GetLongField(o, gDisplay_EGLDisplayFieldID); 53 } 54 static inline EGLSurface getSurface(JNIEnv* env, jobject o) { 55 if (!o) return EGL_NO_SURFACE; 56 return (EGLSurface)env->GetLongField(o, gSurface_EGLSurfaceFieldID); 57 } 58 static inline EGLContext getContext(JNIEnv* env, jobject o) { 59 if (!o) return EGL_NO_CONTEXT; 60 return (EGLContext)env->GetLongField(o, gContext_EGLContextFieldID); 61 } 62 static inline EGLConfig getConfig(JNIEnv* env, jobject o) { 63 if (!o) return 0; 64 return (EGLConfig)env->GetLongField(o, gConfig_EGLConfigFieldID); 65 } 66 67 static inline jboolean EglBoolToJBool(EGLBoolean eglBool) { 68 return eglBool == EGL_TRUE ? JNI_TRUE : JNI_FALSE; 69 } 70 71 static void nativeClassInit(JNIEnv *_env, jclass eglImplClass) 72 { 73 jclass config_class = _env->FindClass("com/google/android/gles_jni/EGLConfigImpl"); 74 gConfig_class = (jclass) _env->NewGlobalRef(config_class); 75 gConfig_ctorID = _env->GetMethodID(gConfig_class, "<init>", "(J)V"); 76 gConfig_EGLConfigFieldID = _env->GetFieldID(gConfig_class, "mEGLConfig", "J"); 77 78 jclass display_class = _env->FindClass("com/google/android/gles_jni/EGLDisplayImpl"); 79 gDisplay_EGLDisplayFieldID = _env->GetFieldID(display_class, "mEGLDisplay", "J"); 80 81 jclass context_class = _env->FindClass("com/google/android/gles_jni/EGLContextImpl"); 82 gContext_EGLContextFieldID = _env->GetFieldID(context_class, "mEGLContext", "J"); 83 84 jclass surface_class = _env->FindClass("com/google/android/gles_jni/EGLSurfaceImpl"); 85 gSurface_EGLSurfaceFieldID = _env->GetFieldID(surface_class, "mEGLSurface", "J"); 86 } 87 88 static const jint gNull_attrib_base[] = {EGL_NONE}; 89 90 static bool validAttribList(JNIEnv *_env, jintArray attrib_list) { 91 if (attrib_list == NULL) { 92 return true; 93 } 94 jsize len = _env->GetArrayLength(attrib_list); 95 if (len < 1) { 96 return false; 97 } 98 jint item = 0; 99 _env->GetIntArrayRegion(attrib_list, len-1, 1, &item); 100 return item == EGL_NONE; 101 } 102 103 static jint* beginNativeAttribList(JNIEnv *_env, jintArray attrib_list) { 104 if (attrib_list != NULL) { 105 return _env->GetIntArrayElements(attrib_list, (jboolean *)0); 106 } else { 107 return(jint*) gNull_attrib_base; 108 } 109 } 110 111 static void endNativeAttributeList(JNIEnv *_env, jintArray attrib_list, jint* attrib_base) { 112 if (attrib_list != NULL) { 113 _env->ReleaseIntArrayElements(attrib_list, attrib_base, 0); 114 } 115 } 116 117 static jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display, 118 jintArray major_minor) { 119 if (display == NULL || (major_minor != NULL && 120 _env->GetArrayLength(major_minor) < 2)) { 121 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 122 return JNI_FALSE; 123 } 124 125 EGLDisplay dpy = getDisplay(_env, display); 126 EGLBoolean success = eglInitialize(dpy, NULL, NULL); 127 if (success && major_minor) { 128 int len = _env->GetArrayLength(major_minor); 129 if (len) { 130 // we're exposing only EGL 1.0 131 jint* base = (jint *)_env->GetPrimitiveArrayCritical(major_minor, (jboolean *)0); 132 if (len >= 1) base[0] = 1; 133 if (len >= 2) base[1] = 0; 134 _env->ReleasePrimitiveArrayCritical(major_minor, base, 0); 135 } 136 } 137 return EglBoolToJBool(success); 138 } 139 140 static jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display, 141 jobject context, jint attribute, jintArray value) { 142 if (display == NULL || context == NULL || value == NULL 143 || _env->GetArrayLength(value) < 1) { 144 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 145 return JNI_FALSE; 146 } 147 EGLDisplay dpy = getDisplay(_env, display); 148 EGLContext ctx = getContext(_env, context); 149 EGLBoolean success = EGL_FALSE; 150 int len = _env->GetArrayLength(value); 151 if (len) { 152 jint* base = _env->GetIntArrayElements(value, (jboolean *)0); 153 success = eglQueryContext(dpy, ctx, attribute, base); 154 _env->ReleaseIntArrayElements(value, base, 0); 155 } 156 return EglBoolToJBool(success); 157 } 158 159 static jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display, 160 jobject surface, jint attribute, jintArray value) { 161 if (display == NULL || surface == NULL || value == NULL 162 || _env->GetArrayLength(value) < 1) { 163 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 164 return JNI_FALSE; 165 } 166 EGLDisplay dpy = getDisplay(_env, display); 167 EGLContext sur = getSurface(_env, surface); 168 169 EGLBoolean success = EGL_FALSE; 170 int len = _env->GetArrayLength(value); 171 if (len) { 172 jint* base = _env->GetIntArrayElements(value, (jboolean *)0); 173 success = eglQuerySurface(dpy, sur, attribute, base); 174 _env->ReleaseIntArrayElements(value, base, 0); 175 } 176 return EglBoolToJBool(success); 177 } 178 179 static jint jni_getInitCount(JNIEnv *_env, jobject _clazz, jobject display) { 180 EGLDisplay dpy = getDisplay(_env, display); 181 return android::egl_get_init_count(dpy); 182 } 183 184 static jboolean jni_eglReleaseThread(JNIEnv *_env, jobject _this) { 185 return EglBoolToJBool(eglReleaseThread()); 186 } 187 188 static jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display, 189 jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) { 190 if (display == NULL 191 || !validAttribList(_env, attrib_list) 192 || (configs != NULL && _env->GetArrayLength(configs) < config_size) 193 || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) { 194 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 195 return JNI_FALSE; 196 } 197 EGLDisplay dpy = getDisplay(_env, display); 198 EGLBoolean success = EGL_FALSE; 199 200 if (configs == NULL) { 201 config_size = 0; 202 } 203 EGLConfig nativeConfigs[config_size]; 204 205 int num = 0; 206 jint* attrib_base = beginNativeAttribList(_env, attrib_list); 207 success = eglChooseConfig(dpy, attrib_base, configs ? nativeConfigs : 0, config_size, &num); 208 endNativeAttributeList(_env, attrib_list, attrib_base); 209 210 if (num_config != NULL) { 211 _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num); 212 } 213 214 if (success && configs!=NULL) { 215 for (int i=0 ; i<num ; i++) { 216 jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, reinterpret_cast<jlong>(nativeConfigs[i])); 217 _env->SetObjectArrayElement(configs, i, obj); 218 } 219 } 220 return EglBoolToJBool(success); 221 } 222 223 static jlong jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display, 224 jobject config, jobject share_context, jintArray attrib_list) { 225 if (display == NULL || config == NULL || share_context == NULL 226 || !validAttribList(_env, attrib_list)) { 227 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 228 return JNI_FALSE; 229 } 230 EGLDisplay dpy = getDisplay(_env, display); 231 EGLConfig cnf = getConfig(_env, config); 232 EGLContext shr = getContext(_env, share_context); 233 jint* base = beginNativeAttribList(_env, attrib_list); 234 EGLContext ctx = eglCreateContext(dpy, cnf, shr, base); 235 endNativeAttributeList(_env, attrib_list, base); 236 return reinterpret_cast<jlong>(ctx); 237 } 238 239 static jlong jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display, 240 jobject config, jintArray attrib_list) { 241 if (display == NULL || config == NULL 242 || !validAttribList(_env, attrib_list)) { 243 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 244 return JNI_FALSE; 245 } 246 EGLDisplay dpy = getDisplay(_env, display); 247 EGLConfig cnf = getConfig(_env, config); 248 jint* base = beginNativeAttribList(_env, attrib_list); 249 EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base); 250 endNativeAttributeList(_env, attrib_list, base); 251 return reinterpret_cast<jlong>(sur); 252 } 253 254 static void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur, 255 jobject display, jobject config, jobject native_pixmap, 256 jintArray attrib_list) 257 { 258 jniThrowException(_env, "java/lang/UnsupportedOperationException", "eglCreatePixmapSurface"); 259 } 260 261 static jlong jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display, 262 jobject config, jobject native_window, jintArray attrib_list) { 263 if (display == NULL || config == NULL 264 || !validAttribList(_env, attrib_list)) { 265 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 266 return JNI_FALSE; 267 } 268 EGLDisplay dpy = getDisplay(_env, display); 269 EGLContext cnf = getConfig(_env, config); 270 sp<ANativeWindow> window; 271 if (native_window == NULL) { 272 not_valid_surface: 273 jniThrowException(_env, "java/lang/IllegalArgumentException", 274 "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface"); 275 return 0; 276 } 277 278 window = android_view_Surface_getNativeWindow(_env, native_window); 279 if (window == NULL) 280 goto not_valid_surface; 281 282 jint* base = beginNativeAttribList(_env, attrib_list); 283 EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base); 284 endNativeAttributeList(_env, attrib_list, base); 285 return reinterpret_cast<jlong>(sur); 286 } 287 288 static jlong jni_eglCreateWindowSurfaceTexture(JNIEnv *_env, jobject _this, jobject display, 289 jobject config, jobject native_window, jintArray attrib_list) { 290 if (display == NULL || config == NULL 291 || !validAttribList(_env, attrib_list)) { 292 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 293 return 0; 294 } 295 EGLDisplay dpy = getDisplay(_env, display); 296 EGLContext cnf = getConfig(_env, config); 297 sp<ANativeWindow> window; 298 if (native_window == 0) { 299 not_valid_surface: 300 jniThrowException(_env, "java/lang/IllegalArgumentException", 301 "Make sure the SurfaceTexture is valid"); 302 return 0; 303 } 304 305 sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(_env, native_window)); 306 window = new Surface(producer, true); 307 if (window == NULL) 308 goto not_valid_surface; 309 310 jint* base = beginNativeAttribList(_env, attrib_list); 311 EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base); 312 endNativeAttributeList(_env, attrib_list, base); 313 return reinterpret_cast<jlong>(sur); 314 } 315 316 static jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display, 317 jobject config, jint attribute, jintArray value) { 318 if (display == NULL || config == NULL 319 || (value == NULL || _env->GetArrayLength(value) < 1)) { 320 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 321 return JNI_FALSE; 322 } 323 EGLDisplay dpy = getDisplay(_env, display); 324 EGLContext cnf = getConfig(_env, config); 325 EGLBoolean success = EGL_FALSE; 326 jint localValue; 327 success = eglGetConfigAttrib(dpy, cnf, attribute, &localValue); 328 if (success) { 329 _env->SetIntArrayRegion(value, 0, 1, &localValue); 330 } 331 return EglBoolToJBool(success); 332 } 333 334 static jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display, 335 jobjectArray configs, jint config_size, jintArray num_config) { 336 if (display == NULL || (configs != NULL && _env->GetArrayLength(configs) < config_size) 337 || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) { 338 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 339 return JNI_FALSE; 340 } 341 EGLDisplay dpy = getDisplay(_env, display); 342 EGLBoolean success = EGL_FALSE; 343 if (configs == NULL) { 344 config_size = 0; 345 } 346 EGLConfig nativeConfigs[config_size]; 347 int num; 348 success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, &num); 349 if (num_config != NULL) { 350 _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num); 351 } 352 if (success && configs) { 353 for (int i=0 ; i<num ; i++) { 354 jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, reinterpret_cast<jlong>(nativeConfigs[i])); 355 _env->SetObjectArrayElement(configs, i, obj); 356 } 357 } 358 return EglBoolToJBool(success); 359 } 360 361 static jint jni_eglGetError(JNIEnv *_env, jobject _this) { 362 EGLint error = eglGetError(); 363 return error; 364 } 365 366 static jlong jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) { 367 return reinterpret_cast<jlong>(eglGetCurrentContext()); 368 } 369 370 static jlong jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) { 371 return reinterpret_cast<jlong>(eglGetCurrentDisplay()); 372 } 373 374 static jlong jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) { 375 if ((readdraw != EGL_READ) && (readdraw != EGL_DRAW)) { 376 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 377 return 0; 378 } 379 return reinterpret_cast<jlong>(eglGetCurrentSurface(readdraw)); 380 } 381 382 static jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) { 383 if (display == NULL || context == NULL) { 384 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 385 return JNI_FALSE; 386 } 387 EGLDisplay dpy = getDisplay(_env, display); 388 EGLContext ctx = getContext(_env, context); 389 return EglBoolToJBool(eglDestroyContext(dpy, ctx)); 390 } 391 392 static jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) { 393 if (display == NULL || surface == NULL) { 394 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 395 return JNI_FALSE; 396 } 397 EGLDisplay dpy = getDisplay(_env, display); 398 EGLSurface sur = getSurface(_env, surface); 399 return EglBoolToJBool(eglDestroySurface(dpy, sur)); 400 } 401 402 static jlong jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) { 403 return reinterpret_cast<jlong>(eglGetDisplay(EGL_DEFAULT_DISPLAY)); 404 } 405 406 static jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) { 407 if (display == NULL || draw == NULL || read == NULL || context == NULL) { 408 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 409 return JNI_FALSE; 410 } 411 EGLDisplay dpy = getDisplay(_env, display); 412 EGLSurface sdr = getSurface(_env, draw); 413 EGLSurface srd = getSurface(_env, read); 414 EGLContext ctx = getContext(_env, context); 415 return EglBoolToJBool(eglMakeCurrent(dpy, sdr, srd, ctx)); 416 } 417 418 static jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) { 419 if (display == NULL) { 420 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 421 return NULL; 422 } 423 EGLDisplay dpy = getDisplay(_env, display); 424 const char* chars = eglQueryString(dpy, name); 425 return _env->NewStringUTF(chars); 426 } 427 428 static jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) { 429 if (display == NULL || surface == NULL) { 430 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 431 return JNI_FALSE; 432 } 433 EGLDisplay dpy = getDisplay(_env, display); 434 EGLSurface sur = getSurface(_env, surface); 435 return EglBoolToJBool(eglSwapBuffers(dpy, sur)); 436 } 437 438 static jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) { 439 if (display == NULL) { 440 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 441 return JNI_FALSE; 442 } 443 EGLDisplay dpy = getDisplay(_env, display); 444 return EglBoolToJBool(eglTerminate(dpy)); 445 } 446 447 static jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display, 448 jobject surface, jobject native_pixmap) { 449 if (display == NULL || surface == NULL || native_pixmap == NULL) { 450 jniThrowException(_env, "java/lang/IllegalArgumentException", NULL); 451 return JNI_FALSE; 452 } 453 // TODO: Implement this 454 return JNI_FALSE; 455 } 456 457 static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) { 458 return EglBoolToJBool(eglWaitGL()); 459 } 460 461 static jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) { 462 return EglBoolToJBool(eglWaitNative(engine)); 463 } 464 465 466 static const char *classPathName = "com/google/android/gles_jni/EGLImpl"; 467 468 #define DISPLAY "Ljavax/microedition/khronos/egl/EGLDisplay;" 469 #define CONTEXT "Ljavax/microedition/khronos/egl/EGLContext;" 470 #define CONFIG "Ljavax/microedition/khronos/egl/EGLConfig;" 471 #define SURFACE "Ljavax/microedition/khronos/egl/EGLSurface;" 472 #define OBJECT "Ljava/lang/Object;" 473 #define STRING "Ljava/lang/String;" 474 475 static const JNINativeMethod methods[] = { 476 {"_nativeClassInit","()V", (void*)nativeClassInit }, 477 {"eglWaitGL", "()Z", (void*)jni_eglWaitGL }, 478 {"eglInitialize", "(" DISPLAY "[I)Z", (void*)jni_eglInitialize }, 479 {"eglQueryContext", "(" DISPLAY CONTEXT "I[I)Z", (void*)jni_eglQueryContext }, 480 {"eglQuerySurface", "(" DISPLAY SURFACE "I[I)Z", (void*)jni_eglQuerySurface }, 481 {"eglReleaseThread","()Z", (void*)jni_eglReleaseThread }, 482 {"getInitCount", "(" DISPLAY ")I", (void*)jni_getInitCount }, 483 {"eglChooseConfig", "(" DISPLAY "[I[" CONFIG "I[I)Z", (void*)jni_eglChooseConfig }, 484 {"_eglCreateContext","(" DISPLAY CONFIG CONTEXT "[I)J", (void*)jni_eglCreateContext }, 485 {"eglGetConfigs", "(" DISPLAY "[" CONFIG "I[I)Z", (void*)jni_eglGetConfigs }, 486 {"eglTerminate", "(" DISPLAY ")Z", (void*)jni_eglTerminate }, 487 {"eglCopyBuffers", "(" DISPLAY SURFACE OBJECT ")Z", (void*)jni_eglCopyBuffers }, 488 {"eglWaitNative", "(I" OBJECT ")Z", (void*)jni_eglWaitNative }, 489 {"eglGetError", "()I", (void*)jni_eglGetError }, 490 {"eglGetConfigAttrib", "(" DISPLAY CONFIG "I[I)Z", (void*)jni_eglGetConfigAttrib }, 491 {"_eglGetDisplay", "(" OBJECT ")J", (void*)jni_eglGetDisplay }, 492 {"_eglGetCurrentContext", "()J", (void*)jni_eglGetCurrentContext }, 493 {"_eglGetCurrentDisplay", "()J", (void*)jni_eglGetCurrentDisplay }, 494 {"_eglGetCurrentSurface", "(I)J", (void*)jni_eglGetCurrentSurface }, 495 {"_eglCreatePbufferSurface","(" DISPLAY CONFIG "[I)J", (void*)jni_eglCreatePbufferSurface }, 496 {"_eglCreatePixmapSurface", "(" SURFACE DISPLAY CONFIG OBJECT "[I)V", (void*)jni_eglCreatePixmapSurface }, 497 {"_eglCreateWindowSurface", "(" DISPLAY CONFIG OBJECT "[I)J", (void*)jni_eglCreateWindowSurface }, 498 {"_eglCreateWindowSurfaceTexture", "(" DISPLAY CONFIG OBJECT "[I)J", (void*)jni_eglCreateWindowSurfaceTexture }, 499 {"eglDestroyContext", "(" DISPLAY CONTEXT ")Z", (void*)jni_eglDestroyContext }, 500 {"eglDestroySurface", "(" DISPLAY SURFACE ")Z", (void*)jni_eglDestroySurface }, 501 {"eglMakeCurrent", "(" DISPLAY SURFACE SURFACE CONTEXT")Z", (void*)jni_eglMakeCurrent }, 502 {"eglQueryString", "(" DISPLAY "I)" STRING, (void*)jni_eglQueryString }, 503 {"eglSwapBuffers", "(" DISPLAY SURFACE ")Z", (void*)jni_eglSwapBuffers }, 504 }; 505 506 } // namespace android 507 508 int register_com_google_android_gles_jni_EGLImpl(JNIEnv *_env) 509 { 510 int err; 511 err = android::AndroidRuntime::registerNativeMethods(_env, 512 android::classPathName, android::methods, NELEM(android::methods)); 513 return err; 514 } 515
