Graphics.cpp revision 1abf5d62429e5a9329520b2f7c2b5a5e7a8e72ec
1#define LOG_TAG "GraphicsJNI" 2 3#include "jni.h" 4#include "JNIHelp.h" 5#include "GraphicsJNI.h" 6 7#include "SkCanvas.h" 8#include "SkDevice.h" 9#include "SkPicture.h" 10#include "SkRegion.h" 11#include <android_runtime/AndroidRuntime.h> 12 13void doThrowNPE(JNIEnv* env) { 14 jniThrowNullPointerException(env, NULL); 15} 16 17void doThrowAIOOBE(JNIEnv* env) { 18 jniThrowException(env, "java/lang/ArrayIndexOutOfBoundsException", NULL); 19} 20 21void doThrowRE(JNIEnv* env, const char* msg) { 22 jniThrowRuntimeException(env, msg); 23} 24 25void doThrowIAE(JNIEnv* env, const char* msg) { 26 jniThrowException(env, "java/lang/IllegalArgumentException", msg); 27} 28 29void doThrowISE(JNIEnv* env, const char* msg) { 30 jniThrowException(env, "java/lang/IllegalStateException", msg); 31} 32 33void doThrowOOME(JNIEnv* env, const char* msg) { 34 jniThrowException(env, "java/lang/OutOfMemoryError", msg); 35} 36 37void doThrowIOE(JNIEnv* env, const char* msg) { 38 jniThrowException(env, "java/io/IOException", msg); 39} 40 41bool GraphicsJNI::hasException(JNIEnv *env) { 42 if (env->ExceptionCheck() != 0) { 43 ALOGE("*** Uncaught exception returned from Java call!\n"); 44 env->ExceptionDescribe(); 45 return true; 46 } 47 return false; 48} 49 50/////////////////////////////////////////////////////////////////////////////// 51 52AutoJavaFloatArray::AutoJavaFloatArray(JNIEnv* env, jfloatArray array, 53 int minLength, JNIAccess access) 54: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 55 SkASSERT(env); 56 if (array) { 57 fLen = env->GetArrayLength(array); 58 if (fLen < minLength) { 59 sk_throw(); 60 } 61 fPtr = env->GetFloatArrayElements(array, NULL); 62 } 63 fReleaseMode = (access == kRO_JNIAccess) ? JNI_ABORT : 0; 64} 65 66AutoJavaFloatArray::~AutoJavaFloatArray() { 67 if (fPtr) { 68 fEnv->ReleaseFloatArrayElements(fArray, fPtr, fReleaseMode); 69 } 70} 71 72AutoJavaIntArray::AutoJavaIntArray(JNIEnv* env, jintArray array, 73 int minLength) 74: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 75 SkASSERT(env); 76 if (array) { 77 fLen = env->GetArrayLength(array); 78 if (fLen < minLength) { 79 sk_throw(); 80 } 81 fPtr = env->GetIntArrayElements(array, NULL); 82 } 83} 84 85AutoJavaIntArray::~AutoJavaIntArray() { 86 if (fPtr) { 87 fEnv->ReleaseIntArrayElements(fArray, fPtr, 0); 88 } 89} 90 91AutoJavaShortArray::AutoJavaShortArray(JNIEnv* env, jshortArray array, 92 int minLength, JNIAccess access) 93: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 94 SkASSERT(env); 95 if (array) { 96 fLen = env->GetArrayLength(array); 97 if (fLen < minLength) { 98 sk_throw(); 99 } 100 fPtr = env->GetShortArrayElements(array, NULL); 101 } 102 fReleaseMode = (access == kRO_JNIAccess) ? JNI_ABORT : 0; 103} 104 105AutoJavaShortArray::~AutoJavaShortArray() { 106 if (fPtr) { 107 fEnv->ReleaseShortArrayElements(fArray, fPtr, fReleaseMode); 108 } 109} 110 111AutoJavaByteArray::AutoJavaByteArray(JNIEnv* env, jbyteArray array, 112 int minLength) 113: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { 114 SkASSERT(env); 115 if (array) { 116 fLen = env->GetArrayLength(array); 117 if (fLen < minLength) { 118 sk_throw(); 119 } 120 fPtr = env->GetByteArrayElements(array, NULL); 121 } 122} 123 124AutoJavaByteArray::~AutoJavaByteArray() { 125 if (fPtr) { 126 fEnv->ReleaseByteArrayElements(fArray, fPtr, 0); 127 } 128} 129 130/////////////////////////////////////////////////////////////////////////////// 131 132static jclass gRect_class; 133static jfieldID gRect_leftFieldID; 134static jfieldID gRect_topFieldID; 135static jfieldID gRect_rightFieldID; 136static jfieldID gRect_bottomFieldID; 137 138static jclass gRectF_class; 139static jfieldID gRectF_leftFieldID; 140static jfieldID gRectF_topFieldID; 141static jfieldID gRectF_rightFieldID; 142static jfieldID gRectF_bottomFieldID; 143 144static jclass gPoint_class; 145static jfieldID gPoint_xFieldID; 146static jfieldID gPoint_yFieldID; 147 148static jclass gPointF_class; 149static jfieldID gPointF_xFieldID; 150static jfieldID gPointF_yFieldID; 151 152static jclass gBitmap_class; 153static jfieldID gBitmap_nativeInstanceID; 154static jmethodID gBitmap_constructorMethodID; 155static jmethodID gBitmap_reinitMethodID; 156static jmethodID gBitmap_getAllocationByteCountMethodID; 157 158static jclass gBitmapConfig_class; 159static jfieldID gBitmapConfig_nativeInstanceID; 160 161static jclass gBitmapRegionDecoder_class; 162static jmethodID gBitmapRegionDecoder_constructorMethodID; 163 164static jclass gCanvas_class; 165static jfieldID gCanvas_nativeInstanceID; 166 167static jclass gPaint_class; 168static jfieldID gPaint_nativeInstanceID; 169 170static jclass gPicture_class; 171static jfieldID gPicture_nativeInstanceID; 172 173static jclass gRegion_class; 174static jfieldID gRegion_nativeInstanceID; 175static jmethodID gRegion_constructorMethodID; 176 177/////////////////////////////////////////////////////////////////////////////// 178 179void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B) 180{ 181 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 182 183 *L = env->GetIntField(obj, gRect_leftFieldID); 184 *T = env->GetIntField(obj, gRect_topFieldID); 185 *R = env->GetIntField(obj, gRect_rightFieldID); 186 *B = env->GetIntField(obj, gRect_bottomFieldID); 187} 188 189void GraphicsJNI::set_jrect(JNIEnv* env, jobject obj, int L, int T, int R, int B) 190{ 191 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 192 193 env->SetIntField(obj, gRect_leftFieldID, L); 194 env->SetIntField(obj, gRect_topFieldID, T); 195 env->SetIntField(obj, gRect_rightFieldID, R); 196 env->SetIntField(obj, gRect_bottomFieldID, B); 197} 198 199SkIRect* GraphicsJNI::jrect_to_irect(JNIEnv* env, jobject obj, SkIRect* ir) 200{ 201 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 202 203 ir->set(env->GetIntField(obj, gRect_leftFieldID), 204 env->GetIntField(obj, gRect_topFieldID), 205 env->GetIntField(obj, gRect_rightFieldID), 206 env->GetIntField(obj, gRect_bottomFieldID)); 207 return ir; 208} 209 210void GraphicsJNI::irect_to_jrect(const SkIRect& ir, JNIEnv* env, jobject obj) 211{ 212 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 213 214 env->SetIntField(obj, gRect_leftFieldID, ir.fLeft); 215 env->SetIntField(obj, gRect_topFieldID, ir.fTop); 216 env->SetIntField(obj, gRect_rightFieldID, ir.fRight); 217 env->SetIntField(obj, gRect_bottomFieldID, ir.fBottom); 218} 219 220SkRect* GraphicsJNI::jrectf_to_rect(JNIEnv* env, jobject obj, SkRect* r) 221{ 222 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 223 224 r->set(SkFloatToScalar(env->GetFloatField(obj, gRectF_leftFieldID)), 225 SkFloatToScalar(env->GetFloatField(obj, gRectF_topFieldID)), 226 SkFloatToScalar(env->GetFloatField(obj, gRectF_rightFieldID)), 227 SkFloatToScalar(env->GetFloatField(obj, gRectF_bottomFieldID))); 228 return r; 229} 230 231SkRect* GraphicsJNI::jrect_to_rect(JNIEnv* env, jobject obj, SkRect* r) 232{ 233 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 234 235 r->set(SkIntToScalar(env->GetIntField(obj, gRect_leftFieldID)), 236 SkIntToScalar(env->GetIntField(obj, gRect_topFieldID)), 237 SkIntToScalar(env->GetIntField(obj, gRect_rightFieldID)), 238 SkIntToScalar(env->GetIntField(obj, gRect_bottomFieldID))); 239 return r; 240} 241 242void GraphicsJNI::rect_to_jrectf(const SkRect& r, JNIEnv* env, jobject obj) 243{ 244 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 245 246 env->SetFloatField(obj, gRectF_leftFieldID, SkScalarToFloat(r.fLeft)); 247 env->SetFloatField(obj, gRectF_topFieldID, SkScalarToFloat(r.fTop)); 248 env->SetFloatField(obj, gRectF_rightFieldID, SkScalarToFloat(r.fRight)); 249 env->SetFloatField(obj, gRectF_bottomFieldID, SkScalarToFloat(r.fBottom)); 250} 251 252SkIPoint* GraphicsJNI::jpoint_to_ipoint(JNIEnv* env, jobject obj, SkIPoint* point) 253{ 254 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 255 256 point->set(env->GetIntField(obj, gPoint_xFieldID), 257 env->GetIntField(obj, gPoint_yFieldID)); 258 return point; 259} 260 261void GraphicsJNI::ipoint_to_jpoint(const SkIPoint& ir, JNIEnv* env, jobject obj) 262{ 263 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 264 265 env->SetIntField(obj, gPoint_xFieldID, ir.fX); 266 env->SetIntField(obj, gPoint_yFieldID, ir.fY); 267} 268 269SkPoint* GraphicsJNI::jpointf_to_point(JNIEnv* env, jobject obj, SkPoint* point) 270{ 271 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 272 273 point->set(SkFloatToScalar(env->GetIntField(obj, gPointF_xFieldID)), 274 SkFloatToScalar(env->GetIntField(obj, gPointF_yFieldID))); 275 return point; 276} 277 278void GraphicsJNI::point_to_jpointf(const SkPoint& r, JNIEnv* env, jobject obj) 279{ 280 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 281 282 env->SetFloatField(obj, gPointF_xFieldID, SkScalarToFloat(r.fX)); 283 env->SetFloatField(obj, gPointF_yFieldID, SkScalarToFloat(r.fY)); 284} 285 286SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { 287 SkASSERT(env); 288 SkASSERT(bitmap); 289 SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); 290 SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID); 291 SkASSERT(b); 292 return b; 293} 294 295SkBitmap::Config GraphicsJNI::getNativeBitmapConfig(JNIEnv* env, 296 jobject jconfig) { 297 SkASSERT(env); 298 if (NULL == jconfig) { 299 return SkBitmap::kNo_Config; 300 } 301 SkASSERT(env->IsInstanceOf(jconfig, gBitmapConfig_class)); 302 int c = env->GetIntField(jconfig, gBitmapConfig_nativeInstanceID); 303 if (c < 0 || c >= SkBitmap::kConfigCount) { 304 c = SkBitmap::kNo_Config; 305 } 306 return static_cast<SkBitmap::Config>(c); 307} 308 309SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { 310 SkASSERT(env); 311 SkASSERT(canvas); 312 SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); 313 SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID); 314 SkASSERT(c); 315 return c; 316} 317 318SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { 319 SkASSERT(env); 320 SkASSERT(paint); 321 SkASSERT(env->IsInstanceOf(paint, gPaint_class)); 322 SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID); 323 SkASSERT(p); 324 return p; 325} 326 327SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) 328{ 329 SkASSERT(env); 330 SkASSERT(picture); 331 SkASSERT(env->IsInstanceOf(picture, gPicture_class)); 332 SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID); 333 SkASSERT(p); 334 return p; 335} 336 337SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) 338{ 339 SkASSERT(env); 340 SkASSERT(region); 341 SkASSERT(env->IsInstanceOf(region, gRegion_class)); 342 SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID); 343 SkASSERT(r); 344 return r; 345} 346 347/////////////////////////////////////////////////////////////////////////////////////////// 348 349jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer, 350 int bitmapCreateFlags, jbyteArray ninepatch, jintArray layoutbounds, int density) 351{ 352 SkASSERT(bitmap); 353 SkASSERT(bitmap->pixelRef()); 354 bool isMutable = bitmapCreateFlags & kBitmapCreateFlag_Mutable; 355 bool isPremultiplied = bitmapCreateFlags & kBitmapCreateFlag_Premultiplied; 356 357 jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID, 358 static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)), buffer, 359 bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied, 360 ninepatch, layoutbounds); 361 hasException(env); // For the side effect of logging. 362 return obj; 363} 364 365jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, int bitmapCreateFlags, 366 jbyteArray ninepatch, int density) 367{ 368 return createBitmap(env, bitmap, NULL, bitmapCreateFlags, ninepatch, NULL, density); 369} 370 371void GraphicsJNI::reinitBitmap(JNIEnv* env, jobject javaBitmap, SkBitmap* bitmap, 372 bool isPremultiplied) 373{ 374 env->CallVoidMethod(javaBitmap, gBitmap_reinitMethodID, 375 bitmap->width(), bitmap->height(), isPremultiplied); 376} 377 378int GraphicsJNI::getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap) 379{ 380 return env->CallIntMethod(javaBitmap, gBitmap_getAllocationByteCountMethodID); 381} 382 383jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap) 384{ 385 SkASSERT(bitmap != NULL); 386 387 jobject obj = env->NewObject(gBitmapRegionDecoder_class, 388 gBitmapRegionDecoder_constructorMethodID, 389 static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap))); 390 hasException(env); // For the side effect of logging. 391 return obj; 392} 393 394jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) 395{ 396 SkASSERT(region != NULL); 397 jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID, 398 static_cast<jint>(reinterpret_cast<uintptr_t>(region)), 0); 399 hasException(env); // For the side effect of logging. 400 return obj; 401} 402 403static JNIEnv* vm2env(JavaVM* vm) 404{ 405 JNIEnv* env = NULL; 406 if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK || NULL == env) 407 { 408 SkDebugf("------- [%p] vm->GetEnv() failed\n", vm); 409 sk_throw(); 410 } 411 return env; 412} 413 414/////////////////////////////////////////////////////////////////////////////// 415 416AndroidPixelRef::AndroidPixelRef(JNIEnv* env, void* storage, size_t size, jbyteArray storageObj, 417 SkColorTable* ctable) : SkMallocPixelRef(storage, size, ctable, (storageObj == NULL)) { 418 SkASSERT(storage); 419 SkASSERT(env); 420 421 if (env->GetJavaVM(&fVM) != JNI_OK) { 422 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 423 sk_throw(); 424 } 425 fStorageObj = storageObj; 426 fHasGlobalRef = false; 427 fGlobalRefCnt = 0; 428 429 // If storageObj is NULL, the memory was NOT allocated on the Java heap 430 fOnJavaHeap = (storageObj != NULL); 431 432} 433 434AndroidPixelRef::~AndroidPixelRef() { 435 if (fOnJavaHeap) { 436 JNIEnv* env = vm2env(fVM); 437 438 if (fStorageObj && fHasGlobalRef) { 439 env->DeleteGlobalRef(fStorageObj); 440 } 441 fStorageObj = NULL; 442 } 443} 444 445void AndroidPixelRef::setLocalJNIRef(jbyteArray arr) { 446 if (!fHasGlobalRef) { 447 fStorageObj = arr; 448 } 449} 450 451void AndroidPixelRef::globalRef(void* localref) { 452 if (fOnJavaHeap && sk_atomic_inc(&fGlobalRefCnt) == 0) { 453 JNIEnv *env = vm2env(fVM); 454 455 // If JNI ref was passed, it is always used 456 if (localref) fStorageObj = (jbyteArray) localref; 457 458 if (fStorageObj == NULL) { 459 SkDebugf("No valid local ref to create a JNI global ref\n"); 460 sk_throw(); 461 } 462 if (fHasGlobalRef) { 463 // This should never happen 464 SkDebugf("Already holding a JNI global ref"); 465 sk_throw(); 466 } 467 468 fStorageObj = (jbyteArray) env->NewGlobalRef(fStorageObj); 469 // TODO: Check for failure here 470 fHasGlobalRef = true; 471 } 472 ref(); 473} 474 475void AndroidPixelRef::globalUnref() { 476 if (fOnJavaHeap && sk_atomic_dec(&fGlobalRefCnt) == 1) { 477 JNIEnv *env = vm2env(fVM); 478 if (!fHasGlobalRef) { 479 SkDebugf("We don't have a global ref!"); 480 sk_throw(); 481 } 482 env->DeleteGlobalRef(fStorageObj); 483 fStorageObj = NULL; 484 fHasGlobalRef = false; 485 } 486 unref(); 487} 488 489/////////////////////////////////////////////////////////////////////////////// 490 491extern "C" jbyte* jniGetNonMovableArrayElements(C_JNIEnv* env, jarray arrayObj); 492 493jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, 494 SkColorTable* ctable) { 495 Sk64 size64 = bitmap->getSize64(); 496 if (size64.isNeg() || !size64.is32()) { 497 jniThrowException(env, "java/lang/IllegalArgumentException", 498 "bitmap size exceeds 32bits"); 499 return NULL; 500 } 501 502 size_t size = size64.get32(); 503 jbyteArray arrayObj = env->NewByteArray(size); 504 if (arrayObj) { 505 // TODO: make this work without jniGetNonMovableArrayElements 506 jbyte* addr = jniGetNonMovableArrayElements(&env->functions, arrayObj); 507 if (addr) { 508 SkPixelRef* pr = new AndroidPixelRef(env, (void*) addr, size, arrayObj, ctable); 509 bitmap->setPixelRef(pr)->unref(); 510 // since we're already allocated, we lockPixels right away 511 // HeapAllocator behaves this way too 512 bitmap->lockPixels(); 513 } 514 } 515 516 return arrayObj; 517} 518 519/////////////////////////////////////////////////////////////////////////////// 520 521JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) 522 : fStorageObj(NULL), 523 fAllocCount(0) { 524 if (env->GetJavaVM(&fVM) != JNI_OK) { 525 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 526 sk_throw(); 527 } 528} 529 530bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) { 531 JNIEnv* env = vm2env(fVM); 532 533 fStorageObj = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable); 534 fAllocCount += 1; 535 return fStorageObj != NULL; 536} 537 538//////////////////////////////////////////////////////////////////////////////// 539 540JavaHeapBitmapRef::JavaHeapBitmapRef(JNIEnv* env, SkBitmap* nativeBitmap, jbyteArray buffer) { 541 fEnv = env; 542 fNativeBitmap = nativeBitmap; 543 fBuffer = buffer; 544 545 // If the buffer is NULL, the backing memory wasn't allocated on the Java heap 546 if (fBuffer) { 547 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(fBuffer); 548 } 549} 550 551JavaHeapBitmapRef::~JavaHeapBitmapRef() { 552 if (fBuffer) { 553 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(NULL); 554 } 555} 556 557//////////////////////////////////////////////////////////////////////////////// 558 559static jclass make_globalref(JNIEnv* env, const char classname[]) 560{ 561 jclass c = env->FindClass(classname); 562 SkASSERT(c); 563 return (jclass)env->NewGlobalRef(c); 564} 565 566static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, 567 const char fieldname[], const char type[]) 568{ 569 jfieldID id = env->GetFieldID(clazz, fieldname, type); 570 SkASSERT(id); 571 return id; 572} 573 574int register_android_graphics_Graphics(JNIEnv* env) 575{ 576 jmethodID m; 577 jclass c; 578 579 gRect_class = make_globalref(env, "android/graphics/Rect"); 580 gRect_leftFieldID = getFieldIDCheck(env, gRect_class, "left", "I"); 581 gRect_topFieldID = getFieldIDCheck(env, gRect_class, "top", "I"); 582 gRect_rightFieldID = getFieldIDCheck(env, gRect_class, "right", "I"); 583 gRect_bottomFieldID = getFieldIDCheck(env, gRect_class, "bottom", "I"); 584 585 gRectF_class = make_globalref(env, "android/graphics/RectF"); 586 gRectF_leftFieldID = getFieldIDCheck(env, gRectF_class, "left", "F"); 587 gRectF_topFieldID = getFieldIDCheck(env, gRectF_class, "top", "F"); 588 gRectF_rightFieldID = getFieldIDCheck(env, gRectF_class, "right", "F"); 589 gRectF_bottomFieldID = getFieldIDCheck(env, gRectF_class, "bottom", "F"); 590 591 gPoint_class = make_globalref(env, "android/graphics/Point"); 592 gPoint_xFieldID = getFieldIDCheck(env, gPoint_class, "x", "I"); 593 gPoint_yFieldID = getFieldIDCheck(env, gPoint_class, "y", "I"); 594 595 gPointF_class = make_globalref(env, "android/graphics/PointF"); 596 gPointF_xFieldID = getFieldIDCheck(env, gPointF_class, "x", "F"); 597 gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); 598 599 gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); 600 gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I"); 601 gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(I[BIIIZZ[B[I)V"); 602 gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V"); 603 gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I"); 604 gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder"); 605 gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V"); 606 607 gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config"); 608 gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class, 609 "nativeInt", "I"); 610 611 gCanvas_class = make_globalref(env, "android/graphics/Canvas"); 612 gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I"); 613 614 gPaint_class = make_globalref(env, "android/graphics/Paint"); 615 gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I"); 616 617 gPicture_class = make_globalref(env, "android/graphics/Picture"); 618 gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I"); 619 620 gRegion_class = make_globalref(env, "android/graphics/Region"); 621 gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I"); 622 gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", 623 "(II)V"); 624 625 return 0; 626} 627