Graphics.cpp revision 69a017bc1d1649350f830dfada5c6ed5eac0b770
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 LOGE("*** 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; 155 156static jclass gBitmapConfig_class; 157static jfieldID gBitmapConfig_nativeInstanceID; 158 159static jclass gBitmapRegionDecoder_class; 160static jmethodID gBitmapRegionDecoder_constructorMethodID; 161 162static jclass gCanvas_class; 163static jfieldID gCanvas_nativeInstanceID; 164 165static jclass gPaint_class; 166static jfieldID gPaint_nativeInstanceID; 167 168static jclass gPicture_class; 169static jfieldID gPicture_nativeInstanceID; 170 171static jclass gRegion_class; 172static jfieldID gRegion_nativeInstanceID; 173static jmethodID gRegion_constructorMethodID; 174 175/////////////////////////////////////////////////////////////////////////////// 176 177void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B) 178{ 179 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 180 181 *L = env->GetIntField(obj, gRect_leftFieldID); 182 *T = env->GetIntField(obj, gRect_topFieldID); 183 *R = env->GetIntField(obj, gRect_rightFieldID); 184 *B = env->GetIntField(obj, gRect_bottomFieldID); 185} 186 187void GraphicsJNI::set_jrect(JNIEnv* env, jobject obj, int L, int T, int R, int B) 188{ 189 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 190 191 env->SetIntField(obj, gRect_leftFieldID, L); 192 env->SetIntField(obj, gRect_topFieldID, T); 193 env->SetIntField(obj, gRect_rightFieldID, R); 194 env->SetIntField(obj, gRect_bottomFieldID, B); 195} 196 197SkIRect* GraphicsJNI::jrect_to_irect(JNIEnv* env, jobject obj, SkIRect* ir) 198{ 199 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 200 201 ir->set(env->GetIntField(obj, gRect_leftFieldID), 202 env->GetIntField(obj, gRect_topFieldID), 203 env->GetIntField(obj, gRect_rightFieldID), 204 env->GetIntField(obj, gRect_bottomFieldID)); 205 return ir; 206} 207 208void GraphicsJNI::irect_to_jrect(const SkIRect& ir, JNIEnv* env, jobject obj) 209{ 210 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 211 212 env->SetIntField(obj, gRect_leftFieldID, ir.fLeft); 213 env->SetIntField(obj, gRect_topFieldID, ir.fTop); 214 env->SetIntField(obj, gRect_rightFieldID, ir.fRight); 215 env->SetIntField(obj, gRect_bottomFieldID, ir.fBottom); 216} 217 218SkRect* GraphicsJNI::jrectf_to_rect(JNIEnv* env, jobject obj, SkRect* r) 219{ 220 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 221 222 r->set(SkFloatToScalar(env->GetFloatField(obj, gRectF_leftFieldID)), 223 SkFloatToScalar(env->GetFloatField(obj, gRectF_topFieldID)), 224 SkFloatToScalar(env->GetFloatField(obj, gRectF_rightFieldID)), 225 SkFloatToScalar(env->GetFloatField(obj, gRectF_bottomFieldID))); 226 return r; 227} 228 229SkRect* GraphicsJNI::jrect_to_rect(JNIEnv* env, jobject obj, SkRect* r) 230{ 231 SkASSERT(env->IsInstanceOf(obj, gRect_class)); 232 233 r->set(SkIntToScalar(env->GetIntField(obj, gRect_leftFieldID)), 234 SkIntToScalar(env->GetIntField(obj, gRect_topFieldID)), 235 SkIntToScalar(env->GetIntField(obj, gRect_rightFieldID)), 236 SkIntToScalar(env->GetIntField(obj, gRect_bottomFieldID))); 237 return r; 238} 239 240void GraphicsJNI::rect_to_jrectf(const SkRect& r, JNIEnv* env, jobject obj) 241{ 242 SkASSERT(env->IsInstanceOf(obj, gRectF_class)); 243 244 env->SetFloatField(obj, gRectF_leftFieldID, SkScalarToFloat(r.fLeft)); 245 env->SetFloatField(obj, gRectF_topFieldID, SkScalarToFloat(r.fTop)); 246 env->SetFloatField(obj, gRectF_rightFieldID, SkScalarToFloat(r.fRight)); 247 env->SetFloatField(obj, gRectF_bottomFieldID, SkScalarToFloat(r.fBottom)); 248} 249 250SkIPoint* GraphicsJNI::jpoint_to_ipoint(JNIEnv* env, jobject obj, SkIPoint* point) 251{ 252 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 253 254 point->set(env->GetIntField(obj, gPoint_xFieldID), 255 env->GetIntField(obj, gPoint_yFieldID)); 256 return point; 257} 258 259void GraphicsJNI::ipoint_to_jpoint(const SkIPoint& ir, JNIEnv* env, jobject obj) 260{ 261 SkASSERT(env->IsInstanceOf(obj, gPoint_class)); 262 263 env->SetIntField(obj, gPoint_xFieldID, ir.fX); 264 env->SetIntField(obj, gPoint_yFieldID, ir.fY); 265} 266 267SkPoint* GraphicsJNI::jpointf_to_point(JNIEnv* env, jobject obj, SkPoint* point) 268{ 269 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 270 271 point->set(SkFloatToScalar(env->GetIntField(obj, gPointF_xFieldID)), 272 SkFloatToScalar(env->GetIntField(obj, gPointF_yFieldID))); 273 return point; 274} 275 276void GraphicsJNI::point_to_jpointf(const SkPoint& r, JNIEnv* env, jobject obj) 277{ 278 SkASSERT(env->IsInstanceOf(obj, gPointF_class)); 279 280 env->SetFloatField(obj, gPointF_xFieldID, SkScalarToFloat(r.fX)); 281 env->SetFloatField(obj, gPointF_yFieldID, SkScalarToFloat(r.fY)); 282} 283 284SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { 285 SkASSERT(env); 286 SkASSERT(bitmap); 287 SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); 288 SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID); 289 SkASSERT(b); 290 return b; 291} 292 293SkBitmap::Config GraphicsJNI::getNativeBitmapConfig(JNIEnv* env, 294 jobject jconfig) { 295 SkASSERT(env); 296 if (NULL == jconfig) { 297 return SkBitmap::kNo_Config; 298 } 299 SkASSERT(env->IsInstanceOf(jconfig, gBitmapConfig_class)); 300 int c = env->GetIntField(jconfig, gBitmapConfig_nativeInstanceID); 301 if (c < 0 || c >= SkBitmap::kConfigCount) { 302 c = SkBitmap::kNo_Config; 303 } 304 return static_cast<SkBitmap::Config>(c); 305} 306 307SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { 308 SkASSERT(env); 309 SkASSERT(canvas); 310 SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); 311 SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID); 312 SkASSERT(c); 313 return c; 314} 315 316SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { 317 SkASSERT(env); 318 SkASSERT(paint); 319 SkASSERT(env->IsInstanceOf(paint, gPaint_class)); 320 SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID); 321 SkASSERT(p); 322 return p; 323} 324 325SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) 326{ 327 SkASSERT(env); 328 SkASSERT(picture); 329 SkASSERT(env->IsInstanceOf(picture, gPicture_class)); 330 SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID); 331 SkASSERT(p); 332 return p; 333} 334 335SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) 336{ 337 SkASSERT(env); 338 SkASSERT(region); 339 SkASSERT(env->IsInstanceOf(region, gRegion_class)); 340 SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID); 341 SkASSERT(r); 342 return r; 343} 344 345/////////////////////////////////////////////////////////////////////////////////////////// 346 347jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buffer, 348 bool isMutable, jbyteArray ninepatch, int density) 349{ 350 SkASSERT(bitmap); 351 SkASSERT(bitmap->pixelRef()); 352 353 jobject obj = env->AllocObject(gBitmap_class); 354 if (obj) { 355 env->CallVoidMethod(obj, gBitmap_constructorMethodID, 356 (jint)bitmap, buffer, isMutable, ninepatch, density); 357 if (hasException(env)) { 358 obj = NULL; 359 } 360 } 361 return obj; 362} 363 364jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, 365 jbyteArray ninepatch, int density) 366{ 367 return createBitmap(env, bitmap, NULL, isMutable, ninepatch, density); 368} 369 370 371jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap) 372{ 373 SkASSERT(bitmap != NULL); 374 375 jobject obj = env->AllocObject(gBitmapRegionDecoder_class); 376 if (hasException(env)) { 377 obj = NULL; 378 return obj; 379 } 380 if (obj) { 381 env->CallVoidMethod(obj, gBitmapRegionDecoder_constructorMethodID, (jint)bitmap); 382 if (hasException(env)) { 383 obj = NULL; 384 } 385 } 386 return obj; 387} 388 389jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) 390{ 391 SkASSERT(region != NULL); 392 jobject obj = env->AllocObject(gRegion_class); 393 if (obj) { 394 env->CallVoidMethod(obj, gRegion_constructorMethodID, (jint)region, 0); 395 if (hasException(env)) { 396 obj = NULL; 397 } 398 } 399 return obj; 400} 401 402static JNIEnv* vm2env(JavaVM* vm) 403{ 404 JNIEnv* env = NULL; 405 if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK || NULL == env) 406 { 407 SkDebugf("------- [%p] vm->GetEnv() failed\n", vm); 408 sk_throw(); 409 } 410 return env; 411} 412 413/////////////////////////////////////////////////////////////////////////////// 414 415AndroidPixelRef::AndroidPixelRef(JNIEnv* env, void* storage, size_t size, jbyteArray storageObj, 416 SkColorTable* ctable) : SkMallocPixelRef(storage, size, ctable) { 417 SkASSERT(storage); 418 SkASSERT(env); 419 420 if (env->GetJavaVM(&fVM) != JNI_OK) { 421 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 422 sk_throw(); 423 } 424 fStorageObj = storageObj; 425 fHasGlobalRef = false; 426 fGlobalRefCnt = 0; 427 428 // If storageObj is NULL, the memory was NOT allocated on the Java heap 429 fOnJavaHeap = (storageObj != NULL); 430 431} 432 433AndroidPixelRef::~AndroidPixelRef() { 434 if (fOnJavaHeap) { 435 JNIEnv* env = vm2env(fVM); 436 437 if (fStorageObj && fHasGlobalRef) { 438 env->DeleteGlobalRef(fStorageObj); 439 } 440 fStorageObj = NULL; 441 442 // Set this to NULL to prevent the SkMallocPixelRef destructor 443 // from freeing the memory. 444 fStorage = NULL; 445 } 446} 447 448void AndroidPixelRef::setLocalJNIRef(jbyteArray arr) { 449 if (!fHasGlobalRef) { 450 fStorageObj = arr; 451 } 452} 453 454void AndroidPixelRef::globalRef(void* localref) { 455 if (fOnJavaHeap && sk_atomic_inc(&fGlobalRefCnt) == 0) { 456 JNIEnv *env = vm2env(fVM); 457 458 // If JNI ref was passed, it is always used 459 if (localref) fStorageObj = (jbyteArray) localref; 460 461 if (fStorageObj == NULL) { 462 SkDebugf("No valid local ref to create a JNI global ref\n"); 463 sk_throw(); 464 } 465 if (fHasGlobalRef) { 466 // This should never happen 467 SkDebugf("Already holding a JNI global ref"); 468 sk_throw(); 469 } 470 471 fStorageObj = (jbyteArray) env->NewGlobalRef(fStorageObj); 472 // TODO: Check for failure here 473 fHasGlobalRef = true; 474 } 475 ref(); 476} 477 478void AndroidPixelRef::globalUnref() { 479 if (fOnJavaHeap && sk_atomic_dec(&fGlobalRefCnt) == 1) { 480 JNIEnv *env = vm2env(fVM); 481 if (!fHasGlobalRef) { 482 SkDebugf("We don't have a global ref!"); 483 sk_throw(); 484 } 485 env->DeleteGlobalRef(fStorageObj); 486 fStorageObj = NULL; 487 fHasGlobalRef = false; 488 } 489 unref(); 490} 491 492/////////////////////////////////////////////////////////////////////////////// 493 494extern "C" jbyte* jniGetNonMovableArrayElements(C_JNIEnv* env, jarray arrayObj); 495 496jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, 497 SkColorTable* ctable) { 498 Sk64 size64 = bitmap->getSize64(); 499 if (size64.isNeg() || !size64.is32()) { 500 jniThrowException(env, "java/lang/IllegalArgumentException", 501 "bitmap size exceeds 32bits"); 502 return NULL; 503 } 504 505 size_t size = size64.get32(); 506 jbyteArray arrayObj = env->NewByteArray(size); 507 if (arrayObj) { 508 // TODO: make this work without jniGetNonMovableArrayElements 509 jbyte* addr = jniGetNonMovableArrayElements(&env->functions, arrayObj); 510 if (addr) { 511 SkPixelRef* pr = new AndroidPixelRef(env, (void*) addr, size, arrayObj, ctable); 512 bitmap->setPixelRef(pr)->unref(); 513 // since we're already allocated, we lockPixels right away 514 // HeapAllocator behaves this way too 515 bitmap->lockPixels(); 516 } 517 } 518 519 return arrayObj; 520} 521 522/////////////////////////////////////////////////////////////////////////////// 523 524JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) 525 : fStorageObj(NULL), 526 fAllocCount(0) { 527 if (env->GetJavaVM(&fVM) != JNI_OK) { 528 SkDebugf("------ [%p] env->GetJavaVM failed\n", env); 529 sk_throw(); 530 } 531} 532 533bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) { 534 JNIEnv* env = vm2env(fVM); 535 536 // If allocating in the Java heap, only allow a single object to be 537 // allocated for the lifetime of this object. 538 if (fStorageObj != NULL) { 539 SkDebugf("WARNING: One-shot allocator has already allocated (alloc count = %d)\n", fAllocCount); 540// sk_throw(); 541 } 542 fStorageObj = GraphicsJNI::allocateJavaPixelRef(env, bitmap, ctable); 543 fAllocCount += 1; 544 return fStorageObj != NULL; 545} 546 547//////////////////////////////////////////////////////////////////////////////// 548 549JavaHeapBitmapRef::JavaHeapBitmapRef(JNIEnv* env, SkBitmap* nativeBitmap, jbyteArray buffer) { 550 fEnv = env; 551 fNativeBitmap = nativeBitmap; 552 fBuffer = buffer; 553 554 // If the buffer is NULL, the backing memory wasn't allocated on the Java heap 555 if (fBuffer) { 556 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(fBuffer); 557 } 558} 559 560JavaHeapBitmapRef::~JavaHeapBitmapRef() { 561 if (fBuffer) { 562 ((AndroidPixelRef*) fNativeBitmap->pixelRef())->setLocalJNIRef(NULL); 563 } 564} 565 566//////////////////////////////////////////////////////////////////////////////// 567 568static jclass make_globalref(JNIEnv* env, const char classname[]) 569{ 570 jclass c = env->FindClass(classname); 571 SkASSERT(c); 572 return (jclass)env->NewGlobalRef(c); 573} 574 575static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, 576 const char fieldname[], const char type[]) 577{ 578 jfieldID id = env->GetFieldID(clazz, fieldname, type); 579 SkASSERT(id); 580 return id; 581} 582 583int register_android_graphics_Graphics(JNIEnv* env) 584{ 585 jmethodID m; 586 jclass c; 587 588 gRect_class = make_globalref(env, "android/graphics/Rect"); 589 gRect_leftFieldID = getFieldIDCheck(env, gRect_class, "left", "I"); 590 gRect_topFieldID = getFieldIDCheck(env, gRect_class, "top", "I"); 591 gRect_rightFieldID = getFieldIDCheck(env, gRect_class, "right", "I"); 592 gRect_bottomFieldID = getFieldIDCheck(env, gRect_class, "bottom", "I"); 593 594 gRectF_class = make_globalref(env, "android/graphics/RectF"); 595 gRectF_leftFieldID = getFieldIDCheck(env, gRectF_class, "left", "F"); 596 gRectF_topFieldID = getFieldIDCheck(env, gRectF_class, "top", "F"); 597 gRectF_rightFieldID = getFieldIDCheck(env, gRectF_class, "right", "F"); 598 gRectF_bottomFieldID = getFieldIDCheck(env, gRectF_class, "bottom", "F"); 599 600 gPoint_class = make_globalref(env, "android/graphics/Point"); 601 gPoint_xFieldID = getFieldIDCheck(env, gPoint_class, "x", "I"); 602 gPoint_yFieldID = getFieldIDCheck(env, gPoint_class, "y", "I"); 603 604 gPointF_class = make_globalref(env, "android/graphics/PointF"); 605 gPointF_xFieldID = getFieldIDCheck(env, gPointF_class, "x", "F"); 606 gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); 607 608 gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); 609 gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I"); 610 gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", 611 "(I[BZ[BI)V"); 612 gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder"); 613 gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V"); 614 615 gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config"); 616 gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class, 617 "nativeInt", "I"); 618 619 gCanvas_class = make_globalref(env, "android/graphics/Canvas"); 620 gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I"); 621 622 gPaint_class = make_globalref(env, "android/graphics/Paint"); 623 gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I"); 624 625 gPicture_class = make_globalref(env, "android/graphics/Picture"); 626 gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I"); 627 628 gRegion_class = make_globalref(env, "android/graphics/Region"); 629 gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I"); 630 gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", 631 "(II)V"); 632 633 return 0; 634} 635