diff options
Diffstat (limited to 'core/jni')
79 files changed, 3196 insertions, 2424 deletions
diff --git a/core/jni/Android.mk b/core/jni/Android.mk index 5983120..2e0acb1 100644 --- a/core/jni/Android.mk +++ b/core/jni/Android.mk @@ -4,6 +4,9 @@ include $(CLEAR_VARS) LOCAL_CFLAGS += -DHAVE_CONFIG_H -DKHTML_NO_EXCEPTIONS -DGKWQ_NO_JAVA LOCAL_CFLAGS += -DNO_SUPPORT_JS_BINDING -DQT_NO_WHEELEVENT -DKHTML_NO_XBL LOCAL_CFLAGS += -U__APPLE__ +LOCAL_CFLAGS += -Wno-unused-parameter -Wno-int-to-pointer-cast +LOCAL_CFLAGS += -Wno-maybe-uninitialized -Wno-parentheses +LOCAL_CPPFLAGS += -Wno-conversion-null ifeq ($(TARGET_ARCH), arm) LOCAL_CFLAGS += -DPACKED="__attribute__ ((packed))" @@ -206,7 +209,6 @@ LOCAL_SHARED_LIBRARIES := \ libicuuc \ libicui18n \ libmedia \ - libwpa_client \ libjpeg \ libusbhost \ libharfbuzz_ng \ diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index 09577da..b4599b6 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -447,6 +447,7 @@ int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv) char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX]; char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX]; char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX]; + char gctypeOptsBuf[sizeof("-Xgc:")-1 + PROPERTY_VALUE_MAX]; char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX]; char jitcodecachesizeOptsBuf[sizeof("-Xjitcodecachesize:")-1 + PROPERTY_VALUE_MAX]; char extraOptsBuf[PROPERTY_VALUE_MAX]; @@ -582,6 +583,13 @@ int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv) mOptions.add(opt); } + strcpy(gctypeOptsBuf, "-Xgc:"); + property_get("dalvik.vm.gctype", gctypeOptsBuf+5, ""); + if (gctypeOptsBuf[5] != '\0') { + opt.optionString = gctypeOptsBuf; + mOptions.add(opt); + } + /* * Enable or disable dexopt features, such as bytecode verification and * calculation of register maps for precise GC. @@ -752,13 +760,6 @@ int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv) mOptions.add(opt); } - /* - * We don't have /tmp on the device, but we often have an SD card. Apps - * shouldn't use this, but some test suites might want to exercise it. - */ - opt.optionString = "-Djava.io.tmpdir=/sdcard"; - mOptions.add(opt); - initArgs.version = JNI_VERSION_1_4; initArgs.options = mOptions.editArray(); initArgs.nOptions = mOptions.size(); diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp index 2125763..d97a945 100644 --- a/core/jni/android/graphics/Bitmap.cpp +++ b/core/jni/android/graphics/Bitmap.cpp @@ -289,8 +289,9 @@ static int getPremulBitmapCreateFlags(bool isMutable) { }
static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
- int offset, int stride, int width, int height,
- SkBitmap::Config config, jboolean isMutable) {
+ jint offset, jint stride, jint width, jint height,
+ jint configHandle, jboolean isMutable) {
+ SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle);
if (NULL != jColors) {
size_t n = env->GetArrayLength(jColors);
if (n < SkAbs32(stride) * (size_t)height) {
@@ -321,8 +322,10 @@ static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors, getPremulBitmapCreateFlags(isMutable), NULL, NULL);
}
-static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src,
- SkBitmap::Config dstConfig, jboolean isMutable) {
+static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,
+ jint dstConfigHandle, jboolean isMutable) {
+ const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);
+ SkBitmap::Config dstConfig = static_cast<SkBitmap::Config>(dstConfigHandle);
SkBitmap result;
JavaPixelAllocator allocator(env);
@@ -333,7 +336,8 @@ static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src, getPremulBitmapCreateFlags(isMutable), NULL, NULL);
}
-static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static void Bitmap_destructor(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
android::uirenderer::Caches::getInstance().resourceCache.destructor(bitmap);
@@ -343,24 +347,28 @@ static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) { delete bitmap;
}
-static jboolean Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static jboolean Bitmap_recycle(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
- return android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);
+ bool result;
+ result = android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);
+ return result ? JNI_TRUE : JNI_FALSE;
}
#endif // USE_OPENGL_RENDERER
bitmap->setPixels(NULL, NULL);
- return true;
+ return JNI_TRUE;
}
-static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jint bitmapInt,
- int width, int height, SkBitmap::Config config, int allocSize) {
+static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,
+ jint width, jint height, jint configHandle, jint allocSize) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle);
if (width * height * SkBitmap::ComputeBytesPerPixel(config) > allocSize) {
// done in native as there's no way to get BytesPerPixel in Java
doThrowIAE(env, "Bitmap not large enough to support new configuration");
return;
}
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapInt);
SkPixelRef* ref = bitmap->pixelRef();
SkSafeRef(ref);
bitmap->setConfig(config, width, height);
@@ -380,9 +388,10 @@ enum JavaEncodeFormat { kWEBP_JavaEncodeFormat = 2
};
-static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap,
- int format, int quality,
- jobject jstream, jbyteArray jstorage) {
+static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,
+ jint format, jint quality,
+ jobject jstream, jbyteArray jstorage) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkImageEncoder::Type fm;
switch (format) {
@@ -396,7 +405,7 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, fm = SkImageEncoder::kWEBP_Type;
break;
default:
- return false;
+ return JNI_FALSE;
}
bool success = false;
@@ -404,12 +413,12 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, SkAutoLockPixels alp(*bitmap);
if (NULL == bitmap->getPixels()) {
- return false;
+ return JNI_FALSE;
}
SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
if (NULL == strm) {
- return false;
+ return JNI_FALSE;
}
SkImageEncoder* encoder = SkImageEncoder::Create(fm);
@@ -419,31 +428,37 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, }
delete strm;
}
- return success;
+ return success ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) {
+static void Bitmap_erase(JNIEnv* env, jobject, jlong bitmapHandle, jint color) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->eraseColor(color);
}
-static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->rowBytes();
+static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->rowBytes());
}
-static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->config();
+static jint Bitmap_config(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->config());
}
-static int Bitmap_getGenerationId(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->getGenerationID();
+static jint Bitmap_getGenerationId(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->getGenerationID());
}
-static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return !bitmap->isOpaque();
+static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return !bitmap->isOpaque() ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, SkBitmap* bitmap,
+static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
jboolean hasAlpha, jboolean isPremul) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
if (!hasAlpha) {
bitmap->setAlphaType(kOpaque_SkAlphaType);
} else if (isPremul) {
@@ -453,12 +468,14 @@ static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, SkBitmap* bitm }
}
-static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->hasHardwareMipMap();
+static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return bitmap->hasHardwareMipMap() ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_setHasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap,
+static void Bitmap_setHasMipMap(JNIEnv* env, jobject, jlong bitmapHandle,
jboolean hasMipMap) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->setHasHardwareMipMap(hasMipMap);
}
@@ -532,12 +549,13 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) { }
static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
- const SkBitmap* bitmap,
+ jlong bitmapHandle,
jboolean isMutable, jint density,
jobject parcel) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
if (parcel == NULL) {
SkDebugf("------- writeToParcel null parcel\n");
- return false;
+ return JNI_FALSE;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
@@ -568,7 +586,7 @@ static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject, android::status_t status = p->writeBlob(size, &blob);
if (status) {
doThrowRE(env, "Could not write bitmap to parcel blob.");
- return false;
+ return JNI_FALSE;
}
bitmap->lockPixels();
@@ -581,12 +599,14 @@ static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject, bitmap->unlockPixels();
blob.release();
- return true;
+ return JNI_TRUE;
}
static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,
- const SkBitmap* src, const SkPaint* paint,
+ jlong srcHandle, jlong paintHandle,
jintArray offsetXY) {
+ const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);
+ const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkIPoint offset;
SkBitmap* dst = new SkBitmap;
JavaPixelAllocator allocator(env);
@@ -612,8 +632,9 @@ static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz, ///////////////////////////////////////////////////////////////////////////////
-static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
- int x, int y, bool isPremultiplied) {
+static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,
+ jint x, jint y, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
@@ -627,12 +648,13 @@ static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, SkColor dst[1];
proc(dst, src, 1, bitmap->getColorTable());
- return dst[0];
+ return static_cast<jint>(dst[0]);
}
-static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
- jintArray pixelArray, int offset, int stride,
- int x, int y, int width, int height, bool isPremultiplied) {
+static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,
+ jintArray pixelArray, jint offset, jint stride,
+ jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
@@ -657,8 +679,10 @@ static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap, ///////////////////////////////////////////////////////////////////////////////
-static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
- int x, int y, SkColor color, bool isPremultiplied) {
+static void Bitmap_setPixel(JNIEnv* env, jobject, jlong bitmapHandle,
+ jint x, jint y, jint colorHandle, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ SkColor color = static_cast<SkColor>(colorHandle);
SkAutoLockPixels alp(*bitmap);
if (NULL == bitmap->getPixels()) {
return;
@@ -673,15 +697,17 @@ static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, bitmap->notifyPixelsChanged();
}
-static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
- jintArray pixelArray, int offset, int stride,
- int x, int y, int width, int height, bool isPremultiplied) {
+static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,
+ jintArray pixelArray, jint offset, jint stride,
+ jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
x, y, width, height, *bitmap, isPremultiplied);
}
static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
- const SkBitmap* bitmap, jobject jbuffer) {
+ jlong bitmapHandle, jobject jbuffer) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
const void* src = bitmap->getPixels();
@@ -694,7 +720,8 @@ static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject, }
static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,
- const SkBitmap* bitmap, jobject jbuffer) {
+ jlong bitmapHandle, jobject jbuffer) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
void* dst = bitmap->getPixels();
@@ -706,12 +733,14 @@ static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject, }
}
-static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0,
- const SkBitmap* bm1) {
+static jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle,
+ jlong bm1Handle) {
+ const SkBitmap* bm0 = reinterpret_cast<SkBitmap*>(bm0Handle);
+ const SkBitmap* bm1 = reinterpret_cast<SkBitmap*>(bm1Handle);
if (bm0->width() != bm1->width() ||
bm0->height() != bm1->height() ||
bm0->config() != bm1->config()) {
- return false;
+ return JNI_FALSE;
}
SkAutoLockPixels alp0(*bm0);
@@ -719,24 +748,24 @@ static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0, // if we can't load the pixels, return false
if (NULL == bm0->getPixels() || NULL == bm1->getPixels()) {
- return false;
+ return JNI_FALSE;
}
if (bm0->config() == SkBitmap::kIndex8_Config) {
SkColorTable* ct0 = bm0->getColorTable();
SkColorTable* ct1 = bm1->getColorTable();
if (NULL == ct0 || NULL == ct1) {
- return false;
+ return JNI_FALSE;
}
if (ct0->count() != ct1->count()) {
- return false;
+ return JNI_FALSE;
}
SkAutoLockColors alc0(ct0);
SkAutoLockColors alc1(ct1);
const size_t size = ct0->count() * sizeof(SkPMColor);
if (memcmp(alc0.colors(), alc1.colors(), size) != 0) {
- return false;
+ return JNI_FALSE;
}
}
@@ -747,13 +776,14 @@ static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0, const size_t size = bm0->width() * bm0->bytesPerPixel();
for (int y = 0; y < h; y++) {
if (memcmp(bm0->getAddr(0, y), bm1->getAddr(0, y), size) != 0) {
- return false;
+ return JNI_FALSE;
}
}
- return true;
+ return JNI_TRUE;
}
-static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static void Bitmap_prepareToDraw(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->lockPixels();
bitmap->unlockPixels();
}
@@ -765,38 +795,38 @@ static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) { static JNINativeMethod gBitmapMethods[] = {
{ "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;",
(void*)Bitmap_creator },
- { "nativeCopy", "(IIZ)Landroid/graphics/Bitmap;",
+ { "nativeCopy", "(JIZ)Landroid/graphics/Bitmap;",
(void*)Bitmap_copy },
- { "nativeDestructor", "(I)V", (void*)Bitmap_destructor },
- { "nativeRecycle", "(I)Z", (void*)Bitmap_recycle },
- { "nativeReconfigure", "(IIIII)V", (void*)Bitmap_reconfigure },
- { "nativeCompress", "(IIILjava/io/OutputStream;[B)Z",
+ { "nativeDestructor", "(J)V", (void*)Bitmap_destructor },
+ { "nativeRecycle", "(J)Z", (void*)Bitmap_recycle },
+ { "nativeReconfigure", "(JIIII)V", (void*)Bitmap_reconfigure },
+ { "nativeCompress", "(JIILjava/io/OutputStream;[B)Z",
(void*)Bitmap_compress },
- { "nativeErase", "(II)V", (void*)Bitmap_erase },
- { "nativeRowBytes", "(I)I", (void*)Bitmap_rowBytes },
- { "nativeConfig", "(I)I", (void*)Bitmap_config },
- { "nativeHasAlpha", "(I)Z", (void*)Bitmap_hasAlpha },
- { "nativeSetAlphaAndPremultiplied", "(IZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},
- { "nativeHasMipMap", "(I)Z", (void*)Bitmap_hasMipMap },
- { "nativeSetHasMipMap", "(IZ)V", (void*)Bitmap_setHasMipMap },
+ { "nativeErase", "(JI)V", (void*)Bitmap_erase },
+ { "nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes },
+ { "nativeConfig", "(J)I", (void*)Bitmap_config },
+ { "nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha },
+ { "nativeSetAlphaAndPremultiplied", "(JZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},
+ { "nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap },
+ { "nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap },
{ "nativeCreateFromParcel",
"(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",
(void*)Bitmap_createFromParcel },
- { "nativeWriteToParcel", "(IZILandroid/os/Parcel;)Z",
+ { "nativeWriteToParcel", "(JZILandroid/os/Parcel;)Z",
(void*)Bitmap_writeToParcel },
- { "nativeExtractAlpha", "(II[I)Landroid/graphics/Bitmap;",
+ { "nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;",
(void*)Bitmap_extractAlpha },
- { "nativeGenerationId", "(I)I", (void*)Bitmap_getGenerationId },
- { "nativeGetPixel", "(IIIZ)I", (void*)Bitmap_getPixel },
- { "nativeGetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_getPixels },
- { "nativeSetPixel", "(IIIIZ)V", (void*)Bitmap_setPixel },
- { "nativeSetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_setPixels },
- { "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V",
+ { "nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId },
+ { "nativeGetPixel", "(JIIZ)I", (void*)Bitmap_getPixel },
+ { "nativeGetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_getPixels },
+ { "nativeSetPixel", "(JIIIZ)V", (void*)Bitmap_setPixel },
+ { "nativeSetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_setPixels },
+ { "nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V",
(void*)Bitmap_copyPixelsToBuffer },
- { "nativeCopyPixelsFromBuffer", "(ILjava/nio/Buffer;)V",
+ { "nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V",
(void*)Bitmap_copyPixelsFromBuffer },
- { "nativeSameAs", "(II)Z", (void*)Bitmap_sameAs },
- { "nativePrepareToDraw", "(I)V", (void*)Bitmap_prepareToDraw },
+ { "nativeSameAs", "(JJ)Z", (void*)Bitmap_sameAs },
+ { "nativePrepareToDraw", "(J)V", (void*)Bitmap_prepareToDraw },
};
#define kClassPathName "android/graphics/Bitmap"
diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp index 709de5c..e8feacb 100644 --- a/core/jni/android/graphics/BitmapFactory.cpp +++ b/core/jni/android/graphics/BitmapFactory.cpp @@ -286,7 +286,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding SkBitmap* outputBitmap = NULL; unsigned int existingBufferSize = 0; if (javaBitmap != NULL) { - outputBitmap = (SkBitmap*) env->GetIntField(javaBitmap, gBitmap_nativeBitmapFieldID); + outputBitmap = (SkBitmap*) env->GetLongField(javaBitmap, gBitmap_nativeBitmapFieldID); if (outputBitmap->isImmutable()) { ALOGW("Unable to reuse an immutable bitmap as an image decoder target."); javaBitmap = NULL; @@ -566,7 +566,7 @@ static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fi return doDecode(env, stream, padding, bitmapFactoryOptions, isPurgeable); } -static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset, +static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jlong native_asset, jobject padding, jobject options) { SkStreamRewindable* stream; @@ -591,7 +591,7 @@ static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset, } static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray, - int offset, int length, jobject options) { + jint offset, jint length, jobject options) { /* If optionsShareable() we could decide to just wrap the java array and share it, but that means adding a globalref to the java array object @@ -628,7 +628,7 @@ static JNINativeMethod gMethods[] = { }, { "nativeDecodeAsset", - "(ILandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", (void*)nativeDecodeAsset }, @@ -681,7 +681,7 @@ int register_android_graphics_BitmapFactory(JNIEnv* env) { jclass bitmap_class = env->FindClass("android/graphics/Bitmap"); SkASSERT(bitmap_class); - gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "I"); + gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "J"); gBitmap_layoutBoundsFieldID = getFieldIDCheck(env, bitmap_class, "mLayoutBounds", "[I"); int ret = AndroidRuntime::registerNativeMethods(env, "android/graphics/BitmapFactory$Options", diff --git a/core/jni/android/graphics/BitmapRegionDecoder.cpp b/core/jni/android/graphics/BitmapRegionDecoder.cpp index 1412a0e..0d67b07 100644 --- a/core/jni/android/graphics/BitmapRegionDecoder.cpp +++ b/core/jni/android/graphics/BitmapRegionDecoder.cpp @@ -101,7 +101,7 @@ static jobject createBitmapRegionDecoder(JNIEnv* env, SkStreamRewindable* stream } static jobject nativeNewInstanceFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray, - int offset, int length, jboolean isShareable) { + jint offset, jint length, jboolean isShareable) { /* If isShareable we could decide to just wrap the java array and share it, but that means adding a globalref to the java array object For now we just always copy the array's data if isShareable. @@ -150,7 +150,7 @@ static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz, } static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz, - jint native_asset, // Asset + jlong native_asset, // Asset jboolean isShareable) { Asset* asset = reinterpret_cast<Asset*>(native_asset); SkAutoTUnref<SkMemoryStream> stream(CopyAssetToStream(asset)); @@ -169,8 +169,9 @@ static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz, * purgeable not supported * reportSizeToVM not supported */ -static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd, - int start_x, int start_y, int width, int height, jobject options) { +static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, + jint start_x, jint start_y, jint width, jint height, jobject options) { + SkBitmapRegionDecoder *brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle); jobject tileBitmap = NULL; SkImageDecoder *decoder = brd->getDecoder(); int sampleSize = 1; @@ -255,15 +256,18 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkBitmapRegionDecoder *b return GraphicsJNI::createBitmap(env, bitmap, buff, bitmapCreateFlags, NULL, NULL, -1); } -static int nativeGetHeight(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) { - return brd->getHeight(); +static jint nativeGetHeight(JNIEnv* env, jobject, jlong brdHandle) { + SkBitmapRegionDecoder *brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle); + return static_cast<jint>(brd->getHeight()); } -static int nativeGetWidth(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) { - return brd->getWidth(); +static jint nativeGetWidth(JNIEnv* env, jobject, jlong brdHandle) { + SkBitmapRegionDecoder *brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle); + return static_cast<jint>(brd->getWidth()); } -static void nativeClean(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) { +static void nativeClean(JNIEnv* env, jobject, jlong brdHandle) { + SkBitmapRegionDecoder *brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle); delete brd; } @@ -273,14 +277,14 @@ static void nativeClean(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) { static JNINativeMethod gBitmapRegionDecoderMethods[] = { { "nativeDecodeRegion", - "(IIIIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + "(JIIIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", (void*)nativeDecodeRegion}, - { "nativeGetHeight", "(I)I", (void*)nativeGetHeight}, + { "nativeGetHeight", "(J)I", (void*)nativeGetHeight}, - { "nativeGetWidth", "(I)I", (void*)nativeGetWidth}, + { "nativeGetWidth", "(J)I", (void*)nativeGetWidth}, - { "nativeClean", "(I)V", (void*)nativeClean}, + { "nativeClean", "(J)V", (void*)nativeClean}, { "nativeNewInstance", "([BIIZ)Landroid/graphics/BitmapRegionDecoder;", @@ -298,7 +302,7 @@ static JNINativeMethod gBitmapRegionDecoderMethods[] = { }, { "nativeNewInstance", - "(IZ)Landroid/graphics/BitmapRegionDecoder;", + "(JZ)Landroid/graphics/BitmapRegionDecoder;", (void*)nativeNewInstanceFromAsset }, }; diff --git a/core/jni/android/graphics/Camera.cpp b/core/jni/android/graphics/Camera.cpp index 5176d9a..54d448e 100644 --- a/core/jni/android/graphics/Camera.cpp +++ b/core/jni/android/graphics/Camera.cpp @@ -7,84 +7,102 @@ static jfieldID gNativeInstanceFieldID; static void Camera_constructor(JNIEnv* env, jobject obj) { Sk3DView* view = new Sk3DView; - env->SetIntField(obj, gNativeInstanceFieldID, (int)view); + env->SetLongField(obj, gNativeInstanceFieldID, reinterpret_cast<jlong>(view)); } static void Camera_destructor(JNIEnv* env, jobject obj) { - delete (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* view = reinterpret_cast<Sk3DView*>(viewHandle); + delete view; } static void Camera_save(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->save(); } static void Camera_restore(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->restore(); } static void Camera_translate(JNIEnv* env, jobject obj, - float dx, float dy, float dz) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jfloat dx, jfloat dy, jfloat dz) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz)); } -static void Camera_rotateX(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateX(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateX(SkFloatToScalar(degrees)); } -static void Camera_rotateY(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateY(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateY(SkFloatToScalar(degrees)); } -static void Camera_rotateZ(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateZ(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateZ(SkFloatToScalar(degrees)); } static void Camera_rotate(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateX(SkFloatToScalar(x)); v->rotateY(SkFloatToScalar(y)); v->rotateZ(SkFloatToScalar(z)); } static void Camera_setLocation(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->setCameraLocation(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z)); } static jfloat Camera_getLocationX(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationX()); } static jfloat Camera_getLocationY(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationY()); } static jfloat Camera_getLocationZ(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationZ()); } -static void Camera_getMatrix(JNIEnv* env, jobject obj, int native_matrix) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); - v->getMatrix((SkMatrix*)native_matrix); +static void Camera_getMatrix(JNIEnv* env, jobject obj, jlong matrixHandle) { + SkMatrix* native_matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); + v->getMatrix(native_matrix); } -static void Camera_applyToCanvas(JNIEnv* env, jobject obj, int native_canvas) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_applyToCanvas(JNIEnv* env, jobject obj, jlong canvasHandle) { + SkCanvas* native_canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->applyToCanvas((SkCanvas*)native_canvas); } -static float Camera_dotWithNormal(JNIEnv* env, jobject obj, - float x, float y, float z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static jfloat Camera_dotWithNormal(JNIEnv* env, jobject obj, + jfloat x, jfloat y, jfloat z) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z)); return SkScalarToFloat(dot); @@ -111,8 +129,8 @@ static JNINativeMethod gCameraMethods[] = { { "getLocationX", "()F", (void*)Camera_getLocationX }, { "getLocationY", "()F", (void*)Camera_getLocationY }, { "getLocationZ", "()F", (void*)Camera_getLocationZ }, - { "nativeGetMatrix", "(I)V", (void*)Camera_getMatrix }, - { "nativeApplyToCanvas", "(I)V", (void*)Camera_applyToCanvas }, + { "nativeGetMatrix", "(J)V", (void*)Camera_getMatrix }, + { "nativeApplyToCanvas", "(J)V", (void*)Camera_applyToCanvas }, { "dotWithNormal", "(FFF)F", (void*)Camera_dotWithNormal } }; @@ -121,7 +139,7 @@ int register_android_graphics_Camera(JNIEnv* env) { if (clazz == 0) { return -1; } - gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "I"); + gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "J"); if (gNativeInstanceFieldID == 0) { return -1; } diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp index edf3b4a..f6ab39c 100644 --- a/core/jni/android/graphics/Canvas.cpp +++ b/core/jni/android/graphics/Canvas.cpp @@ -38,13 +38,13 @@ static uint32_t get_thread_msec() { #if defined(HAVE_POSIX_CLOCKS) struct timespec tm; - + clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm); - + return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000; #else struct timeval tv; - + gettimeofday(&tv, NULL); return tv.tv_sec * 1000LL + tv.tv_usec / 1000; #endif @@ -70,23 +70,27 @@ private: class SkCanvasGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) { + static void finalizer(JNIEnv* env, jobject clazz, jlong canvasHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->unref(); } - static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) { + static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) { + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); if (bitmap) { - return new SkCanvas(*bitmap); + return reinterpret_cast<jlong>(new SkCanvas(*bitmap)); } else { // Create an empty bitmap device to prevent callers from crashing // if they attempt to draw into this canvas. SkBitmap emptyBitmap; - return new SkCanvas(emptyBitmap); + return reinterpret_cast<jlong>(new SkCanvas(emptyBitmap)); } } - + static void copyCanvasState(JNIEnv* env, jobject clazz, - SkCanvas* srcCanvas, SkCanvas* dstCanvas) { + jlong srcCanvasHandle, jlong dstCanvasHandle) { + SkCanvas* srcCanvas = reinterpret_cast<SkCanvas*>(srcCanvasHandle); + SkCanvas* dstCanvas = reinterpret_cast<SkCanvas*>(dstCanvasHandle); if (srcCanvas && dstCanvas) { dstCanvas->setMatrix(srcCanvas->getTotalMatrix()); if (NULL != srcCanvas->getDevice() && NULL != dstCanvas->getDevice()) { @@ -110,73 +114,89 @@ public: static jboolean isOpaque(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).isOpaque(); + bool result = canvas->getDevice()->accessBitmap(false).isOpaque(); + return result ? JNI_TRUE : JNI_FALSE; } - - static int getWidth(JNIEnv* env, jobject jcanvas) { + + static jint getWidth(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).width(); + int width = canvas->getDevice()->accessBitmap(false).width(); + return static_cast<jint>(width); } - - static int getHeight(JNIEnv* env, jobject jcanvas) { + + static jint getHeight(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).height(); + int height = canvas->getDevice()->accessBitmap(false).height(); + return static_cast<jint>(height); } - static int saveAll(JNIEnv* env, jobject jcanvas) { + static jint saveAll(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); + return static_cast<jint>(result); } - - static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) { + + static jint save(JNIEnv* env, jobject jcanvas, jint flagsHandle) { + SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle); NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); + return static_cast<jint>(result); } - - static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds, - SkPaint* paint, int flags) { + + static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds, + jlong paintHandle, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } - return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags); + return canvas->saveLayer(bounds_, paint, static_cast<SkCanvas::SaveFlags>(flags)); } - - static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas, + + static jint saveLayer4F(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, jfloat r, jfloat b, - SkPaint* paint, int flags) { + jlong paintHandle, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); - return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayer(&bounds, paint, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - - static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas, - jobject bounds, int alpha, int flags) { + + static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, + jobject bounds, jint alpha, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } - return canvas->saveLayerAlpha(bounds_, alpha, - (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayerAlpha(bounds_, alpha, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - - static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas, + + static jint saveLayerAlpha4F(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, jfloat r, jfloat b, - int alpha, int flags) { + jint alpha, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); - return canvas->saveLayerAlpha(&bounds, alpha, - (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayerAlpha(&bounds, alpha, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - + static void restore(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); @@ -186,13 +206,14 @@ public: } canvas->restore(); } - - static int getSaveCount(JNIEnv* env, jobject jcanvas) { + + static jint getSaveCount(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); + return static_cast<jint>(result); } - - static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) { + + static void restoreToCount(JNIEnv* env, jobject jcanvas, jint restoreCount) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); if (restoreCount < 1) { @@ -201,48 +222,52 @@ public: } canvas->restoreToCount(restoreCount); } - + static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_); } - + static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_); } - + static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar degrees_ = SkFloatToScalar(degrees); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_); } - + static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_); } - - static void concat(JNIEnv* env, jobject, SkCanvas* canvas, - const SkMatrix* matrix) { + + static void concat(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); canvas->concat(*matrix); } - - static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas, - const SkMatrix* matrix) { + + static void setMatrix(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); if (NULL == matrix) { canvas->resetMatrix(); } else { canvas->setMatrix(*matrix); } } - + static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left, jfloat top, jfloat right, jfloat bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); @@ -250,122 +275,150 @@ public: r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); - return c->clipRect(r); + bool result = c->clipRect(r); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left, jint top, jint right, jint bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkRect r; r.set(SkIntToScalar(left), SkIntToScalar(top), SkIntToScalar(right), SkIntToScalar(bottom)); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); + bool result = GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rectf); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; - return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); + bool result = c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rect); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; - return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); + bool result = c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); + return result ? JNI_TRUE : JNI_FALSE; + } - - static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas, - float left, float top, float right, float bottom, - int op) { + + static jboolean clipRect(JNIEnv* env, jobject, jlong canvasHandle, + jfloat left, jfloat top, jfloat right, jfloat bottom, + jint op) { SkRect rect; + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); rect.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); - return canvas->clipRect(rect, (SkRegion::Op)op); + bool result = canvas->clipRect(rect, static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; + } - - static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas, - SkPath* path, int op) { - return canvas->clipPath(*path, (SkRegion::Op)op); + + static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle, + jlong pathHandle, jint op) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + bool result = canvas->clipPath(*reinterpret_cast<SkPath*>(pathHandle), + static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas, - SkRegion* deviceRgn, int op) { - return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op); + + static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle, + jlong deviceRgnHandle, jint op) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkRegion* deviceRgn = reinterpret_cast<SkRegion*>(deviceRgnHandle); + bool result = canvas->clipRegion(*deviceRgn, static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; } - - static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas, - SkDrawFilter* filter) { - canvas->setDrawFilter(filter); + + static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, + jlong filterHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + canvas->setDrawFilter(reinterpret_cast<SkDrawFilter*>(filterHandle)); } - - static jboolean quickReject__RectF(JNIEnv* env, jobject, SkCanvas* canvas, + + static jboolean quickReject__RectF(JNIEnv* env, jobject, jlong canvasHandle, jobject rect) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); return canvas->quickReject(rect_); } - static jboolean quickReject__Path(JNIEnv* env, jobject, SkCanvas* canvas, - SkPath* path) { - return canvas->quickReject(*path); + static jboolean quickReject__Path(JNIEnv* env, jobject, jlong canvasHandle, + jlong pathHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + bool result = canvas->quickReject(*reinterpret_cast<SkPath*>(pathHandle)); + return result ? JNI_TRUE : JNI_FALSE; } - static jboolean quickReject__FFFF(JNIEnv* env, jobject, SkCanvas* canvas, + static jboolean quickReject__FFFF(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, jfloat right, jfloat bottom) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect r; r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); - return canvas->quickReject(r); + bool result = canvas->quickReject(r); + return result ? JNI_TRUE : JNI_FALSE; } - - static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRGB(JNIEnv* env, jobject, jlong canvasHandle, jint r, jint g, jint b) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawARGB(0xFF, r, g, b); } - - static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawARGB(JNIEnv* env, jobject, jlong canvasHandle, jint a, jint r, jint g, jint b) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawARGB(a, r, g, b); } - - static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawColor__I(JNIEnv* env, jobject, jlong canvasHandle, jint color) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawColor(color); } - - static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas, - jint color, SkPorterDuff::Mode mode) { + + static void drawColor__II(JNIEnv* env, jobject, jlong canvasHandle, + jint color, jint modeHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); canvas->drawColor(color, SkPorterDuff::ToXfermodeMode(mode)); } - - static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas, - SkPaint* paint) { + + static void drawPaint(JNIEnv* env, jobject, jlong canvasHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawPaint(*paint); } - + static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint, - SkCanvas::PointMode mode) { + jint modeHandle) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jptsArray); NPE_CHECK_RETURN_VOID(env, jpaint); + SkCanvas::PointMode mode = static_cast<SkCanvas::PointMode>(modeHandle); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); - + AutoJavaFloatArray autoPts(env, jptsArray); float* floats = autoPts.ptr(); const int length = autoPts.length(); - + if ((offset | count) < 0 || offset + count > length) { doThrowAIOOBE(env); return; } - + // now convert the floats into SkPoints count >>= 1; // now it is the number of points SkAutoSTMalloc<32, SkPoint> storage(count); @@ -374,98 +427,118 @@ public: for (int i = 0; i < count; i++) { pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1])); src += 2; - } + } canvas->drawPoints(mode, count, pts, paint); } - + static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kPoints_PointMode); } - + static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kLines_PointMode); } - - static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y, + + static void drawPoint(JNIEnv* env, jobject jcanvas, jfloat x, jfloat y, jobject jpaint) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jpaint); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); - + canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint); } - - static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, jfloat startX, jfloat startY, jfloat stopX, - jfloat stopY, SkPaint* paint) { + jfloat stopY, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY), SkFloatToScalar(stopX), SkFloatToScalar(stopY), *paint); } - - static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas, - jobject rect, SkPaint* paint) { + + static void drawRect__RectFPaint(JNIEnv* env, jobject, jlong canvasHandle, + jobject rect, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); canvas->drawRect(rect_, *paint); } - - static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRect__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, jfloat right, - jfloat bottom, SkPaint* paint) { + jfloat bottom, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); SkScalar right_ = SkFloatToScalar(right); SkScalar bottom_ = SkFloatToScalar(bottom); canvas->drawRectCoords(left_, top_, right_, bottom_, *paint); } - - static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, - SkPaint* paint) { + + static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jobject joval, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawOval(oval, *paint); } - - static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx, - jfloat cy, jfloat radius, SkPaint* paint) { + + static void drawCircle(JNIEnv* env, jobject, jlong canvasHandle, jfloat cx, + jfloat cy, jfloat radius, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy), SkFloatToScalar(radius), *paint); } - - static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, + + static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jobject joval, jfloat startAngle, jfloat sweepAngle, - jboolean useCenter, SkPaint* paint) { + jboolean useCenter, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawArc(oval, SkFloatToScalar(startAngle), SkFloatToScalar(sweepAngle), useCenter, *paint); } - - static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jrect, jfloat rx, jfloat ry, - SkPaint* paint) { + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect rect; GraphicsJNI::jrectf_to_rect(env, jrect, &rect); canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry), *paint); } - - static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, - SkPaint* paint) { + + static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawPath(*path, *paint); } - + static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas, - SkCanvas* canvas, SkBitmap* bitmap, + jlong canvasHandle, jlong bitmapHandle, jfloat left, jfloat top, - SkPaint* paint, jint canvasDensity, + jlong paintHandle, jint canvasDensity, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); @@ -508,7 +581,7 @@ public: GraphicsJNI::jrect_to_irect(env, srcIRect, &src); srcPtr = &src; } - + if (screenDensity != 0 && screenDensity != bitmapDensity) { SkPaint filteredPaint; if (paint) { @@ -521,31 +594,39 @@ public: } } - static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas, - SkBitmap* bitmap, jobject srcIRect, - jobject dstRectF, SkPaint* paint, + static void drawBitmapRF(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jobject srcIRect, + jobject dstRectF, jlong paintHandle, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect dst; GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } - - static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas, - SkBitmap* bitmap, jobject srcIRect, - jobject dstRect, SkPaint* paint, + + static void drawBitmapRR(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jobject srcIRect, + jobject dstRect, jlong paintHandle, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect dst; GraphicsJNI::jrect_to_rect(env, dstRect, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } - - static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas, - jintArray jcolors, int offset, int stride, - jfloat x, jfloat y, int width, int height, - jboolean hasAlpha, SkPaint* paint) + + static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle, + jintArray jcolors, jint offset, jint stride, + jfloat x, jfloat y, jint width, jint height, + jboolean hasAlpha, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkBitmap bitmap; bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, width, height); @@ -561,24 +642,31 @@ public: canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y), paint); } - - static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas, - const SkBitmap* bitmap, const SkMatrix* matrix, - const SkPaint* paint) { + + static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jlong matrixHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawBitmapMatrix(*bitmap, *matrix, paint); } - - static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas, - const SkBitmap* bitmap, int meshWidth, int meshHeight, - jfloatArray jverts, int vertIndex, jintArray jcolors, - int colorIndex, const SkPaint* paint) { + + static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jint meshWidth, jint meshHeight, + jfloatArray jverts, jint vertIndex, jintArray jcolors, + jint colorIndex, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const int ptCount = (meshWidth + 1) * (meshHeight + 1); const int indexCount = meshWidth * meshHeight * 6; AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); - + /* Our temp storage holds 2 or 3 arrays. texture points [ptCount * sizeof(SkPoint)] optionally vertex points [ptCount * sizeof(SkPoint)] if we need a @@ -617,7 +705,7 @@ public: const SkScalar h = SkIntToScalar(bitmap->height()); const SkScalar dx = w / meshWidth; const SkScalar dy = h / meshHeight; - + SkPoint* texsPtr = texs; SkScalar y = 0; for (int i = 0; i <= meshHeight; i++) { @@ -636,7 +724,7 @@ public: } SkASSERT(texsPtr - texs == ptCount); } - + // cons up indices { uint16_t* indexPtr = indices; @@ -684,13 +772,16 @@ public: indexCount, tmpPaint); } - static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas, - SkCanvas::VertexMode mode, int vertexCount, - jfloatArray jverts, int vertIndex, - jfloatArray jtexs, int texIndex, - jintArray jcolors, int colorIndex, - jshortArray jindices, int indexIndex, - int indexCount, const SkPaint* paint) { + static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle, + jint modeHandle, jint vertexCount, + jfloatArray jverts, jint vertIndex, + jfloatArray jtexs, jint texIndex, + jintArray jcolors, jint colorIndex, + jshortArray jindices, jint indexIndex, + jint indexCount, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkCanvas::VertexMode mode = static_cast<SkCanvas::VertexMode>(modeHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount); AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount); @@ -712,7 +803,7 @@ public: count += ptCount; // += for texs } SkAutoMalloc storage(count * sizeof(SkPoint)); - verts = (SkPoint*)storage.get(); + verts = (SkPoint*)storage.get(); const float* src = vertA.ptr() + vertIndex; for (int i = 0; i < ptCount; i++) { verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); @@ -742,18 +833,22 @@ public: } - static void drawText___CIIFFIPaint(JNIEnv* env, jobject, SkCanvas* canvas, - jcharArray text, int index, int count, - jfloat x, jfloat y, int flags, SkPaint* paint) { + static void drawText___CIIFFIPaint(JNIEnv* env, jobject, jlong canvasHandle, + jcharArray text, jint index, jint count, + jfloat x, jfloat y, jint flags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); drawTextWithGlyphs(canvas, textArray + index, 0, count, x, y, flags, paint); env->ReleaseCharArrayElements(text, textArray, JNI_ABORT); } static void drawText__StringIIFFIPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, - int start, int end, - jfloat x, jfloat y, int flags, SkPaint* paint) { + jlong canvasHandle, jstring text, + jint start, jint end, + jfloat x, jfloat y, jint flags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); drawTextWithGlyphs(canvas, textArray, start, end, x, y, flags, paint); env->ReleaseStringChars(text, textArray); @@ -843,9 +938,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextRun___CIIIIFFIPaint( - JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index, - int count, int contextIndex, int contextCount, - jfloat x, jfloat y, int dirFlags, SkPaint* paint) { + JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index, + jint count, jint contextIndex, jint contextCount, + jfloat x, jfloat y, jint dirFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* chars = env->GetCharArrayElements(text, NULL); drawTextWithGlyphs(canvas, chars + contextIndex, index - contextIndex, @@ -854,9 +951,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextRun__StringIIIIFFIPaint( - JNIEnv* env, jobject obj, SkCanvas* canvas, jstring text, jint start, + JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, - jfloat x, jfloat y, jint dirFlags, SkPaint* paint) { + jfloat x, jfloat y, jint dirFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jint count = end - start; jint contextCount = contextEnd - contextStart; @@ -866,9 +965,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l env->ReleaseStringChars(text, chars); } - static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas, - jcharArray text, int index, int count, - jfloatArray pos, SkPaint* paint) { + static void drawPosText___CII_FPaint(JNIEnv* env, jobject, jlong canvasHandle, + jcharArray text, jint index, jint count, + jfloatArray pos, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL; jsize textCount = text ? env->GetArrayLength(text) : NULL; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; @@ -879,12 +980,12 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); } - + SkPaint::TextEncoding encoding = paint->getTextEncoding(); paint->setTextEncoding(SkPaint::kUTF16_TextEncoding); canvas->drawPosText(textArray + index, count << 1, posPtr, *paint); paint->setTextEncoding(encoding); - + if (text) { env->ReleaseCharArrayElements(text, textArray, 0); } @@ -895,9 +996,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawPosText__String_FPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, + jlong canvasHandle, jstring text, jfloatArray pos, - SkPaint* paint) { + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const void* text_ = text ? env->GetStringChars(text, NULL) : NULL; int byteLength = text ? env->GetStringLength(text) : 0; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; @@ -924,8 +1027,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jcharArray text, int index, int count, - SkPath* path, jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) { + jlong canvasHandle, jcharArray text, jint index, jint count, + jlong pathHandle, jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); TextLayout::drawTextOnPath(paint, textArray + index, count, bidiFlags, hOffset, vOffset, @@ -934,8 +1040,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, SkPath* path, - jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) { + jlong canvasHandle, jstring text, jlong pathHandle, + jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* text_ = env->GetStringChars(text, NULL); int count = env->GetStringLength(text); TextLayout::drawTextOnPath(paint, text_, count, bidiFlags, hOffset, vOffset, @@ -970,8 +1079,9 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l return true; } - static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas, - jobject bounds) { + static jboolean getClipBounds(JNIEnv* env, jobject, jlong canvasHandle, + jobject bounds) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect r; SkIRect ir; bool result = getHardClipBounds(canvas, &r); @@ -982,30 +1092,32 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l r.round(&ir); (void)GraphicsJNI::irect_to_jrect(ir, env, bounds); - return result; + return result ? JNI_TRUE : JNI_FALSE; } - static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas, - SkMatrix* matrix) { + static void getCTM(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); *matrix = canvas->getTotalMatrix(); } }; static JNINativeMethod gCanvasMethods[] = { - {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer}, - {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster}, - {"copyNativeCanvasState","(II)V", (void*) SkCanvasGlue::copyCanvasState}, + {"finalizer", "(J)V", (void*) SkCanvasGlue::finalizer}, + {"initRaster","(J)J", (void*) SkCanvasGlue::initRaster}, + {"copyNativeCanvasState","(JJ)V", (void*) SkCanvasGlue::copyCanvasState}, {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque}, {"getWidth","()I", (void*) SkCanvasGlue::getWidth}, {"getHeight","()I", (void*) SkCanvasGlue::getHeight}, {"save","()I", (void*) SkCanvasGlue::saveAll}, {"save","(I)I", (void*) SkCanvasGlue::save}, - {"native_saveLayer","(ILandroid/graphics/RectF;II)I", + {"native_saveLayer","(JLandroid/graphics/RectF;JI)I", (void*) SkCanvasGlue::saveLayer}, - {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F}, - {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I", + {"native_saveLayer","(JFFFFJI)I", (void*) SkCanvasGlue::saveLayer4F}, + {"native_saveLayerAlpha","(JLandroid/graphics/RectF;II)I", (void*) SkCanvasGlue::saveLayerAlpha}, - {"native_saveLayerAlpha","(IFFFFII)I", + {"native_saveLayerAlpha","(JFFFFII)I", (void*) SkCanvasGlue::saveLayerAlpha4F}, {"restore","()V", (void*) SkCanvasGlue::restore}, {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount}, @@ -1014,77 +1126,77 @@ static JNINativeMethod gCanvasMethods[] = { {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF}, {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F}, {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF}, - {"native_concat","(II)V", (void*) SkCanvasGlue::concat}, - {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix}, + {"native_concat","(JJ)V", (void*) SkCanvasGlue::concat}, + {"native_setMatrix","(JJ)V", (void*) SkCanvasGlue::setMatrix}, {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF}, {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII}, {"clipRect","(Landroid/graphics/RectF;)Z", (void*) SkCanvasGlue::clipRect_RectF}, {"clipRect","(Landroid/graphics/Rect;)Z", (void*) SkCanvasGlue::clipRect_Rect}, - {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect}, - {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath}, - {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion}, - {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter}, - {"native_getClipBounds","(ILandroid/graphics/Rect;)Z", + {"native_clipRect","(JFFFFI)Z", (void*) SkCanvasGlue::clipRect}, + {"native_clipPath","(JJI)Z", (void*) SkCanvasGlue::clipPath}, + {"native_clipRegion","(JJI)Z", (void*) SkCanvasGlue::clipRegion}, + {"nativeSetDrawFilter", "(JJ)V", (void*) SkCanvasGlue::setDrawFilter}, + {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) SkCanvasGlue::getClipBounds}, - {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM}, - {"native_quickReject","(ILandroid/graphics/RectF;)Z", + {"native_getCTM", "(JJ)V", (void*)SkCanvasGlue::getCTM}, + {"native_quickReject","(JLandroid/graphics/RectF;)Z", (void*) SkCanvasGlue::quickReject__RectF}, - {"native_quickReject","(II)Z", (void*) SkCanvasGlue::quickReject__Path}, - {"native_quickReject","(IFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF}, - {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB}, - {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB}, - {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I}, - {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II}, - {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint}, + {"native_quickReject","(JJ)Z", (void*) SkCanvasGlue::quickReject__Path}, + {"native_quickReject","(JFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF}, + {"native_drawRGB","(JIII)V", (void*) SkCanvasGlue::drawRGB}, + {"native_drawARGB","(JIIII)V", (void*) SkCanvasGlue::drawARGB}, + {"native_drawColor","(JI)V", (void*) SkCanvasGlue::drawColor__I}, + {"native_drawColor","(JII)V", (void*) SkCanvasGlue::drawColor__II}, + {"native_drawPaint","(JJ)V", (void*) SkCanvasGlue::drawPaint}, {"drawPoint", "(FFLandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoint}, {"drawPoints", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoints}, {"drawLines", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawLines}, - {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, - {"native_drawRect","(ILandroid/graphics/RectF;I)V", + {"native_drawLine","(JFFFFJ)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, + {"native_drawRect","(JLandroid/graphics/RectF;J)V", (void*) SkCanvasGlue::drawRect__RectFPaint}, - {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, - {"native_drawOval","(ILandroid/graphics/RectF;I)V", + {"native_drawRect","(JFFFFJ)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, + {"native_drawOval","(JLandroid/graphics/RectF;J)V", (void*) SkCanvasGlue::drawOval}, - {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle}, - {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V", + {"native_drawCircle","(JFFFJ)V", (void*) SkCanvasGlue::drawCircle}, + {"native_drawArc","(JLandroid/graphics/RectF;FFZJ)V", (void*) SkCanvasGlue::drawArc}, - {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V", + {"native_drawRoundRect","(JLandroid/graphics/RectF;FFJ)V", (void*) SkCanvasGlue::drawRoundRect}, - {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath}, - {"native_drawBitmap","(IIFFIIII)V", + {"native_drawPath","(JJJ)V", (void*) SkCanvasGlue::drawPath}, + {"native_drawBitmap","(JJFFJIII)V", (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint}, - {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;III)V", + {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/RectF;JII)V", (void*) SkCanvasGlue::drawBitmapRF}, - {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;III)V", + {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/Rect;JII)V", (void*) SkCanvasGlue::drawBitmapRR}, - {"native_drawBitmap", "(I[IIIFFIIZI)V", + {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)SkCanvasGlue::drawBitmapArray}, - {"nativeDrawBitmapMatrix", "(IIII)V", + {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)SkCanvasGlue::drawBitmapMatrix}, - {"nativeDrawBitmapMesh", "(IIII[FI[III)V", + {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)SkCanvasGlue::drawBitmapMesh}, - {"nativeDrawVertices", "(III[FI[FI[II[SIII)V", + {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)SkCanvasGlue::drawVertices}, - {"native_drawText","(I[CIIFFII)V", + {"native_drawText","(J[CIIFFIJ)V", (void*) SkCanvasGlue::drawText___CIIFFIPaint}, - {"native_drawText","(ILjava/lang/String;IIFFII)V", + {"native_drawText","(JLjava/lang/String;IIFFIJ)V", (void*) SkCanvasGlue::drawText__StringIIFFIPaint}, - {"native_drawTextRun","(I[CIIIIFFII)V", + {"native_drawTextRun","(J[CIIIIFFIJ)V", (void*) SkCanvasGlue::drawTextRun___CIIIIFFIPaint}, - {"native_drawTextRun","(ILjava/lang/String;IIIIFFII)V", + {"native_drawTextRun","(JLjava/lang/String;IIIIFFIJ)V", (void*) SkCanvasGlue::drawTextRun__StringIIIIFFIPaint}, - {"native_drawPosText","(I[CII[FI)V", + {"native_drawPosText","(J[CII[FJ)V", (void*) SkCanvasGlue::drawPosText___CII_FPaint}, - {"native_drawPosText","(ILjava/lang/String;[FI)V", + {"native_drawPosText","(JLjava/lang/String;[FJ)V", (void*) SkCanvasGlue::drawPosText__String_FPaint}, - {"native_drawTextOnPath","(I[CIIIFFII)V", + {"native_drawTextOnPath","(J[CIIJFFIJ)V", (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint}, - {"native_drawTextOnPath","(ILjava/lang/String;IFFII)V", + {"native_drawTextOnPath","(JLjava/lang/String;JFFIJ)V", (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint}, {"freeCaches", "()V", (void*) SkCanvasGlue::freeCaches}, @@ -1105,7 +1217,7 @@ int register_android_graphics_Canvas(JNIEnv* env) { int result; REG(env, "android/graphics/Canvas", gCanvasMethods); - + return result; } diff --git a/core/jni/android/graphics/ColorFilter.cpp b/core/jni/android/graphics/ColorFilter.cpp index dd1177b..f9cefd6 100644 --- a/core/jni/android/graphics/ColorFilter.cpp +++ b/core/jni/android/graphics/ColorFilter.cpp @@ -32,7 +32,9 @@ using namespace uirenderer; class SkColorFilterGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkColorFilter* obj, SkiaColorFilter* f) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong fHandle) { + SkColorFilter* obj = reinterpret_cast<SkColorFilter *>(objHandle); + SkiaColorFilter* f = reinterpret_cast<SkiaColorFilter *>(fHandle); SkSafeUnref(obj); // f == NULL when not !USE_OPENGL_RENDERER, so no need to delete outside the ifdef #ifdef USE_OPENGL_RENDERER @@ -44,26 +46,30 @@ public: #endif } - static SkiaColorFilter* glCreatePorterDuffFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, - jint srcColor, SkPorterDuff::Mode mode) { + static jlong glCreatePorterDuffFilter(JNIEnv* env, jobject, jlong skFilterHandle, + jint srcColor, jint modeHandle) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); #ifdef USE_OPENGL_RENDERER - return new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode)); + return reinterpret_cast<jlong>(new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode))); #else return NULL; #endif } - static SkiaColorFilter* glCreateLightingFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, + static jlong glCreateLightingFilter(JNIEnv* env, jobject, jlong skFilterHandle, jint mul, jint add) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); #ifdef USE_OPENGL_RENDERER - return new SkiaLightingFilter(skFilter, mul, add); + return reinterpret_cast<jlong>(new SkiaLightingFilter(skFilter, mul, add)); #else return NULL; #endif } - static SkiaColorFilter* glCreateColorMatrixFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, + static jlong glCreateColorMatrixFilter(JNIEnv* env, jobject, jlong skFilterHandle, jfloatArray jarray) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); #ifdef USE_OPENGL_RENDERER AutoJavaFloatArray autoArray(env, jarray, 20); const float* src = autoArray.ptr(); @@ -80,22 +86,23 @@ public: colorVector[2] = src[14]; colorVector[3] = src[19]; - return new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector); + return reinterpret_cast<jlong>(new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector)); #else return NULL; #endif } - static SkColorFilter* CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor, - SkPorterDuff::Mode mode) { - return SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode)); + static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor, + jint modeHandle) { + SkPorterDuff::Mode mode = (SkPorterDuff::Mode) modeHandle; + return reinterpret_cast<jlong>(SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode))); } - static SkColorFilter* CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) { - return SkColorFilter::CreateLightingFilter(mul, add); + static jlong CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) { + return reinterpret_cast<jlong>(SkColorFilter::CreateLightingFilter(mul, add)); } - static SkColorFilter* CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) { + static jlong CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) { AutoJavaFloatArray autoArray(env, jarray, 20); const float* src = autoArray.ptr(); @@ -104,30 +111,30 @@ public: for (int i = 0; i < 20; i++) { array[i] = SkFloatToScalar(src[i]); } - return new SkColorMatrixFilter(array); + return reinterpret_cast<jlong>(new SkColorMatrixFilter(array)); #else - return new SkColorMatrixFilter(src); + return reinterpret_cast<jlong>(new SkColorMatrixFilter(src)); #endif } }; static JNINativeMethod colorfilter_methods[] = { - {"finalizer", "(II)V", (void*) SkColorFilterGlue::finalizer} + {"finalizer", "(JJ)V", (void*) SkColorFilterGlue::finalizer} }; static JNINativeMethod porterduff_methods[] = { - { "native_CreatePorterDuffFilter", "(II)I", (void*) SkColorFilterGlue::CreatePorterDuffFilter }, - { "nCreatePorterDuffFilter", "(III)I", (void*) SkColorFilterGlue::glCreatePorterDuffFilter } + { "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter }, + { "nCreatePorterDuffFilter", "(JII)J", (void*) SkColorFilterGlue::glCreatePorterDuffFilter } }; static JNINativeMethod lighting_methods[] = { - { "native_CreateLightingFilter", "(II)I", (void*) SkColorFilterGlue::CreateLightingFilter }, - { "nCreateLightingFilter", "(III)I", (void*) SkColorFilterGlue::glCreateLightingFilter }, + { "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter }, + { "nCreateLightingFilter", "(JII)J", (void*) SkColorFilterGlue::glCreateLightingFilter }, }; static JNINativeMethod colormatrix_methods[] = { - { "nativeColorMatrixFilter", "([F)I", (void*) SkColorFilterGlue::CreateColorMatrixFilter }, - { "nColorMatrixFilter", "(I[F)I", (void*) SkColorFilterGlue::glCreateColorMatrixFilter } + { "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter }, + { "nColorMatrixFilter", "(J[F)J", (void*) SkColorFilterGlue::glCreateColorMatrixFilter } }; #define REG(env, name, array) \ diff --git a/core/jni/android/graphics/DrawFilter.cpp b/core/jni/android/graphics/DrawFilter.cpp index 2f9fe7e..fbfa2ec 100644 --- a/core/jni/android/graphics/DrawFilter.cpp +++ b/core/jni/android/graphics/DrawFilter.cpp @@ -33,18 +33,20 @@ namespace android { class SkDrawFilterGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkDrawFilter* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkDrawFilter* obj = reinterpret_cast<SkDrawFilter*>(objHandle); SkSafeUnref(obj); } - static SkDrawFilter* CreatePaintFlagsDF(JNIEnv* env, jobject clazz, - int clearFlags, int setFlags) { + static jlong CreatePaintFlagsDF(JNIEnv* env, jobject clazz, + jint clearFlags, jint setFlags) { // trim off any out-of-range bits clearFlags &= SkPaint::kAllFlags; setFlags &= SkPaint::kAllFlags; if (clearFlags | setFlags) { - return new SkPaintFlagsDrawFilter(clearFlags, setFlags); + SkDrawFilter* filter = new SkPaintFlagsDrawFilter(clearFlags, setFlags); + return reinterpret_cast<jlong>(filter); } else { return NULL; } @@ -52,11 +54,11 @@ public: }; static JNINativeMethod drawfilter_methods[] = { - {"nativeDestructor", "(I)V", (void*) SkDrawFilterGlue::finalizer} + {"nativeDestructor", "(J)V", (void*) SkDrawFilterGlue::finalizer} }; static JNINativeMethod paintflags_methods[] = { - {"nativeConstructor","(II)I", (void*) SkDrawFilterGlue::CreatePaintFlagsDF} + {"nativeConstructor","(II)J", (void*) SkDrawFilterGlue::CreatePaintFlagsDF} }; #define REG(env, name, array) \ diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp index 3090ad2..5d951ca 100644 --- a/core/jni/android/graphics/Graphics.cpp +++ b/core/jni/android/graphics/Graphics.cpp @@ -174,6 +174,12 @@ static jclass gRegion_class; static jfieldID gRegion_nativeInstanceID; static jmethodID gRegion_constructorMethodID; +static jclass gByte_class; +static jobject gVMRuntime; +static jclass gVMRuntime_class; +static jmethodID gVMRuntime_newNonMovableArray; +static jmethodID gVMRuntime_addressOf; + /////////////////////////////////////////////////////////////////////////////// void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B) @@ -287,7 +293,8 @@ SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { SkASSERT(env); SkASSERT(bitmap); SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); - SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID); + jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativeInstanceID); + SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle); SkASSERT(b); return b; } @@ -310,7 +317,8 @@ SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { SkASSERT(env); SkASSERT(canvas); SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); - SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID); + jlong canvasHandle = env->GetLongField(canvas, gCanvas_nativeInstanceID); + SkCanvas* c = reinterpret_cast<SkCanvas*>(canvasHandle); SkASSERT(c); return c; } @@ -319,7 +327,8 @@ SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { SkASSERT(env); SkASSERT(paint); SkASSERT(env->IsInstanceOf(paint, gPaint_class)); - SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID); + jlong paintHandle = env->GetLongField(paint, gPaint_nativeInstanceID); + SkPaint* p = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(p); return p; } @@ -329,7 +338,8 @@ SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) SkASSERT(env); SkASSERT(picture); SkASSERT(env->IsInstanceOf(picture, gPicture_class)); - SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID); + jlong pictureHandle = env->GetLongField(picture, gPicture_nativeInstanceID); + SkPicture* p = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(p); return p; } @@ -339,7 +349,8 @@ SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) SkASSERT(env); SkASSERT(region); SkASSERT(env->IsInstanceOf(region, gRegion_class)); - SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID); + jlong regionHandle = env->GetLongField(region, gRegion_nativeInstanceID); + SkRegion* r = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(r); return r; } @@ -371,7 +382,7 @@ jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buff assert_premultiplied(*bitmap, isPremultiplied); jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)), buffer, + reinterpret_cast<jlong>(bitmap), buffer, bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied, ninepatch, layoutbounds); hasException(env); // For the side effect of logging. @@ -406,7 +417,7 @@ jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecode jobject obj = env->NewObject(gBitmapRegionDecoder_class, gBitmapRegionDecoder_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap))); + reinterpret_cast<jlong>(bitmap)); hasException(env); // For the side effect of logging. return obj; } @@ -415,7 +426,7 @@ jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) { SkASSERT(region != NULL); jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(region)), 0); + reinterpret_cast<jlong>(region), 0); hasException(env); // For the side effect of logging. return obj; } @@ -550,8 +561,6 @@ void AndroidPixelRef::globalUnref() { /////////////////////////////////////////////////////////////////////////////// -extern "C" jbyte* jniGetNonMovableArrayElements(C_JNIEnv* env, jarray arrayObj); - jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, SkColorTable* ctable) { Sk64 size64 = bitmap->getSize64(); @@ -569,19 +578,24 @@ jbyteArray GraphicsJNI::allocateJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, } size_t size = size64.get32(); - jbyteArray arrayObj = env->NewByteArray(size); - if (arrayObj) { - // TODO: make this work without jniGetNonMovableArrayElements - jbyte* addr = jniGetNonMovableArrayElements(&env->functions, arrayObj); - if (addr) { - SkPixelRef* pr = new AndroidPixelRef(env, bitmapInfo, (void*) addr, - bitmap->rowBytes(), arrayObj, ctable); - bitmap->setPixelRef(pr)->unref(); - // since we're already allocated, we lockPixels right away - // HeapAllocator behaves this way too - bitmap->lockPixels(); - } + jbyteArray arrayObj = (jbyteArray) env->CallObjectMethod(gVMRuntime, + gVMRuntime_newNonMovableArray, + gByte_class, size); + if (env->ExceptionCheck() != 0) { + return NULL; + } + SkASSERT(arrayObj); + jbyte* addr = (jbyte*) env->CallLongMethod(gVMRuntime, gVMRuntime_addressOf, arrayObj); + if (env->ExceptionCheck() != 0) { + return NULL; } + SkASSERT(addr); + SkPixelRef* pr = new AndroidPixelRef(env, bitmapInfo, (void*) addr, + bitmap->rowBytes(), arrayObj, ctable); + bitmap->setPixelRef(pr)->unref(); + // since we're already allocated, we lockPixels right away + // HeapAllocator behaves this way too + bitmap->lockPixels(); return arrayObj; } @@ -630,7 +644,7 @@ static jclass make_globalref(JNIEnv* env, const char classname[]) { jclass c = env->FindClass(classname); SkASSERT(c); - return (jclass)env->NewGlobalRef(c); + return (jclass) env->NewGlobalRef(c); } static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, @@ -667,30 +681,41 @@ int register_android_graphics_Graphics(JNIEnv* env) gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); - gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I"); - gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(I[BIIIZZ[B[I)V"); + gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "J"); + gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(J[BIIIZZ[B[I)V"); gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V"); gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I"); gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder"); - gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V"); + gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(J)V"); gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config"); gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class, "nativeInt", "I"); gCanvas_class = make_globalref(env, "android/graphics/Canvas"); - gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I"); + gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "J"); gPaint_class = make_globalref(env, "android/graphics/Paint"); - gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I"); + gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "J"); gPicture_class = make_globalref(env, "android/graphics/Picture"); - gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I"); + gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "J"); gRegion_class = make_globalref(env, "android/graphics/Region"); - gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I"); + gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "J"); gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", - "(II)V"); + "(JI)V"); + + c = env->FindClass("java/lang/Byte"); + gByte_class = (jclass) env->NewGlobalRef( + env->GetStaticObjectField(c, env->GetStaticFieldID(c, "TYPE", "Ljava/lang/Class;"))); + + gVMRuntime_class = make_globalref(env, "dalvik/system/VMRuntime"); + m = env->GetStaticMethodID(gVMRuntime_class, "getRuntime", "()Ldalvik/system/VMRuntime;"); + gVMRuntime = env->NewGlobalRef(env->CallStaticObjectMethod(gVMRuntime_class, m)); + gVMRuntime_newNonMovableArray = env->GetMethodID(gVMRuntime_class, "newNonMovableArray", + "(Ljava/lang/Class;I)Ljava/lang/Object;"); + gVMRuntime_addressOf = env->GetMethodID(gVMRuntime_class, "addressOf", "(Ljava/lang/Object;)J"); return 0; } diff --git a/core/jni/android/graphics/Interpolator.cpp b/core/jni/android/graphics/Interpolator.cpp index aa33c3d..ca04dfe 100644 --- a/core/jni/android/graphics/Interpolator.cpp +++ b/core/jni/android/graphics/Interpolator.cpp @@ -5,23 +5,26 @@ #include "SkInterpolator.h" #include "SkTemplates.h" -static SkInterpolator* Interpolator_constructor(JNIEnv* env, jobject clazz, int valueCount, int frameCount) +static jlong Interpolator_constructor(JNIEnv* env, jobject clazz, jint valueCount, jint frameCount) { - return new SkInterpolator(valueCount, frameCount); + return reinterpret_cast<jlong>(new SkInterpolator(valueCount, frameCount)); } -static void Interpolator_destructor(JNIEnv* env, jobject clazz, SkInterpolator* interp) +static void Interpolator_destructor(JNIEnv* env, jobject clazz, jlong interpHandle) { + SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle); delete interp; } -static void Interpolator_reset(JNIEnv* env, jobject clazz, SkInterpolator* interp, int valueCount, int frameCount) +static void Interpolator_reset(JNIEnv* env, jobject clazz, jlong interpHandle, jint valueCount, jint frameCount) { + SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle); interp->reset(valueCount, frameCount); } -static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, SkInterpolator* interp, int index, int msec, jfloatArray valueArray, jfloatArray blendArray) +static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, jlong interpHandle, jint index, jint msec, jfloatArray valueArray, jfloatArray blendArray) { + SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle); SkScalar blendStorage[4]; SkScalar* blend = NULL; @@ -46,8 +49,9 @@ static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, SkInterpolator* interp->setKeyFrame(index, msec, scalars, blend); } -static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, SkInterpolator* interp, float repeatCount, jboolean mirror) +static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, jlong interpHandle, jfloat repeatCount, jboolean mirror) { + SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle); if (repeatCount > 32000) repeatCount = 32000; @@ -55,8 +59,9 @@ static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, SkInterpola interp->setMirror(mirror != 0); } -static int Interpolator_timeToValues(JNIEnv* env, jobject clazz, SkInterpolator* interp, int msec, jfloatArray valueArray) +static jint Interpolator_timeToValues(JNIEnv* env, jobject clazz, jlong interpHandle, jint msec, jfloatArray valueArray) { + SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle); SkInterpolatorBase::Result result; float* values = valueArray ? env->GetFloatArrayElements(valueArray, NULL) : NULL; @@ -70,7 +75,7 @@ static int Interpolator_timeToValues(JNIEnv* env, jobject clazz, SkInterpolator* env->ReleaseFloatArrayElements(valueArray, values, 0); } - return result; + return static_cast<jint>(result); } // ---------------------------------------------------------------------------- @@ -79,12 +84,12 @@ static int Interpolator_timeToValues(JNIEnv* env, jobject clazz, SkInterpolator* * JNI registration. */ static JNINativeMethod gInterpolatorMethods[] = { - { "nativeConstructor", "(II)I", (void*)Interpolator_constructor }, - { "nativeDestructor", "(I)V", (void*)Interpolator_destructor }, - { "nativeReset", "(III)V", (void*)Interpolator_reset }, - { "nativeSetKeyFrame", "(III[F[F)V", (void*)Interpolator_setKeyFrame }, - { "nativeSetRepeatMirror", "(IFZ)V", (void*)Interpolator_setRepeatMirror }, - { "nativeTimeToValues", "(II[F)I", (void*)Interpolator_timeToValues } + { "nativeConstructor", "(II)J", (void*)Interpolator_constructor }, + { "nativeDestructor", "(J)V", (void*)Interpolator_destructor }, + { "nativeReset", "(JII)V", (void*)Interpolator_reset }, + { "nativeSetKeyFrame", "(JII[F[F)V", (void*)Interpolator_setKeyFrame }, + { "nativeSetRepeatMirror", "(JFZ)V", (void*)Interpolator_setRepeatMirror }, + { "nativeTimeToValues", "(JI[F)I", (void*)Interpolator_timeToValues } }; int register_android_graphics_Interpolator(JNIEnv* env) diff --git a/core/jni/android/graphics/LayerRasterizer.cpp b/core/jni/android/graphics/LayerRasterizer.cpp index e5bc6f8..29e7db1 100644 --- a/core/jni/android/graphics/LayerRasterizer.cpp +++ b/core/jni/android/graphics/LayerRasterizer.cpp @@ -3,11 +3,13 @@ class SkLayerRasterizerGlue { public: - static SkRasterizer* create(JNIEnv* env, jobject) { - return new SkLayerRasterizer(); + static jlong create(JNIEnv* env, jobject) { + return reinterpret_cast<jlong>(new SkLayerRasterizer()); } - static void addLayer(JNIEnv* env, jobject, SkLayerRasterizer* layer, const SkPaint* paint, float dx, float dy) { + static void addLayer(JNIEnv* env, jobject, jlong layerHandle, jlong paintHandle, jfloat dx, jfloat dy) { + SkLayerRasterizer* layer = reinterpret_cast<SkLayerRasterizer *>(layerHandle); + const SkPaint* paint = reinterpret_cast<SkPaint *>(paintHandle); SkASSERT(layer); SkASSERT(paint); layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy)); @@ -19,8 +21,8 @@ public: #include <android_runtime/AndroidRuntime.h> static JNINativeMethod gLayerRasterizerMethods[] = { - { "nativeConstructor", "()I", (void*)SkLayerRasterizerGlue::create }, - { "nativeAddLayer", "(IIFF)V", (void*)SkLayerRasterizerGlue::addLayer } + { "nativeConstructor", "()J", (void*)SkLayerRasterizerGlue::create }, + { "nativeAddLayer", "(JJFF)V", (void*)SkLayerRasterizerGlue::addLayer } }; int register_android_graphics_LayerRasterizer(JNIEnv* env) diff --git a/core/jni/android/graphics/MaskFilter.cpp b/core/jni/android/graphics/MaskFilter.cpp index d954ddf..f331af7 100644 --- a/core/jni/android/graphics/MaskFilter.cpp +++ b/core/jni/android/graphics/MaskFilter.cpp @@ -13,18 +13,19 @@ static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) { class SkMaskFilterGlue { public: - static void destructor(JNIEnv* env, jobject, SkMaskFilter* filter) { + static void destructor(JNIEnv* env, jobject, jlong filterHandle) { + SkMaskFilter* filter = reinterpret_cast<SkMaskFilter *>(filterHandle); SkSafeUnref(filter); } - static SkMaskFilter* createBlur(JNIEnv* env, jobject, float radius, int blurStyle) { + static jlong createBlur(JNIEnv* env, jobject, jfloat radius, jint blurStyle) { SkMaskFilter* filter = SkBlurMaskFilter::Create(SkFloatToScalar(radius), (SkBlurMaskFilter::BlurStyle)blurStyle); ThrowIAE_IfNull(env, filter); - return filter; + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, float ambient, float specular, float radius) { + static jlong createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, jfloat ambient, jfloat specular, jfloat radius) { SkScalar direction[3]; AutoJavaFloatArray autoDir(env, dirArray, 3); @@ -38,39 +39,42 @@ public: SkFloatToScalar(specular), SkFloatToScalar(radius)); ThrowIAE_IfNull(env, filter); - return filter; + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createTable(JNIEnv* env, jobject, jbyteArray jtable) { + static jlong createTable(JNIEnv* env, jobject, jbyteArray jtable) { AutoJavaByteArray autoTable(env, jtable, 256); - return new SkTableMaskFilter((const uint8_t*)autoTable.ptr()); + SkMaskFilter* filter = new SkTableMaskFilter((const uint8_t*)autoTable.ptr()); + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createClipTable(JNIEnv* env, jobject, int min, int max) { - return SkTableMaskFilter::CreateClip(min, max); + static jlong createClipTable(JNIEnv* env, jobject, jint min, jint max) { + SkMaskFilter* filter = SkTableMaskFilter::CreateClip(min, max); + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createGammaTable(JNIEnv* env, jobject, float gamma) { - return SkTableMaskFilter::CreateGamma(gamma); + static jlong createGammaTable(JNIEnv* env, jobject, jfloat gamma) { + SkMaskFilter* filter = SkTableMaskFilter::CreateGamma(gamma); + return reinterpret_cast<jlong>(filter); } }; static JNINativeMethod gMaskFilterMethods[] = { - { "nativeDestructor", "(I)V", (void*)SkMaskFilterGlue::destructor } + { "nativeDestructor", "(J)V", (void*)SkMaskFilterGlue::destructor } }; static JNINativeMethod gBlurMaskFilterMethods[] = { - { "nativeConstructor", "(FI)I", (void*)SkMaskFilterGlue::createBlur } + { "nativeConstructor", "(FI)J", (void*)SkMaskFilterGlue::createBlur } }; static JNINativeMethod gEmbossMaskFilterMethods[] = { - { "nativeConstructor", "([FFFF)I", (void*)SkMaskFilterGlue::createEmboss } + { "nativeConstructor", "([FFFF)J", (void*)SkMaskFilterGlue::createEmboss } }; static JNINativeMethod gTableMaskFilterMethods[] = { - { "nativeNewTable", "([B)I", (void*)SkMaskFilterGlue::createTable }, - { "nativeNewClip", "(II)I", (void*)SkMaskFilterGlue::createClipTable }, - { "nativeNewGamma", "(F)I", (void*)SkMaskFilterGlue::createGammaTable } + { "nativeNewTable", "([B)J", (void*)SkMaskFilterGlue::createTable }, + { "nativeNewClip", "(II)J", (void*)SkMaskFilterGlue::createClipTable }, + { "nativeNewGamma", "(F)J", (void*)SkMaskFilterGlue::createGammaTable } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp index d0871ac5..a667499 100644 --- a/core/jni/android/graphics/Matrix.cpp +++ b/core/jni/android/graphics/Matrix.cpp @@ -31,218 +31,246 @@ namespace android { class SkMatrixGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); delete obj; } - static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) { + static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) { + const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle); SkMatrix* obj = new SkMatrix(); if (src) *obj = *src; else obj->reset(); - return obj; + return reinterpret_cast<jlong>(obj); } - - static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) { - return obj->isIdentity(); + + static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + return obj->isIdentity() ? JNI_TRUE : JNI_FALSE; } - - static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) { - return obj->rectStaysRect(); + static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE; } - - static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) { + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->reset(); } - - static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { + static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); *obj = *other; } - - static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->setTranslate(dx_, dy_); } - - static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setScale(sx_, sy_, px_, py_); } - - static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); obj->setScale(sx_, sy_); } - - static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setRotate(degrees_, px_, py_); } - - static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); obj->setRotate(degrees_); } - - static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sinValue_ = SkFloatToScalar(sinValue); SkScalar cosValue_ = SkFloatToScalar(cosValue); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setSinCos(sinValue_, cosValue_, px_, py_); } - - static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) { + static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sinValue_ = SkFloatToScalar(sinValue); SkScalar cosValue_ = SkFloatToScalar(cosValue); obj->setSinCos(sinValue_, cosValue_); } - - static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setSkew(kx_, ky_, px_, py_); } - - static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); obj->setSkew(kx_, ky_); } - - static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) { - return obj->setConcat(*a, *b); + static jboolean setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); + SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); + return obj->setConcat(*a, *b) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + + static jboolean preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); - return obj->preTranslate(dx_, dy_); + return obj->preTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + + static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preScale(sx_, sy_, px_, py_); + return obj->preScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + + static jboolean preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); - return obj->preScale(sx_, sy_); + return obj->preScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + + static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preRotate(degrees_, px_, py_); + return obj->preRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + + static jboolean preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); - return obj->preRotate(degrees_); + return obj->preRotate(degrees_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + + static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preSkew(kx_, ky_, px_, py_); + return obj->preSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + + static jboolean preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); - return obj->preSkew(kx_, ky_); + return obj->preSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { - return obj->preConcat(*other); + + static jboolean preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); + return obj->preConcat(*other) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + + static jboolean postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); - return obj->postTranslate(dx_, dy_); + return obj->postTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + + static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postScale(sx_, sy_, px_, py_); + return obj->postScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + + static jboolean postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); - return obj->postScale(sx_, sy_); + return obj->postScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + + static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postRotate(degrees_, px_, py_); + return obj->postRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + + static jboolean postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); - return obj->postRotate(degrees_); + return obj->postRotate(degrees_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + + static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postSkew(kx_, ky_, px_, py_); + return obj->postSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) { + + static jboolean postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); - return matrix->postSkew(kx_, ky_); + return matrix->postSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) { - return matrix->postConcat(*other); + + static jboolean postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); + return matrix->postConcat(*other) ? JNI_TRUE : JNI_FALSE; } - - static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) { + + static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle); SkRect src_; GraphicsJNI::jrectf_to_rect(env, src, &src_); SkRect dst_; GraphicsJNI::jrectf_to_rect(env, dst, &dst_); - return matrix->setRectToRect(src_, dst_, stf); + return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE; } - - static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix, - jfloatArray jsrc, int srcIndex, - jfloatArray jdst, int dstIndex, int ptCount) { + + static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray jsrc, jint srcIndex, + jfloatArray jdst, jint dstIndex, jint ptCount) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkASSERT(srcIndex >= 0); SkASSERT(dstIndex >= 0); SkASSERT((unsigned)ptCount <= 4); - AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1)); - AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1)); + AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1), kRO_JNIAccess); + AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), kRW_JNIAccess); float* src = autoSrc.ptr() + srcIndex; float* dst = autoDst.ptr() + dstIndex; + bool result; #ifdef SK_SCALAR_IS_FIXED SkPoint srcPt[4], dstPt[4]; @@ -252,24 +280,28 @@ public: srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y])); dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y])); } - return matrix->setPolyToPoly(srcPt, dstPt, ptCount); + result = matrix->setPolyToPoly(srcPt, dstPt, ptCount); #else - return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, + result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, ptCount); #endif + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) { + + static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle); return matrix->invert(inverse); } - - static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix, - jfloatArray dst, int dstIndex, - jfloatArray src, int srcIndex, - int ptCount, bool isPts) { + + static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray dst, jint dstIndex, + jfloatArray src, jint srcIndex, + jint ptCount, jboolean isPts) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkASSERT(ptCount >= 0); - AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1)); - AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1)); + AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), kRO_JNIAccess); + AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), kRW_JNIAccess); float* srcArray = autoSrc.ptr() + srcIndex; float* dstArray = autoDst.ptr() + dstIndex; @@ -304,21 +336,26 @@ public: ptCount); #endif } - - static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) { + + static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkRect dst_, src_; GraphicsJNI::jrectf_to_rect(env, src, &src_); jboolean rectStaysRect = matrix->mapRect(&dst_, src_); GraphicsJNI::rect_to_jrectf(dst_, env, dst); - return rectStaysRect; + return rectStaysRect ? JNI_TRUE : JNI_FALSE; } - - static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) { - return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); + + static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + float result; + result = SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); + return static_cast<jfloat>(result); } - - static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { - AutoJavaFloatArray autoValues(env, values, 9); + + static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess); float* dst = autoValues.ptr(); #ifdef SK_SCALAR_IS_FIXED @@ -334,9 +371,10 @@ public: } #endif } - - static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { - AutoJavaFloatArray autoValues(env, values, 9); + + static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess); const float* src = autoValues.ptr(); #ifdef SK_SCALAR_IS_FIXED @@ -353,53 +391,55 @@ public: #endif } - static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) { + static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) { + const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); + const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); return *a == *b; } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer}, - {"native_create","(I)I", (void*) SkMatrixGlue::create}, - {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity}, - {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect}, - {"native_reset","(I)V", (void*) SkMatrixGlue::reset}, - {"native_set","(II)V", (void*) SkMatrixGlue::set}, - {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate}, - {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, - {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF}, - {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, - {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F}, - {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, - {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF}, - {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, - {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF}, - {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat}, - {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate}, - {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, - {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF}, - {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, - {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F}, - {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, - {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF}, - {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat}, - {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate}, - {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, - {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF}, - {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, - {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F}, - {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, - {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF}, - {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat}, - {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, - {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, - {"native_invert","(II)Z", (void*) SkMatrixGlue::invert}, - {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, - {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, - {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius}, - {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues}, - {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues}, - {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals} + {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer}, + {"native_create","(J)J", (void*) SkMatrixGlue::create}, + {"native_isIdentity","(J)Z", (void*) SkMatrixGlue::isIdentity}, + {"native_rectStaysRect","(J)Z", (void*) SkMatrixGlue::rectStaysRect}, + {"native_reset","(J)V", (void*) SkMatrixGlue::reset}, + {"native_set","(JJ)V", (void*) SkMatrixGlue::set}, + {"native_setTranslate","(JFF)V", (void*) SkMatrixGlue::setTranslate}, + {"native_setScale","(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, + {"native_setScale","(JFF)V", (void*) SkMatrixGlue::setScale__FF}, + {"native_setRotate","(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, + {"native_setRotate","(JF)V", (void*) SkMatrixGlue::setRotate__F}, + {"native_setSinCos","(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, + {"native_setSinCos","(JFF)V", (void*) SkMatrixGlue::setSinCos__FF}, + {"native_setSkew","(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, + {"native_setSkew","(JFF)V", (void*) SkMatrixGlue::setSkew__FF}, + {"native_setConcat","(JJJ)Z", (void*) SkMatrixGlue::setConcat}, + {"native_preTranslate","(JFF)Z", (void*) SkMatrixGlue::preTranslate}, + {"native_preScale","(JFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, + {"native_preScale","(JFF)Z", (void*) SkMatrixGlue::preScale__FF}, + {"native_preRotate","(JFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, + {"native_preRotate","(JF)Z", (void*) SkMatrixGlue::preRotate__F}, + {"native_preSkew","(JFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, + {"native_preSkew","(JFF)Z", (void*) SkMatrixGlue::preSkew__FF}, + {"native_preConcat","(JJ)Z", (void*) SkMatrixGlue::preConcat}, + {"native_postTranslate","(JFF)Z", (void*) SkMatrixGlue::postTranslate}, + {"native_postScale","(JFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, + {"native_postScale","(JFF)Z", (void*) SkMatrixGlue::postScale__FF}, + {"native_postRotate","(JFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, + {"native_postRotate","(JF)Z", (void*) SkMatrixGlue::postRotate__F}, + {"native_postSkew","(JFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, + {"native_postSkew","(JFF)Z", (void*) SkMatrixGlue::postSkew__FF}, + {"native_postConcat","(JJ)Z", (void*) SkMatrixGlue::postConcat}, + {"native_setRectToRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, + {"native_setPolyToPoly","(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, + {"native_invert","(JJ)Z", (void*) SkMatrixGlue::invert}, + {"native_mapPoints","(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, + {"native_mapRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, + {"native_mapRadius","(JF)F", (void*) SkMatrixGlue::mapRadius}, + {"native_getValues","(J[F)V", (void*) SkMatrixGlue::getValues}, + {"native_setValues","(J[F)V", (void*) SkMatrixGlue::setValues}, + {"native_equals", "(JJ)Z", (void*) SkMatrixGlue::equals} }; static jfieldID sNativeInstanceField; @@ -409,13 +449,13 @@ int register_android_graphics_Matrix(JNIEnv* env) { sizeof(methods) / sizeof(methods[0])); jclass clazz = env->FindClass("android/graphics/Matrix"); - sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "I"); + sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "J"); return result; } SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) { - return reinterpret_cast<SkMatrix*>(env->GetIntField(matrixObj, sNativeInstanceField)); + return reinterpret_cast<SkMatrix*>(env->GetLongField(matrixObj, sNativeInstanceField)); } } diff --git a/core/jni/android/graphics/Movie.cpp b/core/jni/android/graphics/Movie.cpp index 55be7c1..461f723 100644 --- a/core/jni/android/graphics/Movie.cpp +++ b/core/jni/android/graphics/Movie.cpp @@ -27,43 +27,43 @@ jobject create_jmovie(JNIEnv* env, SkMovie* moov) { return NULL; } return env->NewObject(gMovie_class, gMovie_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(moov))); + static_cast<jlong>(reinterpret_cast<uintptr_t>(moov))); } static SkMovie* J2Movie(JNIEnv* env, jobject movie) { SkASSERT(env); SkASSERT(movie); SkASSERT(env->IsInstanceOf(movie, gMovie_class)); - SkMovie* m = (SkMovie*)env->GetIntField(movie, gMovie_nativeInstanceID); + SkMovie* m = (SkMovie*)env->GetLongField(movie, gMovie_nativeInstanceID); SkASSERT(m); return m; } /////////////////////////////////////////////////////////////////////////////// -static int movie_width(JNIEnv* env, jobject movie) { +static jint movie_width(JNIEnv* env, jobject movie) { NPE_CHECK_RETURN_ZERO(env, movie); - return J2Movie(env, movie)->width(); + return static_cast<jint>(J2Movie(env, movie)->width()); } -static int movie_height(JNIEnv* env, jobject movie) { +static jint movie_height(JNIEnv* env, jobject movie) { NPE_CHECK_RETURN_ZERO(env, movie); - return J2Movie(env, movie)->height(); + return static_cast<jint>(J2Movie(env, movie)->height()); } static jboolean movie_isOpaque(JNIEnv* env, jobject movie) { NPE_CHECK_RETURN_ZERO(env, movie); - return J2Movie(env, movie)->isOpaque(); + return J2Movie(env, movie)->isOpaque() ? JNI_TRUE : JNI_FALSE; } -static int movie_duration(JNIEnv* env, jobject movie) { +static jint movie_duration(JNIEnv* env, jobject movie) { NPE_CHECK_RETURN_ZERO(env, movie); - return J2Movie(env, movie)->duration(); + return static_cast<jint>(J2Movie(env, movie)->duration()); } -static jboolean movie_setTime(JNIEnv* env, jobject movie, int ms) { +static jboolean movie_setTime(JNIEnv* env, jobject movie, jint ms) { NPE_CHECK_RETURN_ZERO(env, movie); - return J2Movie(env, movie)->setTime(ms); + return J2Movie(env, movie)->setTime(ms) ? JNI_TRUE : JNI_FALSE; } static void movie_draw(JNIEnv* env, jobject movie, jobject canvas, @@ -82,7 +82,7 @@ static void movie_draw(JNIEnv* env, jobject movie, jobject canvas, c->drawBitmap(b, sx, sy, p); } -static jobject movie_decodeAsset(JNIEnv* env, jobject clazz, jint native_asset) { +static jobject movie_decodeAsset(JNIEnv* env, jobject clazz, jlong native_asset) { android::Asset* asset = reinterpret_cast<android::Asset*>(native_asset); if (asset == NULL) return NULL; SkAutoTUnref<SkStreamRewindable> stream (new android::AssetStreamAdaptor(asset, @@ -117,7 +117,7 @@ static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) { static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz, jbyteArray byteArray, - int offset, int length) { + jint offset, jint length) { NPE_CHECK_RETURN_ZERO(env, byteArray); @@ -132,7 +132,8 @@ static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz, return create_jmovie(env, moov); } -static void movie_destructor(JNIEnv* env, jobject, SkMovie* movie) { +static void movie_destructor(JNIEnv* env, jobject, jlong movieHandle) { + SkMovie* movie = (SkMovie*) movieHandle; delete movie; } @@ -148,11 +149,11 @@ static JNINativeMethod gMethods[] = { { "setTime", "(I)Z", (void*)movie_setTime }, { "draw", "(Landroid/graphics/Canvas;FFLandroid/graphics/Paint;)V", (void*)movie_draw }, - { "nativeDecodeAsset", "(I)Landroid/graphics/Movie;", + { "nativeDecodeAsset", "(J)Landroid/graphics/Movie;", (void*)movie_decodeAsset }, { "nativeDecodeStream", "(Ljava/io/InputStream;)Landroid/graphics/Movie;", (void*)movie_decodeStream }, - { "nativeDestructor","(I)V", (void*)movie_destructor }, + { "nativeDestructor","(J)V", (void*)movie_destructor }, { "decodeByteArray", "([BII)Landroid/graphics/Movie;", (void*)movie_decodeByteArray }, }; @@ -167,10 +168,10 @@ int register_android_graphics_Movie(JNIEnv* env) RETURN_ERR_IF_NULL(gMovie_class); gMovie_class = (jclass)env->NewGlobalRef(gMovie_class); - gMovie_constructorMethodID = env->GetMethodID(gMovie_class, "<init>", "(I)V"); + gMovie_constructorMethodID = env->GetMethodID(gMovie_class, "<init>", "(J)V"); RETURN_ERR_IF_NULL(gMovie_constructorMethodID); - gMovie_nativeInstanceID = env->GetFieldID(gMovie_class, "mNativeMovie", "I"); + gMovie_nativeInstanceID = env->GetFieldID(gMovie_class, "mNativeMovie", "J"); RETURN_ERR_IF_NULL(gMovie_nativeInstanceID); return android::AndroidRuntime::registerNativeMethods(env, kClassPathName, diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp index 7e6aeae..871e24d 100644 --- a/core/jni/android/graphics/NinePatch.cpp +++ b/core/jni/android/graphics/NinePatch.cpp @@ -46,22 +46,22 @@ class SkNinePatchGlue { public: static jboolean isNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) { if (NULL == obj) { - return false; + return JNI_FALSE; } if (env->GetArrayLength(obj) < (int)sizeof(Res_png_9patch)) { - return false; + return JNI_FALSE; } const jbyte* array = env->GetByteArrayElements(obj, 0); if (array != NULL) { const Res_png_9patch* chunk = reinterpret_cast<const Res_png_9patch*>(array); int8_t wasDeserialized = chunk->wasDeserialized; env->ReleaseByteArrayElements(obj, const_cast<jbyte*>(array), JNI_ABORT); - return wasDeserialized != -1; + return (wasDeserialized != -1) ? JNI_TRUE : JNI_FALSE; } - return false; + return JNI_FALSE; } - static int8_t* validateNinePatchChunk(JNIEnv* env, jobject, jint, jbyteArray obj) { + static jlong validateNinePatchChunk(JNIEnv* env, jobject, jlong, jbyteArray obj) { size_t chunkSize = env->GetArrayLength(obj); if (chunkSize < (int) (sizeof(Res_png_9patch))) { jniThrowRuntimeException(env, "Array too small for chunk."); @@ -72,10 +72,11 @@ public: // This call copies the content of the jbyteArray env->GetByteArrayRegion(obj, 0, chunkSize, reinterpret_cast<jbyte*>(storage)); // Deserialize in place, return the array we just allocated - return (int8_t*) Res_png_9patch::deserialize(storage); + return reinterpret_cast<jlong>(Res_png_9patch::deserialize(storage)); } - static void finalize(JNIEnv* env, jobject, int8_t* patch) { + static void finalize(JNIEnv* env, jobject, jlong patchHandle) { + int8_t* patch = reinterpret_cast<int8_t*>(patchHandle); #ifdef USE_OPENGL_RENDERER if (android::uirenderer::Caches::hasInstance()) { Res_png_9patch* p = (Res_png_9patch*) patch; @@ -115,9 +116,13 @@ public: } } - static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF, - const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint, + static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF, + jlong bitmapHandle, jlong chunkHandle, jlong paintHandle, jint destDensity, jint srcDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(canvas); SkASSERT(boundsRectF); SkASSERT(bitmap); @@ -130,9 +135,13 @@ public: draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity); } - static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect, - const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint, + static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect, + jlong bitmapHandle, jlong chunkHandle, jlong paintHandle, jint destDensity, jint srcDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(canvas); SkASSERT(boundsRect); SkASSERT(bitmap); @@ -144,8 +153,10 @@ public: draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity); } - static jint getTransparentRegion(JNIEnv* env, jobject, const SkBitmap* bitmap, - Res_png_9patch* chunk, jobject boundsRect) { + static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapHandle, + jlong chunkHandle, jobject boundsRect) { + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); SkASSERT(bitmap); SkASSERT(chunk); SkASSERT(boundsRect); @@ -156,7 +167,7 @@ public: SkRegion* region = NULL; NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, ®ion); - return (jint) region; + return reinterpret_cast<jlong>(region); } }; @@ -167,11 +178,11 @@ public: static JNINativeMethod gNinePatchMethods[] = { { "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk }, - { "validateNinePatchChunk", "(I[B)I", (void*) SkNinePatchGlue::validateNinePatchChunk }, - { "nativeFinalize", "(I)V", (void*) SkNinePatchGlue::finalize }, - { "nativeDraw", "(ILandroid/graphics/RectF;IIIII)V", (void*) SkNinePatchGlue::drawF }, - { "nativeDraw", "(ILandroid/graphics/Rect;IIIII)V", (void*) SkNinePatchGlue::drawI }, - { "nativeGetTransparentRegion", "(IILandroid/graphics/Rect;)I", + { "validateNinePatchChunk", "(J[B)J", (void*) SkNinePatchGlue::validateNinePatchChunk }, + { "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize }, + { "nativeDraw", "(JLandroid/graphics/RectF;JJJII)V", (void*) SkNinePatchGlue::drawF }, + { "nativeDraw", "(JLandroid/graphics/Rect;JJJII)V", (void*) SkNinePatchGlue::drawI }, + { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J", (void*) SkNinePatchGlue::getTransparentRegion } }; diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp index fd3f327..dc97c22 100644 --- a/core/jni/android/graphics/Paint.cpp +++ b/core/jni/android/graphics/Paint.cpp @@ -70,33 +70,40 @@ public: AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT }; - static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); delete obj; } - static SkPaint* init(JNIEnv* env, jobject clazz) { + static jlong init(JNIEnv* env, jobject clazz) { SkPaint* obj = new SkPaint(); defaultSettingsForAndroid(obj); - return obj; + return reinterpret_cast<jlong>(obj); } - static SkPaint* intiWithPaint(JNIEnv* env, jobject clazz, SkPaint* paint) { + static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkPaint* obj = new SkPaint(*paint); - return obj; + return reinterpret_cast<jlong>(obj); } - static void reset(JNIEnv* env, jobject clazz, SkPaint* obj) { + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); obj->reset(); defaultSettingsForAndroid(obj); } - static void assign(JNIEnv* env, jobject clazz, SkPaint* dst, const SkPaint* src) { + static void assign(JNIEnv* env, jobject clazz, jlong dstPaintHandle, jlong srcPaintHandle) { + SkPaint* dst = reinterpret_cast<SkPaint*>(dstPaintHandle); + const SkPaint* src = reinterpret_cast<SkPaint*>(srcPaintHandle); *dst = *src; } static jint getFlags(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getFlags(); + int result; + result = GraphicsJNI::getNativePaint(env, paint)->getFlags(); + return static_cast<jint>(result); } static void setFlags(JNIEnv* env, jobject paint, jint flags) { @@ -157,22 +164,29 @@ public: GraphicsJNI::getNativePaint(env, paint)->setDither(dither); } - static jint getStyle(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStyle(); + static jint getStyle(JNIEnv* env, jobject clazz,jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStyle()); } - static void setStyle(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Style style) { + static void setStyle(JNIEnv* env, jobject clazz, jlong objHandle, jint styleHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Style style = static_cast<SkPaint::Style>(styleHandle); obj->setStyle(style); } static jint getColor(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getColor(); + int color; + color = GraphicsJNI::getNativePaint(env, paint)->getColor(); + return static_cast<jint>(color); } static jint getAlpha(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getAlpha(); + int alpha; + alpha = GraphicsJNI::getNativePaint(env, paint)->getAlpha(); + return static_cast<jint>(alpha); } static void setColor(JNIEnv* env, jobject paint, jint color) { @@ -205,59 +219,85 @@ public: GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter)); } - static jint getStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStrokeCap(); + static jint getStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStrokeCap()); } - static void setStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Cap cap) { + static void setStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle, jint capHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Cap cap = static_cast<SkPaint::Cap>(capHandle); obj->setStrokeCap(cap); } - static jint getStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStrokeJoin(); + static jint getStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStrokeJoin()); } - static void setStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Join join) { + static void setStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle, jint joinHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Join join = (SkPaint::Join) joinHandle; obj->setStrokeJoin(join); } - static jboolean getFillPath(JNIEnv* env, jobject clazz, SkPaint* obj, SkPath* src, SkPath* dst) { - return obj->getFillPath(*src, dst); + static jboolean getFillPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong dstHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); + return obj->getFillPath(*src, dst) ? JNI_TRUE : JNI_FALSE; } - static SkShader* setShader(JNIEnv* env, jobject clazz, SkPaint* obj, SkShader* shader) { - return obj->setShader(shader); + static jlong setShader(JNIEnv* env, jobject clazz, jlong objHandle, jlong shaderHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + return reinterpret_cast<jlong>(obj->setShader(shader)); } - static SkColorFilter* setColorFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkColorFilter* filter) { - return obj->setColorFilter(filter); + static jlong setColorFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong filterHandle) { + SkPaint* obj = reinterpret_cast<SkPaint *>(objHandle); + SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(filterHandle); + return reinterpret_cast<jlong>(obj->setColorFilter(filter)); } - static SkXfermode* setXfermode(JNIEnv* env, jobject clazz, SkPaint* obj, SkXfermode* xfermode) { - return obj->setXfermode(xfermode); + static jlong setXfermode(JNIEnv* env, jobject clazz, jlong objHandle, jlong xfermodeHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkXfermode* xfermode = reinterpret_cast<SkXfermode*>(xfermodeHandle); + return reinterpret_cast<jlong>(obj->setXfermode(xfermode)); } - static SkPathEffect* setPathEffect(JNIEnv* env, jobject clazz, SkPaint* obj, SkPathEffect* effect) { - return obj->setPathEffect(effect); + static jlong setPathEffect(JNIEnv* env, jobject clazz, jlong objHandle, jlong effectHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle); + return reinterpret_cast<jlong>(obj->setPathEffect(effect)); } - static SkMaskFilter* setMaskFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkMaskFilter* maskfilter) { - return obj->setMaskFilter(maskfilter); + static jlong setMaskFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong maskfilterHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkMaskFilter* maskfilter = reinterpret_cast<SkMaskFilter*>(maskfilterHandle); + return reinterpret_cast<jlong>(obj->setMaskFilter(maskfilter)); } - static SkTypeface* setTypeface(JNIEnv* env, jobject clazz, SkPaint* obj, SkTypeface* typeface) { - return obj->setTypeface(typeface); + static jlong setTypeface(JNIEnv* env, jobject clazz, jlong objHandle, jlong typefaceHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkTypeface* typeface = reinterpret_cast<SkTypeface*>(typefaceHandle); + return reinterpret_cast<jlong>(obj->setTypeface(typeface)); } - static SkRasterizer* setRasterizer(JNIEnv* env, jobject clazz, SkPaint* obj, SkRasterizer* rasterizer) { - return obj->setRasterizer(rasterizer); + static jlong setRasterizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong rasterizerHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkRasterizer* rasterizer = reinterpret_cast<SkRasterizer*>(rasterizerHandle); + return reinterpret_cast<jlong>(obj->setRasterizer(rasterizer)); } - static jint getTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getTextAlign(); + static jint getTextAlign(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getTextAlign()); } - static void setTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Align align) { + static void setTextAlign(JNIEnv* env, jobject clazz, jlong objHandle, jint alignHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Align align = static_cast<SkPaint::Align>(alignHandle); obj->setTextAlign(align); } @@ -301,7 +341,8 @@ public: output[0] = '\0'; } - static void setTextLocale(JNIEnv* env, jobject clazz, SkPaint* obj, jstring locale) { + static void setTextLocale(JNIEnv* env, jobject clazz, jlong objHandle, jstring locale) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); ScopedUtfChars localeChars(env, locale); char langTag[ULOC_FULLNAME_CAPACITY]; toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, localeChars.c_str()); @@ -391,7 +432,7 @@ public: return descent - ascent + leading; } - static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count, + static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, jint index, jint count, jint bidiFlags) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, text); @@ -416,7 +457,7 @@ public: return result; } - static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, int start, int end, + static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, jint start, jint end, jint bidiFlags) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, text); @@ -489,8 +530,9 @@ public: return count; } - static int getTextWidths___CIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, - int index, int count, jint bidiFlags, jfloatArray widths) { + static jint getTextWidths___CIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, + jint index, jint count, jint bidiFlags, jfloatArray widths) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); count = dotextwidths(env, paint, textArray + index, count, widths, bidiFlags); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), @@ -498,8 +540,9 @@ public: return count; } - static int getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, - int start, int end, jint bidiFlags, jfloatArray widths) { + static jint getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, + jint start, jint end, jint bidiFlags, jfloatArray widths) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); int count = dotextwidths(env, paint, textArray + start, end - start, widths, bidiFlags); env->ReleaseStringChars(text, textArray); @@ -536,9 +579,10 @@ public: return glyphsCount; } - static int getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, SkPaint* paint, + static jint getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags, jcharArray glyphs) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); int count = doTextGlyphs(env, paint, textArray + contextStart, start - contextStart, end - start, contextEnd - contextStart, flags, glyphs); @@ -579,9 +623,10 @@ public: return totalAdvance; } - static float getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint, + static jfloat getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint index, jint count, jint contextIndex, jint contextCount, jint flags, jfloatArray advances, jint advancesIndex) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); jfloat result = doTextRunAdvances(env, paint, textArray + contextIndex, index - contextIndex, count, contextCount, flags, advances, advancesIndex); @@ -589,9 +634,10 @@ public: return result; } - static float getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint, + static jfloat getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags, jfloatArray advances, jint advancesIndex) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jfloat result = doTextRunAdvances(env, paint, textArray + contextStart, start - contextStart, end - start, contextEnd - contextStart, flags, @@ -644,8 +690,9 @@ public: return pos; } - static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, + static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint contextStart, jint contextCount, jint flags, jint offset, jint cursorOpt) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); jint result = doTextRunCursor(env, paint, textArray, contextStart, contextCount, flags, offset, cursorOpt); @@ -653,8 +700,9 @@ public: return result; } - static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, + static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint contextStart, jint contextEnd, jint flags, jint offset, jint cursorOpt) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jint result = doTextRunCursor(env, paint, textArray, contextStart, contextEnd - contextStart, flags, offset, cursorOpt); @@ -667,22 +715,26 @@ public: TextLayout::getTextPath(paint, text, count, bidiFlags, x, y, path); } - static void getTextPath___C(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags, - jcharArray text, int index, int count, jfloat x, jfloat y, SkPath* path) { + static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, + jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); getTextPath(env, paint, textArray + index, count, bidiFlags, x, y, path); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), JNI_ABORT); } - static void getTextPath__String(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags, - jstring text, int start, int end, jfloat x, jfloat y, SkPath* path) { + static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, + jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); const jchar* textArray = env->GetStringChars(text, NULL); getTextPath(env, paint, textArray + start, end - start, bidiFlags, x, y, path); env->ReleaseStringChars(text, textArray); } static void setShadowLayer(JNIEnv* env, jobject jpaint, jfloat radius, - jfloat dx, jfloat dy, int color) { + jfloat dx, jfloat dy, jint color) { NPE_CHECK_RETURN_VOID(env, jpaint); SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); @@ -718,8 +770,8 @@ public: return bytes >> 1; } - static int breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext, - int index, int count, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { + static jint breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext, + jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, jtext); @@ -746,8 +798,8 @@ public: return count; } - static int breakTextS(JNIEnv* env, jobject jpaint, jstring jtext, - bool forwards, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { + static jint breakTextS(JNIEnv* env, jobject jpaint, jstring jtext, + jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, jtext); @@ -778,15 +830,17 @@ public: GraphicsJNI::irect_to_jrect(ir, env, bounds); } - static void getStringBounds(JNIEnv* env, jobject, const SkPaint* paint, - jstring text, int start, int end, jint bidiFlags, jobject bounds) { + static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle, + jstring text, jint start, jint end, jint bidiFlags, jobject bounds) { + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);; const jchar* textArray = env->GetStringChars(text, NULL); doTextBounds(env, textArray + start, end - start, bounds, *paint, bidiFlags); env->ReleaseStringChars(text, textArray); } - static void getCharArrayBounds(JNIEnv* env, jobject, const SkPaint* paint, - jcharArray text, int index, int count, jint bidiFlags, jobject bounds) { + static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle, + jcharArray text, jint index, jint count, jint bidiFlags, jobject bounds) { + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); doTextBounds(env, textArray + index, count, bounds, *paint, bidiFlags); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), @@ -796,11 +850,11 @@ public: }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkPaintGlue::finalizer}, - {"native_init","()I", (void*) SkPaintGlue::init}, - {"native_initWithPaint","(I)I", (void*) SkPaintGlue::intiWithPaint}, - {"native_reset","(I)V", (void*) SkPaintGlue::reset}, - {"native_set","(II)V", (void*) SkPaintGlue::assign}, + {"finalizer", "(J)V", (void*) SkPaintGlue::finalizer}, + {"native_init","()J", (void*) SkPaintGlue::init}, + {"native_initWithPaint","(J)J", (void*) SkPaintGlue::initWithPaint}, + {"native_reset","(J)V", (void*) SkPaintGlue::reset}, + {"native_set","(JJ)V", (void*) SkPaintGlue::assign}, {"getFlags","()I", (void*) SkPaintGlue::getFlags}, {"setFlags","(I)V", (void*) SkPaintGlue::setFlags}, {"getHinting","()I", (void*) SkPaintGlue::getHinting}, @@ -813,8 +867,8 @@ static JNINativeMethod methods[] = { {"setFakeBoldText","(Z)V", (void*) SkPaintGlue::setFakeBoldText}, {"setFilterBitmap","(Z)V", (void*) SkPaintGlue::setFilterBitmap}, {"setDither","(Z)V", (void*) SkPaintGlue::setDither}, - {"native_getStyle","(I)I", (void*) SkPaintGlue::getStyle}, - {"native_setStyle","(II)V", (void*) SkPaintGlue::setStyle}, + {"native_getStyle","(J)I", (void*) SkPaintGlue::getStyle}, + {"native_setStyle","(JI)V", (void*) SkPaintGlue::setStyle}, {"getColor","()I", (void*) SkPaintGlue::getColor}, {"setColor","(I)V", (void*) SkPaintGlue::setColor}, {"getAlpha","()I", (void*) SkPaintGlue::getAlpha}, @@ -823,21 +877,21 @@ static JNINativeMethod methods[] = { {"setStrokeWidth","(F)V", (void*) SkPaintGlue::setStrokeWidth}, {"getStrokeMiter","()F", (void*) SkPaintGlue::getStrokeMiter}, {"setStrokeMiter","(F)V", (void*) SkPaintGlue::setStrokeMiter}, - {"native_getStrokeCap","(I)I", (void*) SkPaintGlue::getStrokeCap}, - {"native_setStrokeCap","(II)V", (void*) SkPaintGlue::setStrokeCap}, - {"native_getStrokeJoin","(I)I", (void*) SkPaintGlue::getStrokeJoin}, - {"native_setStrokeJoin","(II)V", (void*) SkPaintGlue::setStrokeJoin}, - {"native_getFillPath","(III)Z", (void*) SkPaintGlue::getFillPath}, - {"native_setShader","(II)I", (void*) SkPaintGlue::setShader}, - {"native_setColorFilter","(II)I", (void*) SkPaintGlue::setColorFilter}, - {"native_setXfermode","(II)I", (void*) SkPaintGlue::setXfermode}, - {"native_setPathEffect","(II)I", (void*) SkPaintGlue::setPathEffect}, - {"native_setMaskFilter","(II)I", (void*) SkPaintGlue::setMaskFilter}, - {"native_setTypeface","(II)I", (void*) SkPaintGlue::setTypeface}, - {"native_setRasterizer","(II)I", (void*) SkPaintGlue::setRasterizer}, - {"native_getTextAlign","(I)I", (void*) SkPaintGlue::getTextAlign}, - {"native_setTextAlign","(II)V", (void*) SkPaintGlue::setTextAlign}, - {"native_setTextLocale","(ILjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale}, + {"native_getStrokeCap","(J)I", (void*) SkPaintGlue::getStrokeCap}, + {"native_setStrokeCap","(JI)V", (void*) SkPaintGlue::setStrokeCap}, + {"native_getStrokeJoin","(J)I", (void*) SkPaintGlue::getStrokeJoin}, + {"native_setStrokeJoin","(JI)V", (void*) SkPaintGlue::setStrokeJoin}, + {"native_getFillPath","(JJJ)Z", (void*) SkPaintGlue::getFillPath}, + {"native_setShader","(JJ)J", (void*) SkPaintGlue::setShader}, + {"native_setColorFilter","(JJ)J", (void*) SkPaintGlue::setColorFilter}, + {"native_setXfermode","(JJ)J", (void*) SkPaintGlue::setXfermode}, + {"native_setPathEffect","(JJ)J", (void*) SkPaintGlue::setPathEffect}, + {"native_setMaskFilter","(JJ)J", (void*) SkPaintGlue::setMaskFilter}, + {"native_setTypeface","(JJ)J", (void*) SkPaintGlue::setTypeface}, + {"native_setRasterizer","(JJ)J", (void*) SkPaintGlue::setRasterizer}, + {"native_getTextAlign","(J)I", (void*) SkPaintGlue::getTextAlign}, + {"native_setTextAlign","(JI)V", (void*) SkPaintGlue::setTextAlign}, + {"native_setTextLocale","(JLjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale}, {"getTextSize","()F", (void*) SkPaintGlue::getTextSize}, {"setTextSize","(F)V", (void*) SkPaintGlue::setTextSize}, {"getTextScaleX","()F", (void*) SkPaintGlue::getTextScaleX}, @@ -853,24 +907,24 @@ static JNINativeMethod methods[] = { {"native_measureText","(Ljava/lang/String;III)F", (void*) SkPaintGlue::measureText_StringIII}, {"native_breakText","([CIIFI[F)I", (void*) SkPaintGlue::breakTextC}, {"native_breakText","(Ljava/lang/String;ZFI[F)I", (void*) SkPaintGlue::breakTextS}, - {"native_getTextWidths","(I[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F}, - {"native_getTextWidths","(ILjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F}, - {"native_getTextRunAdvances","(I[CIIIII[FI)F", + {"native_getTextWidths","(J[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F}, + {"native_getTextWidths","(JLjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F}, + {"native_getTextRunAdvances","(J[CIIIII[FI)F", (void*) SkPaintGlue::getTextRunAdvances___CIIIII_FI}, - {"native_getTextRunAdvances","(ILjava/lang/String;IIIII[FI)F", + {"native_getTextRunAdvances","(JLjava/lang/String;IIIII[FI)F", (void*) SkPaintGlue::getTextRunAdvances__StringIIIII_FI}, - {"native_getTextGlyphs","(ILjava/lang/String;IIIII[C)I", + {"native_getTextGlyphs","(JLjava/lang/String;IIIII[C)I", (void*) SkPaintGlue::getTextGlyphs__StringIIIII_C}, - {"native_getTextRunCursor", "(I[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C}, - {"native_getTextRunCursor", "(ILjava/lang/String;IIIII)I", + {"native_getTextRunCursor", "(J[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C}, + {"native_getTextRunCursor", "(JLjava/lang/String;IIIII)I", (void*) SkPaintGlue::getTextRunCursor__String}, - {"native_getTextPath","(II[CIIFFI)V", (void*) SkPaintGlue::getTextPath___C}, - {"native_getTextPath","(IILjava/lang/String;IIFFI)V", (void*) SkPaintGlue::getTextPath__String}, - {"nativeGetStringBounds", "(ILjava/lang/String;IIILandroid/graphics/Rect;)V", + {"native_getTextPath","(JI[CIIFFJ)V", (void*) SkPaintGlue::getTextPath___C}, + {"native_getTextPath","(JILjava/lang/String;IIFFJ)V", (void*) SkPaintGlue::getTextPath__String}, + {"nativeGetStringBounds", "(JLjava/lang/String;IIILandroid/graphics/Rect;)V", (void*) SkPaintGlue::getStringBounds }, - {"nativeGetCharArrayBounds", "(I[CIIILandroid/graphics/Rect;)V", + {"nativeGetCharArrayBounds", "(J[CIIILandroid/graphics/Rect;)V", (void*) SkPaintGlue::getCharArrayBounds }, {"nSetShadowLayer", "(FFFI)V", (void*)SkPaintGlue::setShadowLayer} }; diff --git a/core/jni/android/graphics/Path.cpp b/core/jni/android/graphics/Path.cpp index ab7f1dc..54b6996 100644 --- a/core/jni/android/graphics/Path.cpp +++ b/core/jni/android/graphics/Path.cpp @@ -34,7 +34,8 @@ namespace android { class SkPathGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); #ifdef USE_OPENGL_RENDERER if (android::uirenderer::Caches::hasInstance()) { android::uirenderer::Caches::getInstance().resourceCache.destructor(obj); @@ -44,79 +45,96 @@ public: delete obj; } - static SkPath* init1(JNIEnv* env, jobject clazz) { - return new SkPath(); + static jlong init1(JNIEnv* env, jobject clazz) { + return reinterpret_cast<jlong>(new SkPath()); } - - static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) { - return new SkPath(*val); + + static jlong init2(JNIEnv* env, jobject clazz, jlong valHandle) { + SkPath* val = reinterpret_cast<SkPath*>(valHandle); + return reinterpret_cast<jlong>(new SkPath(*val)); } - - static void reset(JNIEnv* env, jobject clazz, SkPath* obj) { + + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->reset(); } - static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) { + static void rewind(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->rewind(); } - static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) { + static void assign(JNIEnv* env, jobject clazz, jlong dstHandle, jlong srcHandle) { + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); + const SkPath* src = reinterpret_cast<SkPath*>(srcHandle); *dst = *src; } - - static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) { + + static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); return obj->getFillType(); } - static void setFillType(JNIEnv* env, jobject clazz, SkPath* path, SkPath::FillType ft) { + static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) { + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle); path->setFillType(ft); } - - static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) { + + static jboolean isEmpty(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); return obj->isEmpty(); } - static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) { + static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); jboolean result = obj->isRect(&rect_); GraphicsJNI::rect_to_jrectf(rect_, env, rect); return result; } - static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds) { + static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject bounds) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); const SkRect& bounds_ = obj->getBounds(); GraphicsJNI::rect_to_jrectf(bounds_, env, bounds); } - static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) { + static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->incReserve(extraPtCount); } - static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); obj->moveTo(x_, y_); } - static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->rMoveTo(dx_, dy_); } - static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); obj->lineTo(x_, y_); } - static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->rLineTo(dx_, dy_); } - static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { + static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -124,7 +142,8 @@ public: obj->quadTo(x1_, y1_, x2_, y2_); } - static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { + static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx1_ = SkFloatToScalar(dx1); SkScalar dy1_ = SkFloatToScalar(dy1); SkScalar dx2_ = SkFloatToScalar(dx2); @@ -132,7 +151,8 @@ public: obj->rQuadTo(dx1_, dy1_, dx2_, dy2_); } - static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -142,7 +162,8 @@ public: obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_); } - static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -152,7 +173,8 @@ public: obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_); } - static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { + static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkRect oval_; GraphicsJNI::jrectf_to_rect(env, oval, &oval_); SkScalar startAngle_ = SkFloatToScalar(startAngle); @@ -160,17 +182,22 @@ public: obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo); } - static void close(JNIEnv* env, jobject clazz, SkPath* obj) { + static void close(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->close(); } - static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) { + static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); obj->addRect(rect_, dir); } - static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) { + static void addRect__FFFFI(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); SkScalar right_ = SkFloatToScalar(right); @@ -178,39 +205,48 @@ public: obj->addRect(left_, top_, right_, bottom_, dir); } - static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) { + static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkRect oval_; GraphicsJNI::jrectf_to_rect(env, oval, &oval_); obj->addOval(oval_, dir); } - static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) { + static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); SkScalar radius_ = SkFloatToScalar(radius); obj->addCircle(x_, y_, radius_, dir); } - static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) { + static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) { SkRect oval_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); GraphicsJNI::jrectf_to_rect(env, oval, &oval_); SkScalar startAngle_ = SkFloatToScalar(startAngle); SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); obj->addArc(oval_, startAngle_, sweepAngle_); } - static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, - jfloat rx, jfloat ry, SkPath::Direction dir) { + static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, + jfloat rx, jfloat ry, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); SkScalar rx_ = SkFloatToScalar(rx); SkScalar ry_ = SkFloatToScalar(ry); obj->addRoundRect(rect_, rx_, ry_, dir); } - static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect, - jfloatArray array, SkPath::Direction dir) { + static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject rect, + jfloatArray array, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); AutoJavaFloatArray afa(env, array, 8); const float* src = afa.ptr(); @@ -222,90 +258,110 @@ public: obj->addRoundRect(rect_, dst, dir); } - static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) { + static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->addPath(*src, dx_, dy_); } - static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) { + static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); obj->addPath(*src); } - static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) { + static void addPath__PathMatrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong matrixHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); obj->addPath(*src, *matrix); } - static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) { + static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->offset(dx_, dy_, dst); } - static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->offset(dx_, dy_); } - static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->setLastPt(dx_, dy_); } - static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) { + static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); obj->transform(*matrix, dst); } - static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) { + static void transform__Matrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); obj->transform(*matrix); } - static jboolean op(JNIEnv* env, jobject clazz, SkPath* p1, SkPath* p2, SkPathOp op, SkPath* r) { - return Op(*p1, *p2, op, r); + static jboolean op(JNIEnv* env, jobject clazz, jlong p1Handle, jlong p2Handle, jint opHandle, jlong rHandle) { + SkPath* p1 = reinterpret_cast<SkPath*>(p1Handle); + SkPath* p2 = reinterpret_cast<SkPath*>(p2Handle); + SkPathOp op = static_cast<SkPathOp>(opHandle); + SkPath* r = reinterpret_cast<SkPath*>(rHandle); + return Op(*p1, *p2, op, r); } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkPathGlue::finalizer}, - {"init1","()I", (void*) SkPathGlue::init1}, - {"init2","(I)I", (void*) SkPathGlue::init2}, - {"native_reset","(I)V", (void*) SkPathGlue::reset}, - {"native_rewind","(I)V", (void*) SkPathGlue::rewind}, - {"native_set","(II)V", (void*) SkPathGlue::assign}, - {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType}, - {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType}, - {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty}, - {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, - {"native_computeBounds","(ILandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, - {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve}, - {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF}, - {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo}, - {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF}, - {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo}, - {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, - {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo}, - {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, - {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo}, - {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, - {"native_close","(I)V", (void*) SkPathGlue::close}, - {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, - {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, - {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, - {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle}, - {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, - {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, - {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, - {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF}, - {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path}, - {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix}, - {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath}, - {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF}, - {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint}, - {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath}, - {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix}, - {"native_op","(IIII)Z", (void*) SkPathGlue::op} + {"finalizer", "(J)V", (void*) SkPathGlue::finalizer}, + {"init1","()J", (void*) SkPathGlue::init1}, + {"init2","(J)J", (void*) SkPathGlue::init2}, + {"native_reset","(J)V", (void*) SkPathGlue::reset}, + {"native_rewind","(J)V", (void*) SkPathGlue::rewind}, + {"native_set","(JJ)V", (void*) SkPathGlue::assign}, + {"native_getFillType","(J)I", (void*) SkPathGlue::getFillType}, + {"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType}, + {"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty}, + {"native_isRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, + {"native_computeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, + {"native_incReserve","(JI)V", (void*) SkPathGlue::incReserve}, + {"native_moveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF}, + {"native_rMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo}, + {"native_lineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF}, + {"native_rLineTo","(JFF)V", (void*) SkPathGlue::rLineTo}, + {"native_quadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, + {"native_rQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo}, + {"native_cubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, + {"native_rCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo}, + {"native_arcTo","(JLandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, + {"native_close","(J)V", (void*) SkPathGlue::close}, + {"native_addRect","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, + {"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, + {"native_addOval","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, + {"native_addCircle","(JFFFI)V", (void*) SkPathGlue::addCircle}, + {"native_addArc","(JLandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, + {"native_addRoundRect","(JLandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, + {"native_addRoundRect","(JLandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, + {"native_addPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF}, + {"native_addPath","(JJ)V", (void*) SkPathGlue::addPath__Path}, + {"native_addPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix}, + {"native_offset","(JFFJ)V", (void*) SkPathGlue::offset__FFPath}, + {"native_offset","(JFF)V", (void*) SkPathGlue::offset__FF}, + {"native_setLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint}, + {"native_transform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath}, + {"native_transform","(JJ)V", (void*) SkPathGlue::transform__Matrix}, + {"native_op","(JJIJ)Z", (void*) SkPathGlue::op} }; int register_android_graphics_Path(JNIEnv* env) { diff --git a/core/jni/android/graphics/PathEffect.cpp b/core/jni/android/graphics/PathEffect.cpp index 0503614..2803758 100644 --- a/core/jni/android/graphics/PathEffect.cpp +++ b/core/jni/android/graphics/PathEffect.cpp @@ -11,22 +11,29 @@ class SkPathEffectGlue { public: - static void destructor(JNIEnv* env, jobject, SkPathEffect* effect) { + static void destructor(JNIEnv* env, jobject, jlong effectHandle) { + SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle); SkSafeUnref(effect); } - static SkPathEffect* Compose_constructor(JNIEnv* env, jobject, - SkPathEffect* outer, SkPathEffect* inner) { - return new SkComposePathEffect(outer, inner); + static jlong Compose_constructor(JNIEnv* env, jobject, + jlong outerHandle, jlong innerHandle) { + SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(outerHandle); + SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(innerHandle); + SkPathEffect* effect = new SkComposePathEffect(outer, inner); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Sum_constructor(JNIEnv* env, jobject, - SkPathEffect* first, SkPathEffect* second) { - return new SkSumPathEffect(first, second); + static jlong Sum_constructor(JNIEnv* env, jobject, + jlong firstHandle, jlong secondHandle) { + SkPathEffect* first = reinterpret_cast<SkPathEffect*>(firstHandle); + SkPathEffect* second = reinterpret_cast<SkPathEffect*>(secondHandle); + SkPathEffect* effect = new SkSumPathEffect(first, second); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Dash_constructor(JNIEnv* env, jobject, - jfloatArray intervalArray, float phase) { + static jlong Dash_constructor(JNIEnv* env, jobject, + jfloatArray intervalArray, jfloat phase) { AutoJavaFloatArray autoInterval(env, intervalArray); int count = autoInterval.length() & ~1; // even number float* values = autoInterval.ptr(); @@ -36,24 +43,29 @@ public: for (int i = 0; i < count; i++) { intervals[i] = SkFloatToScalar(values[i]); } - return new SkDashPathEffect(intervals, count, SkFloatToScalar(phase)); + SkPathEffect* effect = new SkDashPathEffect(intervals, count, SkFloatToScalar(phase)); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* OneD_constructor(JNIEnv* env, jobject, - const SkPath* shape, float advance, float phase, int style) { + static jlong OneD_constructor(JNIEnv* env, jobject, + jlong shapeHandle, jfloat advance, jfloat phase, jint style) { + const SkPath* shape = reinterpret_cast<SkPath*>(shapeHandle); SkASSERT(shape != NULL); - return new SkPath1DPathEffect(*shape, SkFloatToScalar(advance), + SkPathEffect* effect = new SkPath1DPathEffect(*shape, SkFloatToScalar(advance), SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Corner_constructor(JNIEnv* env, jobject, float radius){ - return new SkCornerPathEffect(SkFloatToScalar(radius)); + static jlong Corner_constructor(JNIEnv* env, jobject, jfloat radius){ + SkPathEffect* effect = new SkCornerPathEffect(SkFloatToScalar(radius)); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Discrete_constructor(JNIEnv* env, jobject, - float length, float deviation) { - return new SkDiscretePathEffect(SkFloatToScalar(length), + static jlong Discrete_constructor(JNIEnv* env, jobject, + jfloat length, jfloat deviation) { + SkPathEffect* effect = new SkDiscretePathEffect(SkFloatToScalar(length), SkFloatToScalar(deviation)); + return reinterpret_cast<jlong>(effect); } }; @@ -61,31 +73,31 @@ public: //////////////////////////////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gPathEffectMethods[] = { - { "nativeDestructor", "(I)V", (void*)SkPathEffectGlue::destructor } + { "nativeDestructor", "(J)V", (void*)SkPathEffectGlue::destructor } }; static JNINativeMethod gComposePathEffectMethods[] = { - { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Compose_constructor } + { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Compose_constructor } }; static JNINativeMethod gSumPathEffectMethods[] = { - { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Sum_constructor } + { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Sum_constructor } }; static JNINativeMethod gDashPathEffectMethods[] = { - { "nativeCreate", "([FF)I", (void*)SkPathEffectGlue::Dash_constructor } + { "nativeCreate", "([FF)J", (void*)SkPathEffectGlue::Dash_constructor } }; static JNINativeMethod gPathDashPathEffectMethods[] = { - { "nativeCreate", "(IFFI)I", (void*)SkPathEffectGlue::OneD_constructor } + { "nativeCreate", "(JFFI)J", (void*)SkPathEffectGlue::OneD_constructor } }; static JNINativeMethod gCornerPathEffectMethods[] = { - { "nativeCreate", "(F)I", (void*)SkPathEffectGlue::Corner_constructor } + { "nativeCreate", "(F)J", (void*)SkPathEffectGlue::Corner_constructor } }; static JNINativeMethod gDiscretePathEffectMethods[] = { - { "nativeCreate", "(FF)I", (void*)SkPathEffectGlue::Discrete_constructor } + { "nativeCreate", "(FF)J", (void*)SkPathEffectGlue::Discrete_constructor } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/PathMeasure.cpp b/core/jni/android/graphics/PathMeasure.cpp index 51a3f3a..8478a02 100644 --- a/core/jni/android/graphics/PathMeasure.cpp +++ b/core/jni/android/graphics/PathMeasure.cpp @@ -52,11 +52,24 @@ namespace android { class SkPathMeasureGlue { public: - static PathMeasurePair* create(JNIEnv* env, jobject clazz, const SkPath* path, jboolean forceClosed) { - return path ? new PathMeasurePair(*path, forceClosed) : new PathMeasurePair; + static jlong create(JNIEnv* env, jobject clazz, jlong pathHandle, + jboolean forceClosedHandle) { + const SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + bool forceClosed = (forceClosedHandle == JNI_TRUE); + PathMeasurePair* pair; + if(path) + pair = new PathMeasurePair(*path, forceClosed); + else + pair = new PathMeasurePair; + return reinterpret_cast<jlong>(pair); } - - static void setPath(JNIEnv* env, jobject clazz, PathMeasurePair* pair, const SkPath* path, jboolean forceClosed) { + + static void setPath(JNIEnv* env, jobject clazz, jlong pairHandle, + jlong pathHandle, jboolean forceClosedHandle) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + const SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + bool forceClosed = (forceClosedHandle == JNI_TRUE); + if (NULL == path) { pair->fPath.reset(); } else { @@ -64,11 +77,12 @@ public: } pair->fMeasure.setPath(&pair->fPath, forceClosed); } - - static jfloat getLength(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { - return SkScalarToFloat(pair->fMeasure.getLength()); + + static jfloat getLength(JNIEnv* env, jobject clazz, jlong pairHandle) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + return static_cast<jfloat>(SkScalarToFloat(pair->fMeasure.getLength())); } - + static void convertTwoElemFloatArray(JNIEnv* env, jfloatArray array, const SkScalar src[2]) { AutoJavaFloatArray autoArray(env, array, 2); jfloat* ptr = autoArray.ptr(); @@ -76,13 +90,14 @@ public: ptr[1] = SkScalarToFloat(src[1]); } - static jboolean getPosTan(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist, jfloatArray pos, jfloatArray tan) { + static jboolean getPosTan(JNIEnv* env, jobject clazz, jlong pairHandle, jfloat dist, jfloatArray pos, jfloatArray tan) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); SkScalar tmpPos[2], tmpTan[2]; SkScalar* posPtr = pos ? tmpPos : NULL; SkScalar* tanPtr = tan ? tmpTan : NULL; if (!pair->fMeasure.getPosTan(SkFloatToScalar(dist), (SkPoint*)posPtr, (SkVector*)tanPtr)) { - return false; + return JNI_FALSE; } if (pos) { @@ -91,42 +106,53 @@ public: if (tan) { convertTwoElemFloatArray(env, tan, tmpTan); } - return true; + return JNI_TRUE; } - - static jboolean getMatrix(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist, - SkMatrix* matrix, int flags) { - return pair->fMeasure.getMatrix(SkFloatToScalar(dist), matrix, (SkPathMeasure::MatrixFlags)flags); + + static jboolean getMatrix(JNIEnv* env, jobject clazz, jlong pairHandle, jfloat dist, + jlong matrixHandle, jint flags) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + bool result = pair->fMeasure.getMatrix(SkFloatToScalar(dist), matrix, (SkPathMeasure::MatrixFlags)flags); + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean getSegment(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat startF, - jfloat stopF, SkPath* dst, jboolean startWithMoveTo) { - return pair->fMeasure.getSegment(SkFloatToScalar(startF), SkFloatToScalar(stopF), dst, startWithMoveTo); + + static jboolean getSegment(JNIEnv* env, jobject clazz, jlong pairHandle, jfloat startF, + jfloat stopF, jlong dstHandle, jboolean startWithMoveTo) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); + bool result = pair->fMeasure.getSegment(SkFloatToScalar(startF), SkFloatToScalar(stopF), dst, startWithMoveTo); + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean isClosed(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { - return pair->fMeasure.isClosed(); + + static jboolean isClosed(JNIEnv* env, jobject clazz, jlong pairHandle) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + bool result = pair->fMeasure.isClosed(); + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean nextContour(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { - return pair->fMeasure.nextContour(); + + static jboolean nextContour(JNIEnv* env, jobject clazz, jlong pairHandle) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); + bool result = pair->fMeasure.nextContour(); + return result ? JNI_TRUE : JNI_FALSE; } - - static void destroy(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { + + static void destroy(JNIEnv* env, jobject clazz, jlong pairHandle) { + PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle); delete pair; } }; static JNINativeMethod methods[] = { - {"native_create", "(IZ)I", (void*) SkPathMeasureGlue::create }, - {"native_setPath", "(IIZ)V", (void*) SkPathMeasureGlue::setPath }, - {"native_getLength", "(I)F", (void*) SkPathMeasureGlue::getLength }, - {"native_getPosTan", "(IF[F[F)Z", (void*) SkPathMeasureGlue::getPosTan }, - {"native_getMatrix", "(IFII)Z", (void*) SkPathMeasureGlue::getMatrix }, - {"native_getSegment", "(IFFIZ)Z", (void*) SkPathMeasureGlue::getSegment }, - {"native_isClosed", "(I)Z", (void*) SkPathMeasureGlue::isClosed }, - {"native_nextContour", "(I)Z", (void*) SkPathMeasureGlue::nextContour }, - {"native_destroy", "(I)V", (void*) SkPathMeasureGlue::destroy } + {"native_create", "(JZ)J", (void*) SkPathMeasureGlue::create }, + {"native_setPath", "(JJZ)V", (void*) SkPathMeasureGlue::setPath }, + {"native_getLength", "(J)F", (void*) SkPathMeasureGlue::getLength }, + {"native_getPosTan", "(JF[F[F)Z", (void*) SkPathMeasureGlue::getPosTan }, + {"native_getMatrix", "(JFJI)Z", (void*) SkPathMeasureGlue::getMatrix }, + {"native_getSegment", "(JFFJZ)Z", (void*) SkPathMeasureGlue::getSegment }, + {"native_isClosed", "(J)Z", (void*) SkPathMeasureGlue::isClosed }, + {"native_nextContour", "(J)Z", (void*) SkPathMeasureGlue::nextContour }, + {"native_destroy", "(J)V", (void*) SkPathMeasureGlue::destroy } }; int register_android_graphics_PathMeasure(JNIEnv* env) { diff --git a/core/jni/android/graphics/Picture.cpp b/core/jni/android/graphics/Picture.cpp index fcf22b8..bac8ef7 100644 --- a/core/jni/android/graphics/Picture.cpp +++ b/core/jni/android/graphics/Picture.cpp @@ -28,71 +28,80 @@ namespace android { class SkPictureGlue { public: - static SkPicture* newPicture(JNIEnv* env, jobject, const SkPicture* src) { + static jlong newPicture(JNIEnv* env, jobject, jlong srcHandle) { + const SkPicture* src = reinterpret_cast<SkPicture*>(srcHandle); if (src) { - return new SkPicture(*src); + return reinterpret_cast<jlong>(new SkPicture(*src)); } else { - return new SkPicture; + return reinterpret_cast<jlong>(new SkPicture); } } - - static SkPicture* deserialize(JNIEnv* env, jobject, jobject jstream, - jbyteArray jstorage) { + + static jlong deserialize(JNIEnv* env, jobject, jobject jstream, + jbyteArray jstorage) { SkPicture* picture = NULL; SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage); if (strm) { picture = SkPicture::CreateFromStream(strm); delete strm; } - return picture; + return reinterpret_cast<jlong>(picture); } - - static void killPicture(JNIEnv* env, jobject, SkPicture* picture) { + + static void killPicture(JNIEnv* env, jobject, jlong pictureHandle) { + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(picture); picture->unref(); } - - static void draw(JNIEnv* env, jobject, SkCanvas* canvas, - SkPicture* picture) { + + static void draw(JNIEnv* env, jobject, jlong canvasHandle, + jlong pictureHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(canvas); SkASSERT(picture); picture->draw(canvas); } - - static bool serialize(JNIEnv* env, jobject, SkPicture* picture, + + static jboolean serialize(JNIEnv* env, jobject, jlong pictureHandle, jobject jstream, jbyteArray jstorage) { + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); if (NULL != strm) { picture->serialize(strm); delete strm; - return true; + return JNI_TRUE; } - return false; + return JNI_FALSE; } - - static int getWidth(JNIEnv* env, jobject jpic) { + + static jint getWidth(JNIEnv* env, jobject jpic) { NPE_CHECK_RETURN_ZERO(env, jpic); - return GraphicsJNI::getNativePicture(env, jpic)->width(); + int width = GraphicsJNI::getNativePicture(env, jpic)->width(); + return static_cast<jint>(width); } - - static int getHeight(JNIEnv* env, jobject jpic) { + + static jint getHeight(JNIEnv* env, jobject jpic) { NPE_CHECK_RETURN_ZERO(env, jpic); - return GraphicsJNI::getNativePicture(env, jpic)->height(); + int height = GraphicsJNI::getNativePicture(env, jpic)->height(); + return static_cast<jint>(height); } - - static SkCanvas* beginRecording(JNIEnv* env, jobject, SkPicture* pict, - int w, int h) { + + static jlong beginRecording(JNIEnv* env, jobject, jlong pictHandle, + jint w, jint h) { + SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle); // beginRecording does not ref its return value, it just returns it. SkCanvas* canvas = pict->beginRecording(w, h); // the java side will wrap this guy in a Canvas.java, which will call // unref in its finalizer, so we have to ref it here, so that both that // Canvas.java and our picture can both be owners canvas->ref(); - return canvas; + return reinterpret_cast<jlong>(canvas); } - - static void endRecording(JNIEnv* env, jobject, SkPicture* pict) { + + static void endRecording(JNIEnv* env, jobject, jlong pictHandle) { + SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle); pict->endRecording(); } }; @@ -100,30 +109,30 @@ public: static JNINativeMethod gPictureMethods[] = { {"getWidth", "()I", (void*) SkPictureGlue::getWidth}, {"getHeight", "()I", (void*) SkPictureGlue::getHeight}, - {"nativeConstructor", "(I)I", (void*) SkPictureGlue::newPicture}, - {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)I", (void*)SkPictureGlue::deserialize}, - {"nativeBeginRecording", "(III)I", (void*) SkPictureGlue::beginRecording}, - {"nativeEndRecording", "(I)V", (void*) SkPictureGlue::endRecording}, - {"nativeDraw", "(II)V", (void*) SkPictureGlue::draw}, - {"nativeWriteToStream", "(ILjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize}, - {"nativeDestructor","(I)V", (void*) SkPictureGlue::killPicture} + {"nativeConstructor", "(J)J", (void*) SkPictureGlue::newPicture}, + {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)J", (void*)SkPictureGlue::deserialize}, + {"nativeBeginRecording", "(JII)J", (void*) SkPictureGlue::beginRecording}, + {"nativeEndRecording", "(J)V", (void*) SkPictureGlue::endRecording}, + {"nativeDraw", "(JJ)V", (void*) SkPictureGlue::draw}, + {"nativeWriteToStream", "(JLjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize}, + {"nativeDestructor","(J)V", (void*) SkPictureGlue::killPicture} }; #include <android_runtime/AndroidRuntime.h> - + #define REG(env, name, array) \ result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ SK_ARRAY_COUNT(array)); \ if (result < 0) return result - + int register_android_graphics_Picture(JNIEnv* env) { int result; - + REG(env, "android/graphics/Picture", gPictureMethods); - + return result; } - + } diff --git a/core/jni/android/graphics/PorterDuff.cpp b/core/jni/android/graphics/PorterDuff.cpp index 47de601..8a49eb5 100644 --- a/core/jni/android/graphics/PorterDuff.cpp +++ b/core/jni/android/graphics/PorterDuff.cpp @@ -31,15 +31,15 @@ namespace android { class SkPorterDuffGlue { public: - static SkXfermode* CreateXfermode(JNIEnv* env, jobject, - SkPorterDuff::Mode mode) { - return SkPorterDuff::CreateXfermode(mode); + static jlong CreateXfermode(JNIEnv* env, jobject, jint modeHandle) { + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); + return reinterpret_cast<jlong>(SkPorterDuff::CreateXfermode(mode)); } }; static JNINativeMethod methods[] = { - {"nativeCreateXfermode","(I)I", (void*) SkPorterDuffGlue::CreateXfermode}, + {"nativeCreateXfermode","(I)J", (void*) SkPorterDuffGlue::CreateXfermode}, }; int register_android_graphics_PorterDuff(JNIEnv* env) { diff --git a/core/jni/android/graphics/Rasterizer.cpp b/core/jni/android/graphics/Rasterizer.cpp index 4e1b36a..b6450d0 100644 --- a/core/jni/android/graphics/Rasterizer.cpp +++ b/core/jni/android/graphics/Rasterizer.cpp @@ -31,14 +31,15 @@ namespace android { class SkRasterizerGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkRasterizer* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkRasterizer* obj = reinterpret_cast<SkRasterizer *>(objHandle); SkSafeUnref(obj); } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkRasterizerGlue::finalizer} + {"finalizer", "(J)V", (void*) SkRasterizerGlue::finalizer} }; int register_android_graphics_Rasterizer(JNIEnv* env) { diff --git a/core/jni/android/graphics/Region.cpp b/core/jni/android/graphics/Region.cpp index f0a7baf..912968a 100644 --- a/core/jni/android/graphics/Region.cpp +++ b/core/jni/android/graphics/Region.cpp @@ -29,95 +29,131 @@ namespace android { static jfieldID gRegion_nativeInstanceFieldID; +static inline jboolean boolTojboolean(bool value) { + return value ? JNI_TRUE : JNI_FALSE; +} + static inline SkRegion* GetSkRegion(JNIEnv* env, jobject regionObject) { - SkRegion* rgn = (SkRegion*)env->GetIntField(regionObject, gRegion_nativeInstanceFieldID); - SkASSERT(rgn != NULL); - return rgn; + jlong regionHandle = env->GetLongField(regionObject, gRegion_nativeInstanceFieldID); + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkASSERT(region != NULL); + return region; } -static SkRegion* Region_constructor(JNIEnv* env, jobject) { - return new SkRegion; +static jlong Region_constructor(JNIEnv* env, jobject) { + return reinterpret_cast<jlong>(new SkRegion); } -static void Region_destructor(JNIEnv* env, jobject, SkRegion* region) { +static void Region_destructor(JNIEnv* env, jobject, jlong regionHandle) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(region); delete region; } -static void Region_setRegion(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* src) { +static void Region_setRegion(JNIEnv* env, jobject, jlong dstHandle, jlong srcHandle) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* src = reinterpret_cast<SkRegion*>(srcHandle); SkASSERT(dst && src); *dst = *src; } -static jboolean Region_setRect(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom) { - return dst->setRect(left, top, right, bottom); +static jboolean Region_setRect(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + bool result = dst->setRect(left, top, right, bottom); + return boolTojboolean(result); } -static jboolean Region_setPath(JNIEnv* env, jobject, SkRegion* dst, - const SkPath* path, const SkRegion* clip) { +static jboolean Region_setPath(JNIEnv* env, jobject, jlong dstHandle, + jlong pathHandle, jlong clipHandle) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + const SkRegion* clip = reinterpret_cast<SkRegion*>(clipHandle); SkASSERT(dst && path && clip); - return dst->setPath(*path, *clip); + bool result = dst->setPath(*path, *clip); + return boolTojboolean(result); + } -static jboolean Region_getBounds(JNIEnv* env, jobject, SkRegion* region, jobject rectBounds) { +static jboolean Region_getBounds(JNIEnv* env, jobject, jlong regionHandle, jobject rectBounds) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); GraphicsJNI::irect_to_jrect(region->getBounds(), env, rectBounds); - return !region->isEmpty(); + bool result = !region->isEmpty(); + return boolTojboolean(result); } -static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, const SkRegion* region, SkPath* path) { - return region->getBoundaryPath(path); +static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, jlong regionHandle, jlong pathHandle) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + bool result = region->getBoundaryPath(path); + return boolTojboolean(result); } -static jboolean Region_op0(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom, int op) { +static jboolean Region_op0(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); SkIRect ir; ir.set(left, top, right, bottom); - return dst->op(ir, (SkRegion::Op)op); + bool result = dst->op(ir, (SkRegion::Op)op); + return boolTojboolean(result); } -static jboolean Region_op1(JNIEnv* env, jobject, SkRegion* dst, jobject rectObject, const SkRegion* region, int op) { +static jboolean Region_op1(JNIEnv* env, jobject, jlong dstHandle, jobject rectObject, jlong regionHandle, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkIRect ir; GraphicsJNI::jrect_to_irect(env, rectObject, &ir); - return dst->op(ir, *region, (SkRegion::Op)op); + bool result = dst->op(ir, *region, (SkRegion::Op)op); + return boolTojboolean(result); } -static jboolean Region_op2(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* region1, const SkRegion* region2, int op) { - return dst->op(*region1, *region2, (SkRegion::Op)op); +static jboolean Region_op2(JNIEnv* env, jobject, jlong dstHandle, jlong region1Handle, jlong region2Handle, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* region1 = reinterpret_cast<SkRegion*>(region1Handle); + const SkRegion* region2 = reinterpret_cast<SkRegion*>(region2Handle); + bool result = dst->op(*region1, *region2, (SkRegion::Op)op); + return boolTojboolean(result); } //////////////////////////////////// These are methods, not static static jboolean Region_isEmpty(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isEmpty(); + bool result = GetSkRegion(env, region)->isEmpty(); + return boolTojboolean(result); } static jboolean Region_isRect(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isRect(); + bool result = GetSkRegion(env, region)->isRect(); + return boolTojboolean(result); } static jboolean Region_isComplex(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isComplex(); + bool result = GetSkRegion(env, region)->isComplex(); + return boolTojboolean(result); } -static jboolean Region_contains(JNIEnv* env, jobject region, int x, int y) { - return GetSkRegion(env, region)->contains(x, y); +static jboolean Region_contains(JNIEnv* env, jobject region, jint x, jint y) { + bool result = GetSkRegion(env, region)->contains(x, y); + return boolTojboolean(result); } -static jboolean Region_quickContains(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { - return GetSkRegion(env, region)->quickContains(left, top, right, bottom); +static jboolean Region_quickContains(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) { + bool result = GetSkRegion(env, region)->quickContains(left, top, right, bottom); + return boolTojboolean(result); } -static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { +static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) { SkIRect ir; ir.set(left, top, right, bottom); - return GetSkRegion(env, region)->quickReject(ir); + bool result = GetSkRegion(env, region)->quickReject(ir); + return boolTojboolean(result); } static jboolean Region_quickRejectRgn(JNIEnv* env, jobject region, jobject other) { - return GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other)); + bool result = GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other)); + return boolTojboolean(result); } -static void Region_translate(JNIEnv* env, jobject region, int x, int y, jobject dst) { +static void Region_translate(JNIEnv* env, jobject region, jint x, jint y, jobject dst) { SkRegion* rgn = GetSkRegion(env, region); if (dst) rgn->translate(x, y, GetSkRegion(env, dst)); @@ -155,7 +191,8 @@ static void Region_scale(JNIEnv* env, jobject region, jfloat scale, jobject dst) scale_rgn(rgn, *rgn, scale); } -static jstring Region_toString(JNIEnv* env, jobject clazz, SkRegion* region) { +static jstring Region_toString(JNIEnv* env, jobject clazz, jlong regionHandle) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); char* str = region->toString(); if (str == NULL) { return NULL; @@ -167,7 +204,7 @@ static jstring Region_toString(JNIEnv* env, jobject clazz, SkRegion* region) { //////////////////////////////////////////////////////////////////////////////////////////////////////////// -static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel) +static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel) { if (parcel == NULL) { return NULL; @@ -179,13 +216,14 @@ static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject par size_t size = p->readInt32(); region->readFromMemory(p->readInplace(size), size); - return region; + return reinterpret_cast<jlong>(region); } -static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* region, jobject parcel) +static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, jlong regionHandle, jobject parcel) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); if (parcel == NULL) { - return false; + return JNI_FALSE; } android::Parcel* p = android::parcelForJavaObject(env, parcel); @@ -194,14 +232,16 @@ static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* p->writeInt32(size); region->writeToMemory(p->writeInplace(size)); - return true; + return JNI_TRUE; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// -static jboolean Region_equals(JNIEnv* env, jobject clazz, const SkRegion *r1, const SkRegion* r2) +static jboolean Region_equals(JNIEnv* env, jobject clazz, jlong r1Handle, jlong r2Handle) { - return (jboolean) (*r1 == *r2); + const SkRegion *r1 = reinterpret_cast<SkRegion*>(r1Handle); + const SkRegion *r2 = reinterpret_cast<SkRegion*>(r2Handle); + return boolTojboolean(*r1 == *r2); } //////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -217,20 +257,23 @@ struct RgnIterPair { } }; -static RgnIterPair* RegionIter_constructor(JNIEnv* env, jobject, const SkRegion* region) +static jlong RegionIter_constructor(JNIEnv* env, jobject, jlong regionHandle) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(region); - return new RgnIterPair(*region); + return reinterpret_cast<jlong>(new RgnIterPair(*region)); } -static void RegionIter_destructor(JNIEnv* env, jobject, RgnIterPair* pair) +static void RegionIter_destructor(JNIEnv* env, jobject, jlong pairHandle) { + RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle); SkASSERT(pair); delete pair; } -static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject rectObject) +static jboolean RegionIter_next(JNIEnv* env, jobject, jlong pairHandle, jobject rectObject) { + RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle); // the caller has checked that rectObject is not nul SkASSERT(pair); SkASSERT(rectObject); @@ -238,31 +281,31 @@ static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject if (!pair->fIter.done()) { GraphicsJNI::irect_to_jrect(pair->fIter.rect(), env, rectObject); pair->fIter.next(); - return true; + return JNI_TRUE; } - return false; + return JNI_FALSE; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gRegionIterMethods[] = { - { "nativeConstructor", "(I)I", (void*)RegionIter_constructor }, - { "nativeDestructor", "(I)V", (void*)RegionIter_destructor }, - { "nativeNext", "(ILandroid/graphics/Rect;)Z", (void*)RegionIter_next } + { "nativeConstructor", "(J)J", (void*)RegionIter_constructor }, + { "nativeDestructor", "(J)V", (void*)RegionIter_destructor }, + { "nativeNext", "(JLandroid/graphics/Rect;)Z", (void*)RegionIter_next } }; static JNINativeMethod gRegionMethods[] = { // these are static methods - { "nativeConstructor", "()I", (void*)Region_constructor }, - { "nativeDestructor", "(I)V", (void*)Region_destructor }, - { "nativeSetRegion", "(II)V", (void*)Region_setRegion }, - { "nativeSetRect", "(IIIII)Z", (void*)Region_setRect }, - { "nativeSetPath", "(III)Z", (void*)Region_setPath }, - { "nativeGetBounds", "(ILandroid/graphics/Rect;)Z", (void*)Region_getBounds }, - { "nativeGetBoundaryPath", "(II)Z", (void*)Region_getBoundaryPath }, - { "nativeOp", "(IIIIII)Z", (void*)Region_op0 }, - { "nativeOp", "(ILandroid/graphics/Rect;II)Z", (void*)Region_op1 }, - { "nativeOp", "(IIII)Z", (void*)Region_op2 }, + { "nativeConstructor", "()J", (void*)Region_constructor }, + { "nativeDestructor", "(J)V", (void*)Region_destructor }, + { "nativeSetRegion", "(JJ)V", (void*)Region_setRegion }, + { "nativeSetRect", "(JIIII)Z", (void*)Region_setRect }, + { "nativeSetPath", "(JJJ)Z", (void*)Region_setPath }, + { "nativeGetBounds", "(JLandroid/graphics/Rect;)Z", (void*)Region_getBounds }, + { "nativeGetBoundaryPath", "(JJ)Z", (void*)Region_getBoundaryPath }, + { "nativeOp", "(JIIIII)Z", (void*)Region_op0 }, + { "nativeOp", "(JLandroid/graphics/Rect;JI)Z", (void*)Region_op1 }, + { "nativeOp", "(JJJI)Z", (void*)Region_op2 }, // these are methods that take the java region object { "isEmpty", "()Z", (void*)Region_isEmpty }, { "isRect", "()Z", (void*)Region_isRect }, @@ -273,11 +316,11 @@ static JNINativeMethod gRegionMethods[] = { { "quickReject", "(Landroid/graphics/Region;)Z", (void*)Region_quickRejectRgn }, { "scale", "(FLandroid/graphics/Region;)V", (void*)Region_scale }, { "translate", "(IILandroid/graphics/Region;)V", (void*)Region_translate }, - { "nativeToString", "(I)Ljava/lang/String;", (void*)Region_toString }, + { "nativeToString", "(J)Ljava/lang/String;", (void*)Region_toString }, // parceling methods - { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", (void*)Region_createFromParcel }, - { "nativeWriteToParcel", "(ILandroid/os/Parcel;)Z", (void*)Region_writeToParcel }, - { "nativeEquals", "(II)Z", (void*)Region_equals }, + { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J", (void*)Region_createFromParcel }, + { "nativeWriteToParcel", "(JLandroid/os/Parcel;)Z", (void*)Region_writeToParcel }, + { "nativeEquals", "(JJ)Z", (void*)Region_equals }, }; int register_android_graphics_Region(JNIEnv* env) @@ -285,7 +328,7 @@ int register_android_graphics_Region(JNIEnv* env) jclass clazz = env->FindClass("android/graphics/Region"); SkASSERT(clazz); - gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "I"); + gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "J"); SkASSERT(gRegion_nativeInstanceFieldID); int result = android::AndroidRuntime::registerNativeMethods(env, "android/graphics/Region", diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp index 6323ab3..3047440 100644 --- a/core/jni/android/graphics/Shader.cpp +++ b/core/jni/android/graphics/Shader.cpp @@ -24,7 +24,7 @@ static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) { } } -static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, jfloatArray hsvArray) +static void Color_RGBToHSV(JNIEnv* env, jobject, jint red, jint green, jint blue, jfloatArray hsvArray) { SkScalar hsv[3]; SkRGBToHSV(red, green, blue, hsv); @@ -36,7 +36,7 @@ static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, j } } -static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArray) +static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvArray) { AutoJavaFloatArray autoHSV(env, hsvArray, 3); float* values = autoHSV.ptr();; @@ -46,13 +46,15 @@ static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArra hsv[i] = SkFloatToScalar(values[i]); } - return SkHSVToColor(alpha, hsv); + return static_cast<jint>(SkHSVToColor(alpha, hsv)); } /////////////////////////////////////////////////////////////////////////////////////////////// -static void Shader_destructor(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader) +static void Shader_destructor(JNIEnv* env, jobject o, jlong shaderHandle, jlong skiaShaderHandle) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle); SkSafeUnref(shader); // skiaShader == NULL when not !USE_OPENGL_RENDERER, so no need to delete it outside the ifdef #ifdef USE_OPENGL_RENDERER @@ -64,9 +66,12 @@ static void Shader_destructor(JNIEnv* env, jobject o, SkShader* shader, SkiaShad #endif } -static void Shader_setLocalMatrix(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader, - const SkMatrix* matrix) +static void Shader_setLocalMatrix(JNIEnv* env, jobject o, jlong shaderHandle, + jlong skiaShaderHandle, jlong matrixHandle) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); if (shader) { if (NULL == matrix) { shader->resetLocalMatrix(); @@ -82,24 +87,27 @@ static void Shader_setLocalMatrix(JNIEnv* env, jobject o, SkShader* shader, Skia /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* BitmapShader_constructor(JNIEnv* env, jobject o, const SkBitmap* bitmap, - int tileModeX, int tileModeY) +static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong bitmapHandle, + jint tileModeX, jint tileModeY) { + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); SkShader* s = SkShader::CreateBitmapShader(*bitmap, (SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* BitmapShader_postConstructor(JNIEnv* env, jobject o, SkShader* shader, - SkBitmap* bitmap, int tileModeX, int tileModeY) { +static jlong BitmapShader_postConstructor(JNIEnv* env, jobject o, jlong shaderHandle, + jlong bitmapHandle, jint tileModeX, jint tileModeY) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); #ifdef USE_OPENGL_RENDERER SkiaShader* skiaShader = new SkiaBitmapShader(bitmap, shader, static_cast<SkShader::TileMode>(tileModeX), static_cast<SkShader::TileMode>(tileModeY), NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -107,9 +115,9 @@ static SkiaShader* BitmapShader_postConstructor(JNIEnv* env, jobject o, SkShader /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* LinearGradient_create1(JNIEnv* env, jobject o, - float x0, float y0, float x1, float y1, - jintArray colorArray, jfloatArray posArray, int tileMode) +static jlong LinearGradient_create1(JNIEnv* env, jobject o, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, + jintArray colorArray, jfloatArray posArray, jint tileMode) { SkPoint pts[2]; pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); @@ -137,13 +145,14 @@ static SkShader* LinearGradient_create1(JNIEnv* env, jobject o, env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkiaShader* LinearGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x0, float y0, float x1, float y1, jintArray colorArray, - jfloatArray posArray, int tileMode) { +static jlong LinearGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, jintArray colorArray, + jfloatArray posArray, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -206,15 +215,16 @@ static SkiaShader* LinearGradient_postCreate1(JNIEnv* env, jobject o, SkShader* (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* LinearGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x0, float y0, float x1, float y1, int color0, int color1, int tileMode) { +static jlong LinearGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedBounds = new float[4]; storedBounds[0] = x0; storedBounds[1] = y0; storedBounds[2] = x1; storedBounds[3] = y1; @@ -231,15 +241,15 @@ static SkiaShader* LinearGradient_postCreate2(JNIEnv* env, jobject o, SkShader* storedPositions, 2, shader, static_cast<SkShader::TileMode>(tileMode), NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkShader* LinearGradient_create2(JNIEnv* env, jobject o, - float x0, float y0, float x1, float y1, - int color0, int color1, int tileMode) +static jlong LinearGradient_create2(JNIEnv* env, jobject o, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, + jint color0, jint color1, jint tileMode) { SkPoint pts[2]; pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); @@ -252,13 +262,13 @@ static SkShader* LinearGradient_create2(JNIEnv* env, jobject o, SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, float radius, - jintArray colorArray, jfloatArray posArray, int tileMode) { +static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius, + jintArray colorArray, jfloatArray posArray, jint tileMode) { SkPoint center; center.set(SkFloatToScalar(x), SkFloatToScalar(y)); @@ -285,11 +295,11 @@ static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, float radius, - int color0, int color1, int tileMode) { +static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius, + jint color0, jint color1, jint tileMode) { SkPoint center; center.set(SkFloatToScalar(x), SkFloatToScalar(y)); @@ -300,12 +310,13 @@ static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, SkShader* s = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL, 2, (SkShader::TileMode)tileMode); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, float radius, jintArray colorArray, jfloatArray posArray, int tileMode) { +static jlong RadialGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -335,15 +346,16 @@ static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, float radius, int color0, int color1, int tileMode) { +static jlong RadialGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jfloat radius, jint color0, jint color1, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedPositions = new float[2]; storedPositions[0] = 0.0f; storedPositions[1] = 1.0f; @@ -356,7 +368,7 @@ static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* storedPositions, 2, shader, (SkShader::TileMode) tileMode, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -364,7 +376,7 @@ static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* /////////////////////////////////////////////////////////////////////////////// -static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, +static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jintArray jcolors, jfloatArray jpositions) { size_t count = env->GetArrayLength(jcolors); const jint* colors = env->GetIntArrayElements(jcolors, NULL); @@ -388,10 +400,10 @@ static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors), JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y, +static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, int color0, int color1) { SkColor colors[2]; colors[0] = color0; @@ -399,12 +411,13 @@ static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y, SkShader* s = SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y), colors, NULL, 2); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* SweepGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, jintArray colorArray, jfloatArray posArray) { +static jlong SweepGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jintArray colorArray, jfloatArray posArray) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -433,15 +446,16 @@ static SkiaShader* SweepGradient_postCreate1(JNIEnv* env, jobject o, SkShader* s shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, int color0, int color1) { +static jlong SweepGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jint color0, jint color1) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedPositions = new float[2]; storedPositions[0] = 0.0f; storedPositions[1] = 1.0f; @@ -453,7 +467,7 @@ static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* s SkiaShader* skiaShader = new SkiaSweepGradientShader(x, y, storedColors, storedPositions, 2, shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -461,39 +475,57 @@ static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* s /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* ComposeShader_create1(JNIEnv* env, jobject o, - SkShader* shaderA, SkShader* shaderB, SkXfermode* mode) +static jlong ComposeShader_create1(JNIEnv* env, jobject o, + jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle) { - return new SkComposeShader(shaderA, shaderB, mode); + SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle); + SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle); + SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle); + SkShader* shader = new SkComposeShader(shaderA, shaderB, mode); + return reinterpret_cast<jlong>(shader); } -static SkShader* ComposeShader_create2(JNIEnv* env, jobject o, - SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode porterDuffMode) +static jlong ComposeShader_create2(JNIEnv* env, jobject o, + jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle) { + SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle); + SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle); + SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle); SkAutoUnref au(SkPorterDuff::CreateXfermode(porterDuffMode)); SkXfermode* mode = (SkXfermode*) au.get(); - return new SkComposeShader(shaderA, shaderB, mode); + SkShader* shader = new SkComposeShader(shaderA, shaderB, mode); + return reinterpret_cast<jlong>(shader); } -static SkiaShader* ComposeShader_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - SkiaShader* shaderA, SkiaShader* shaderB, SkPorterDuff::Mode porterDuffMode) { +static jlong ComposeShader_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle); + SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle); + SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle); + SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle); SkXfermode::Mode mode = SkPorterDuff::ToXfermodeMode(porterDuffMode); - return new SkiaComposeShader(shaderA, shaderB, mode, shader); + SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, mode, shader); + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* ComposeShader_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - SkiaShader* shaderA, SkiaShader* shaderB, SkXfermode* mode) { +static jlong ComposeShader_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle); + SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle); + SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle); + SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle); SkXfermode::Mode skiaMode; if (!SkXfermode::IsMode(mode, &skiaMode)) { // TODO: Support other modes skiaMode = SkXfermode::kSrcOver_Mode; } - return new SkiaComposeShader(shaderA, shaderB, skiaMode, shader); + SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, skiaMode, shader); + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -507,41 +539,41 @@ static JNINativeMethod gColorMethods[] = { }; static JNINativeMethod gShaderMethods[] = { - { "nativeDestructor", "(II)V", (void*)Shader_destructor }, - { "nativeSetLocalMatrix", "(III)V", (void*)Shader_setLocalMatrix } + { "nativeDestructor", "(JJ)V", (void*)Shader_destructor }, + { "nativeSetLocalMatrix", "(JJJ)V", (void*)Shader_setLocalMatrix } }; static JNINativeMethod gBitmapShaderMethods[] = { - { "nativeCreate", "(III)I", (void*)BitmapShader_constructor }, - { "nativePostCreate", "(IIII)I", (void*)BitmapShader_postConstructor } + { "nativeCreate", "(JII)J", (void*)BitmapShader_constructor }, + { "nativePostCreate", "(JJII)J", (void*)BitmapShader_postConstructor } }; static JNINativeMethod gLinearGradientMethods[] = { - { "nativeCreate1", "(FFFF[I[FI)I", (void*)LinearGradient_create1 }, - { "nativeCreate2", "(FFFFIII)I", (void*)LinearGradient_create2 }, - { "nativePostCreate1", "(IFFFF[I[FI)I", (void*)LinearGradient_postCreate1 }, - { "nativePostCreate2", "(IFFFFIII)I", (void*)LinearGradient_postCreate2 } + { "nativeCreate1", "(FFFF[I[FI)J", (void*)LinearGradient_create1 }, + { "nativeCreate2", "(FFFFIII)J", (void*)LinearGradient_create2 }, + { "nativePostCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_postCreate1 }, + { "nativePostCreate2", "(JFFFFIII)J", (void*)LinearGradient_postCreate2 } }; static JNINativeMethod gRadialGradientMethods[] = { - { "nativeCreate1", "(FFF[I[FI)I", (void*)RadialGradient_create1 }, - { "nativeCreate2", "(FFFIII)I", (void*)RadialGradient_create2 }, - { "nativePostCreate1", "(IFFF[I[FI)I", (void*)RadialGradient_postCreate1 }, - { "nativePostCreate2", "(IFFFIII)I", (void*)RadialGradient_postCreate2 } + { "nativeCreate1", "(FFF[I[FI)J", (void*)RadialGradient_create1 }, + { "nativeCreate2", "(FFFIII)J", (void*)RadialGradient_create2 }, + { "nativePostCreate1", "(JFFF[I[FI)J", (void*)RadialGradient_postCreate1 }, + { "nativePostCreate2", "(JFFFIII)J", (void*)RadialGradient_postCreate2 } }; static JNINativeMethod gSweepGradientMethods[] = { - { "nativeCreate1", "(FF[I[F)I", (void*)SweepGradient_create1 }, - { "nativeCreate2", "(FFII)I", (void*)SweepGradient_create2 }, - { "nativePostCreate1", "(IFF[I[F)I", (void*)SweepGradient_postCreate1 }, - { "nativePostCreate2", "(IFFII)I", (void*)SweepGradient_postCreate2 } + { "nativeCreate1", "(FF[I[F)J", (void*)SweepGradient_create1 }, + { "nativeCreate2", "(FFII)J", (void*)SweepGradient_create2 }, + { "nativePostCreate1", "(JFF[I[F)J", (void*)SweepGradient_postCreate1 }, + { "nativePostCreate2", "(JFFII)J", (void*)SweepGradient_postCreate2 } }; static JNINativeMethod gComposeShaderMethods[] = { - { "nativeCreate1", "(III)I", (void*)ComposeShader_create1 }, - { "nativeCreate2", "(III)I", (void*)ComposeShader_create2 }, - { "nativePostCreate1", "(IIII)I", (void*)ComposeShader_postCreate1 }, - { "nativePostCreate2", "(IIII)I", (void*)ComposeShader_postCreate2 } + { "nativeCreate1", "(JJJ)J", (void*)ComposeShader_create1 }, + { "nativeCreate2", "(JJI)J", (void*)ComposeShader_create2 }, + { "nativePostCreate1", "(JJJJ)J", (void*)ComposeShader_postCreate1 }, + { "nativePostCreate2", "(JJJI)J", (void*)ComposeShader_postCreate2 } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/SurfaceTexture.cpp b/core/jni/android/graphics/SurfaceTexture.cpp index 0c9b3bc..3116955 100644 --- a/core/jni/android/graphics/SurfaceTexture.cpp +++ b/core/jni/android/graphics/SurfaceTexture.cpp @@ -55,28 +55,28 @@ static void SurfaceTexture_setSurfaceTexture(JNIEnv* env, jobject thiz, const sp<GLConsumer>& surfaceTexture) { GLConsumer* const p = - (GLConsumer*)env->GetIntField(thiz, fields.surfaceTexture); + (GLConsumer*)env->GetLongField(thiz, fields.surfaceTexture); if (surfaceTexture.get()) { surfaceTexture->incStrong((void*)SurfaceTexture_setSurfaceTexture); } if (p) { p->decStrong((void*)SurfaceTexture_setSurfaceTexture); } - env->SetIntField(thiz, fields.surfaceTexture, (int)surfaceTexture.get()); + env->SetLongField(thiz, fields.surfaceTexture, (jlong)surfaceTexture.get()); } static void SurfaceTexture_setBufferQueue(JNIEnv* env, jobject thiz, const sp<BufferQueue>& bq) { BufferQueue* const p = - (BufferQueue*)env->GetIntField(thiz, fields.bufferQueue); + (BufferQueue*)env->GetLongField(thiz, fields.bufferQueue); if (bq.get()) { bq->incStrong((void*)SurfaceTexture_setBufferQueue); } if (p) { p->decStrong((void*)SurfaceTexture_setBufferQueue); } - env->SetIntField(thiz, fields.bufferQueue, (int)bq.get()); + env->SetLongField(thiz, fields.bufferQueue, (jlong)bq.get()); } static void SurfaceTexture_setFrameAvailableListener(JNIEnv* env, @@ -84,22 +84,22 @@ static void SurfaceTexture_setFrameAvailableListener(JNIEnv* env, { GLConsumer::FrameAvailableListener* const p = (GLConsumer::FrameAvailableListener*) - env->GetIntField(thiz, fields.frameAvailableListener); + env->GetLongField(thiz, fields.frameAvailableListener); if (listener.get()) { listener->incStrong((void*)SurfaceTexture_setSurfaceTexture); } if (p) { p->decStrong((void*)SurfaceTexture_setSurfaceTexture); } - env->SetIntField(thiz, fields.frameAvailableListener, (int)listener.get()); + env->SetLongField(thiz, fields.frameAvailableListener, (jlong)listener.get()); } sp<GLConsumer> SurfaceTexture_getSurfaceTexture(JNIEnv* env, jobject thiz) { - return (GLConsumer*)env->GetIntField(thiz, fields.surfaceTexture); + return (GLConsumer*)env->GetLongField(thiz, fields.surfaceTexture); } sp<IGraphicBufferProducer> SurfaceTexture_getProducer(JNIEnv* env, jobject thiz) { - return (BufferQueue*)env->GetIntField(thiz, fields.bufferQueue); + return (BufferQueue*)env->GetLongField(thiz, fields.bufferQueue); } sp<ANativeWindow> android_SurfaceTexture_getNativeWindow(JNIEnv* env, jobject thiz) { @@ -201,19 +201,19 @@ void JNISurfaceTextureContext::onFrameAvailable() static void SurfaceTexture_classInit(JNIEnv* env, jclass clazz) { fields.surfaceTexture = env->GetFieldID(clazz, - ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID, "I"); + ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID, "J"); if (fields.surfaceTexture == NULL) { ALOGE("can't find android/graphics/SurfaceTexture.%s", ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID); } fields.bufferQueue = env->GetFieldID(clazz, - ANDROID_GRAPHICS_BUFFERQUEUE_JNI_ID, "I"); + ANDROID_GRAPHICS_BUFFERQUEUE_JNI_ID, "J"); if (fields.bufferQueue == NULL) { ALOGE("can't find android/graphics/SurfaceTexture.%s", ANDROID_GRAPHICS_BUFFERQUEUE_JNI_ID); } fields.frameAvailableListener = env->GetFieldID(clazz, - ANDROID_GRAPHICS_FRAMEAVAILABLELISTENER_JNI_ID, "I"); + ANDROID_GRAPHICS_FRAMEAVAILABLELISTENER_JNI_ID, "J"); if (fields.frameAvailableListener == NULL) { ALOGE("can't find android/graphics/SurfaceTexture.%s", ANDROID_GRAPHICS_FRAMEAVAILABLELISTENER_JNI_ID); diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp index d10a960..8164625 100644 --- a/core/jni/android/graphics/Typeface.cpp +++ b/core/jni/android/graphics/Typeface.cpp @@ -28,8 +28,9 @@ private: const char* fCStr; }; -static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name, - SkTypeface::Style style) { +static jlong Typeface_create(JNIEnv* env, jobject, jstring name, + jint styleHandle) { + SkTypeface::Style style = static_cast<SkTypeface::Style>(styleHandle); SkTypeface* face = NULL; if (NULL != name) { @@ -48,10 +49,11 @@ static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name, if (NULL == face) { face = SkTypeface::CreateFromName(NULL, style); } - return face; + return reinterpret_cast<jlong>(face); } -static SkTypeface* Typeface_createFromTypeface(JNIEnv* env, jobject, SkTypeface* family, int style) { +static jlong Typeface_createFromTypeface(JNIEnv* env, jobject, jlong familyHandle, jint style) { + SkTypeface* family = reinterpret_cast<SkTypeface*>(familyHandle); SkTypeface* face = SkTypeface::CreateFromTypeface(family, (SkTypeface::Style)style); // Try to find the closest matching font, using the standard heuristic if (NULL == face) { @@ -63,20 +65,22 @@ static SkTypeface* Typeface_createFromTypeface(JNIEnv* env, jobject, SkTypeface* if (NULL == face) { face = SkTypeface::CreateFromName(NULL, (SkTypeface::Style)style); } - return face; + return reinterpret_cast<jlong>(face); } -static void Typeface_unref(JNIEnv* env, jobject obj, SkTypeface* face) { +static void Typeface_unref(JNIEnv* env, jobject obj, jlong faceHandle) { + SkTypeface* face = reinterpret_cast<SkTypeface*>(faceHandle); SkSafeUnref(face); } -static int Typeface_getStyle(JNIEnv* env, jobject obj, SkTypeface* face) { - return face->style(); +static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) { + SkTypeface* face = reinterpret_cast<SkTypeface*>(faceHandle); + return static_cast<jint>(face->style()); } -static SkTypeface* Typeface_createFromAsset(JNIEnv* env, jobject, - jobject jassetMgr, - jstring jpath) { +static jlong Typeface_createFromAsset(JNIEnv* env, jobject, + jobject jassetMgr, + jstring jpath) { NPE_CHECK_RETURN_ZERO(env, jassetMgr); NPE_CHECK_RETURN_ZERO(env, jpath); @@ -100,27 +104,27 @@ static SkTypeface* Typeface_createFromAsset(JNIEnv* env, jobject, // need to unref it here or it won't be freed later on stream->unref(); - return face; + return reinterpret_cast<jlong>(face); } -static SkTypeface* Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) { +static jlong Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) { NPE_CHECK_RETURN_ZERO(env, jpath); AutoJavaStringToUTF8 str(env, jpath); - return SkTypeface::CreateFromFile(str.c_str()); + return reinterpret_cast<jlong>(SkTypeface::CreateFromFile(str.c_str())); } /////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gTypefaceMethods[] = { - { "nativeCreate", "(Ljava/lang/String;I)I", (void*)Typeface_create }, - { "nativeCreateFromTypeface", "(II)I", (void*)Typeface_createFromTypeface }, - { "nativeUnref", "(I)V", (void*)Typeface_unref }, - { "nativeGetStyle", "(I)I", (void*)Typeface_getStyle }, - { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)I", + { "nativeCreate", "(Ljava/lang/String;I)J", (void*)Typeface_create }, + { "nativeCreateFromTypeface", "(JI)J", (void*)Typeface_createFromTypeface }, + { "nativeUnref", "(J)V", (void*)Typeface_unref }, + { "nativeGetStyle", "(J)I", (void*)Typeface_getStyle }, + { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)J", (void*)Typeface_createFromAsset }, - { "nativeCreateFromFile", "(Ljava/lang/String;)I", + { "nativeCreateFromFile", "(Ljava/lang/String;)J", (void*)Typeface_createFromFile }, }; diff --git a/core/jni/android/graphics/Xfermode.cpp b/core/jni/android/graphics/Xfermode.cpp index 976a91f..eedceb7 100644 --- a/core/jni/android/graphics/Xfermode.cpp +++ b/core/jni/android/graphics/Xfermode.cpp @@ -26,35 +26,37 @@ namespace android { class SkXfermodeGlue { public: - static void finalizer(JNIEnv* env, jobject, SkXfermode* obj) + static void finalizer(JNIEnv* env, jobject, jlong objHandle) { + SkXfermode* obj = reinterpret_cast<SkXfermode *>(objHandle); SkSafeUnref(obj); } - static SkXfermode* avoid_create(JNIEnv* env, jobject, SkColor opColor, - U8CPU tolerance, SkAvoidXfermode::Mode mode) + static jlong avoid_create(JNIEnv* env, jobject, jint opColor, + jint tolerance, jint modeHandle) { - return new SkAvoidXfermode(opColor, tolerance, mode); + SkAvoidXfermode::Mode mode = static_cast<SkAvoidXfermode::Mode>(modeHandle); + return reinterpret_cast<jlong>(new SkAvoidXfermode(opColor, tolerance, mode)); } - - static SkXfermode* pixelxor_create(JNIEnv* env, jobject, SkColor opColor) + + static jlong pixelxor_create(JNIEnv* env, jobject, jint opColor) { - return new SkPixelXorXfermode(opColor); + return reinterpret_cast<jlong>(new SkPixelXorXfermode(opColor)); } }; /////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gXfermodeMethods[] = { - {"finalizer", "(I)V", (void*) SkXfermodeGlue::finalizer} + {"finalizer", "(J)V", (void*) SkXfermodeGlue::finalizer} }; static JNINativeMethod gAvoidMethods[] = { - {"nativeCreate", "(III)I", (void*) SkXfermodeGlue::avoid_create} + {"nativeCreate", "(III)J", (void*) SkXfermodeGlue::avoid_create} }; static JNINativeMethod gPixelXorMethods[] = { - {"nativeCreate", "(I)I", (void*) SkXfermodeGlue::pixelxor_create} + {"nativeCreate", "(I)J", (void*) SkXfermodeGlue::pixelxor_create} }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/YuvToJpegEncoder.cpp b/core/jni/android/graphics/YuvToJpegEncoder.cpp index f386905..799782d 100644 --- a/core/jni/android/graphics/YuvToJpegEncoder.cpp +++ b/core/jni/android/graphics/YuvToJpegEncoder.cpp @@ -217,8 +217,8 @@ void Yuv422IToJpegEncoder::configSamplingFactors(jpeg_compress_struct* cinfo) { /////////////////////////////////////////////////////////////////////////////// static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv, - int format, int width, int height, jintArray offsets, - jintArray strides, int jpegQuality, jobject jstream, + jint format, jint width, jint height, jintArray offsets, + jintArray strides, jint jpegQuality, jobject jstream, jbyteArray jstorage) { jbyte* yuv = env->GetByteArrayElements(inYuv, NULL); SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); @@ -227,7 +227,7 @@ static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv, jint* imgStrides = env->GetIntArrayElements(strides, NULL); YuvToJpegEncoder* encoder = YuvToJpegEncoder::create(format, imgStrides); if (encoder == NULL) { - return false; + return JNI_FALSE; } encoder->encode(strm, yuv, width, height, imgOffsets, jpegQuality); @@ -235,7 +235,7 @@ static jboolean YuvImage_compressToJpeg(JNIEnv* env, jobject, jbyteArray inYuv, env->ReleaseByteArrayElements(inYuv, yuv, 0); env->ReleaseIntArrayElements(offsets, imgOffsets, 0); env->ReleaseIntArrayElements(strides, imgStrides, 0); - return true; + return JNI_TRUE; } /////////////////////////////////////////////////////////////////////////////// diff --git a/core/jni/android/opengl/util.cpp b/core/jni/android/opengl/util.cpp index 4bb091d..a17f328 100644 --- a/core/jni/android/opengl/util.cpp +++ b/core/jni/android/opengl/util.cpp @@ -389,7 +389,7 @@ static void computeFrustum(const float* m, float* f) { } static -int util_frustumCullSpheres(JNIEnv *env, jclass clazz, +jint util_frustumCullSpheres(JNIEnv *env, jclass clazz, jfloatArray mvp_ref, jint mvpOffset, jfloatArray spheres_ref, jint spheresOffset, jint spheresCount, jintArray results_ref, jint resultsOffset, jint resultsCapacity) { @@ -436,7 +436,7 @@ int util_frustumCullSpheres(JNIEnv *env, jclass clazz, */ static -int util_visibilityTest(JNIEnv *env, jclass clazz, +jint util_visibilityTest(JNIEnv *env, jclass clazz, jfloatArray ws_ref, jint wsOffset, jfloatArray positions_ref, jint positionsOffset, jcharArray indices_ref, jint indicesOffset, jint indexCount) { @@ -553,7 +553,7 @@ static jfieldID nativeBitmapID = 0; void nativeUtilsClassInit(JNIEnv *env, jclass clazz) { jclass bitmapClass = env->FindClass("android/graphics/Bitmap"); - nativeBitmapID = env->GetFieldID(bitmapClass, "mNativeBitmap", "I"); + nativeBitmapID = env->GetFieldID(bitmapClass, "mNativeBitmap", "J"); } extern void setGLDebugLevel(int level); @@ -630,7 +630,7 @@ static jint util_getInternalFormat(JNIEnv *env, jclass clazz, jobject jbitmap) { SkBitmap const * nativeBitmap = - (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID); const SkBitmap& bitmap(*nativeBitmap); SkBitmap::Config config = bitmap.config(); return getInternalFormat(config); @@ -640,7 +640,7 @@ static jint util_getType(JNIEnv *env, jclass clazz, jobject jbitmap) { SkBitmap const * nativeBitmap = - (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID); const SkBitmap& bitmap(*nativeBitmap); SkBitmap::Config config = bitmap.config(); return getType(config); @@ -651,7 +651,7 @@ static jint util_texImage2D(JNIEnv *env, jclass clazz, jobject jbitmap, jint type, jint border) { SkBitmap const * nativeBitmap = - (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID); const SkBitmap& bitmap(*nativeBitmap); SkBitmap::Config config = bitmap.config(); if (internalformat < 0) { @@ -700,7 +700,7 @@ static jint util_texSubImage2D(JNIEnv *env, jclass clazz, jobject jbitmap, jint format, jint type) { SkBitmap const * nativeBitmap = - (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + (SkBitmap const *)env->GetLongField(jbitmap, nativeBitmapID); const SkBitmap& bitmap(*nativeBitmap); SkBitmap::Config config = bitmap.config(); if (format < 0) { @@ -773,7 +773,7 @@ getPointer(JNIEnv *_env, jobject buffer, jint *remaining) pointer = _env->CallStaticLongMethod(nioAccessClass, getBasePointerID, buffer); if (pointer != 0L) { - return (void *) (jint) pointer; + return reinterpret_cast<void *>(pointer); } return NULL; } @@ -974,7 +974,7 @@ static jboolean etc1_isValid(JNIEnv *env, jclass clazz, result = etc1_pkm_is_valid((etc1_byte*) headerB.getData()); } } - return result; + return result ? JNI_TRUE : JNI_FALSE; } /** @@ -997,7 +997,7 @@ static jint etc1_getWidth(JNIEnv *env, jclass clazz, /** * Read the image height from a PKM header */ -static int etc1_getHeight(JNIEnv *env, jclass clazz, +static jint etc1_getHeight(JNIEnv *env, jclass clazz, jobject header) { jint result = 0; BufferHelper headerB(env, header); diff --git a/core/jni/android_app_NativeActivity.cpp b/core/jni/android_app_NativeActivity.cpp index 5418006..9c44093 100644 --- a/core/jni/android_app_NativeActivity.cpp +++ b/core/jni/android_app_NativeActivity.cpp @@ -241,10 +241,10 @@ static int mainWorkCallback(int fd, int events, void* data) { // ------------------------------------------------------------------------ -static jint +static jlong loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jstring funcName, jobject messageQueue, jstring internalDataDir, jstring obbDir, - jstring externalDataDir, int sdkVersion, + jstring externalDataDir, jint sdkVersion, jobject jAssetMgr, jbyteArray savedState) { LOG_TRACE("loadNativeCode_native"); @@ -338,11 +338,11 @@ loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jstring funcName } } - return (jint)code; + return (jlong)code; } static void -unloadNativeCode_native(JNIEnv* env, jobject clazz, jint handle) +unloadNativeCode_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("unloadNativeCode_native"); if (handle != 0) { @@ -352,7 +352,7 @@ unloadNativeCode_native(JNIEnv* env, jobject clazz, jint handle) } static void -onStart_native(JNIEnv* env, jobject clazz, jint handle) +onStart_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onStart_native"); if (handle != 0) { @@ -364,7 +364,7 @@ onStart_native(JNIEnv* env, jobject clazz, jint handle) } static void -onResume_native(JNIEnv* env, jobject clazz, jint handle) +onResume_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onResume_native"); if (handle != 0) { @@ -376,7 +376,7 @@ onResume_native(JNIEnv* env, jobject clazz, jint handle) } static jbyteArray -onSaveInstanceState_native(JNIEnv* env, jobject clazz, jint handle) +onSaveInstanceState_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onSaveInstanceState_native"); @@ -403,7 +403,7 @@ onSaveInstanceState_native(JNIEnv* env, jobject clazz, jint handle) } static void -onPause_native(JNIEnv* env, jobject clazz, jint handle) +onPause_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onPause_native"); if (handle != 0) { @@ -415,7 +415,7 @@ onPause_native(JNIEnv* env, jobject clazz, jint handle) } static void -onStop_native(JNIEnv* env, jobject clazz, jint handle) +onStop_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onStop_native"); if (handle != 0) { @@ -427,7 +427,7 @@ onStop_native(JNIEnv* env, jobject clazz, jint handle) } static void -onConfigurationChanged_native(JNIEnv* env, jobject clazz, jint handle) +onConfigurationChanged_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onConfigurationChanged_native"); if (handle != 0) { @@ -439,7 +439,7 @@ onConfigurationChanged_native(JNIEnv* env, jobject clazz, jint handle) } static void -onLowMemory_native(JNIEnv* env, jobject clazz, jint handle) +onLowMemory_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onLowMemory_native"); if (handle != 0) { @@ -451,7 +451,7 @@ onLowMemory_native(JNIEnv* env, jobject clazz, jint handle) } static void -onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jint handle, jboolean focused) +onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jlong handle, jboolean focused) { LOG_TRACE("onWindowFocusChanged_native"); if (handle != 0) { @@ -463,7 +463,7 @@ onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jint handle, jboolean fo } static void -onSurfaceCreated_native(JNIEnv* env, jobject clazz, jint handle, jobject surface) +onSurfaceCreated_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface) { LOG_TRACE("onSurfaceCreated_native"); if (handle != 0) { @@ -483,7 +483,7 @@ static int32_t getWindowProp(ANativeWindow* window, int what) { } static void -onSurfaceChanged_native(JNIEnv* env, jobject clazz, jint handle, jobject surface, +onSurfaceChanged_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface, jint format, jint width, jint height) { LOG_TRACE("onSurfaceChanged_native"); @@ -524,7 +524,7 @@ onSurfaceChanged_native(JNIEnv* env, jobject clazz, jint handle, jobject surface } static void -onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jint handle) +onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onSurfaceRedrawNeeded_native"); if (handle != 0) { @@ -536,7 +536,7 @@ onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jint handle) } static void -onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jobject surface) +onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface) { LOG_TRACE("onSurfaceDestroyed_native"); if (handle != 0) { @@ -550,7 +550,7 @@ onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jobject surfa } static void -onInputQueueCreated_native(JNIEnv* env, jobject clazz, jint handle, jint queuePtr) +onInputQueueCreated_native(JNIEnv* env, jobject clazz, jlong handle, jlong queuePtr) { LOG_TRACE("onInputChannelCreated_native"); if (handle != 0) { @@ -563,7 +563,7 @@ onInputQueueCreated_native(JNIEnv* env, jobject clazz, jint handle, jint queuePt } static void -onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jint queuePtr) +onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jlong handle, jlong queuePtr) { LOG_TRACE("onInputChannelDestroyed_native"); if (handle != 0) { @@ -576,7 +576,7 @@ onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jint queue } static void -onContentRectChanged_native(JNIEnv* env, jobject clazz, jint handle, +onContentRectChanged_native(JNIEnv* env, jobject clazz, jlong handle, jint x, jint y, jint w, jint h) { LOG_TRACE("onContentRectChanged_native"); @@ -594,26 +594,26 @@ onContentRectChanged_native(JNIEnv* env, jobject clazz, jint handle, } static const JNINativeMethod g_methods[] = { - { "loadNativeCode", "(Ljava/lang/String;Ljava/lang/String;Landroid/os/MessageQueue;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILandroid/content/res/AssetManager;[B)I", + { "loadNativeCode", "(Ljava/lang/String;Ljava/lang/String;Landroid/os/MessageQueue;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILandroid/content/res/AssetManager;[B)J", (void*)loadNativeCode_native }, - { "unloadNativeCode", "(I)V", (void*)unloadNativeCode_native }, - { "onStartNative", "(I)V", (void*)onStart_native }, - { "onResumeNative", "(I)V", (void*)onResume_native }, - { "onSaveInstanceStateNative", "(I)[B", (void*)onSaveInstanceState_native }, - { "onPauseNative", "(I)V", (void*)onPause_native }, - { "onStopNative", "(I)V", (void*)onStop_native }, - { "onConfigurationChangedNative", "(I)V", (void*)onConfigurationChanged_native }, - { "onLowMemoryNative", "(I)V", (void*)onLowMemory_native }, - { "onWindowFocusChangedNative", "(IZ)V", (void*)onWindowFocusChanged_native }, - { "onSurfaceCreatedNative", "(ILandroid/view/Surface;)V", (void*)onSurfaceCreated_native }, - { "onSurfaceChangedNative", "(ILandroid/view/Surface;III)V", (void*)onSurfaceChanged_native }, - { "onSurfaceRedrawNeededNative", "(ILandroid/view/Surface;)V", (void*)onSurfaceRedrawNeeded_native }, - { "onSurfaceDestroyedNative", "(I)V", (void*)onSurfaceDestroyed_native }, - { "onInputQueueCreatedNative", "(II)V", + { "unloadNativeCode", "(J)V", (void*)unloadNativeCode_native }, + { "onStartNative", "(J)V", (void*)onStart_native }, + { "onResumeNative", "(J)V", (void*)onResume_native }, + { "onSaveInstanceStateNative", "(J)[B", (void*)onSaveInstanceState_native }, + { "onPauseNative", "(J)V", (void*)onPause_native }, + { "onStopNative", "(J)V", (void*)onStop_native }, + { "onConfigurationChangedNative", "(J)V", (void*)onConfigurationChanged_native }, + { "onLowMemoryNative", "(J)V", (void*)onLowMemory_native }, + { "onWindowFocusChangedNative", "(JZ)V", (void*)onWindowFocusChanged_native }, + { "onSurfaceCreatedNative", "(JLandroid/view/Surface;)V", (void*)onSurfaceCreated_native }, + { "onSurfaceChangedNative", "(JLandroid/view/Surface;III)V", (void*)onSurfaceChanged_native }, + { "onSurfaceRedrawNeededNative", "(JLandroid/view/Surface;)V", (void*)onSurfaceRedrawNeeded_native }, + { "onSurfaceDestroyedNative", "(J)V", (void*)onSurfaceDestroyed_native }, + { "onInputQueueCreatedNative", "(JJ)V", (void*)onInputQueueCreated_native }, - { "onInputQueueDestroyedNative", "(II)V", + { "onInputQueueDestroyedNative", "(JJ)V", (void*)onInputQueueDestroyed_native }, - { "onContentRectChangedNative", "(IIIII)V", (void*)onContentRectChanged_native }, + { "onContentRectChangedNative", "(JIIII)V", (void*)onContentRectChanged_native }, }; static const char* const kNativeActivityPathName = "android/app/NativeActivity"; diff --git a/core/jni/android_app_backup_FullBackup.cpp b/core/jni/android_app_backup_FullBackup.cpp index 2ca645a..3cfaa82 100644 --- a/core/jni/android_app_backup_FullBackup.cpp +++ b/core/jni/android_app_backup_FullBackup.cpp @@ -70,7 +70,7 @@ static struct { * path: absolute path to the file to be saved * dataOutput: the BackupDataOutput object that we're saving into */ -static int backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, +static jint backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, jstring domainObj, jstring linkdomain, jstring rootpathObj, jstring pathObj, jobject dataOutputObj) { int ret; @@ -92,22 +92,22 @@ static int backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, if (packagenamechars) env->ReleaseStringUTFChars(packageNameObj, packagenamechars); // Extract the data output fd - BackupDataWriter* writer = (BackupDataWriter*) env->GetIntField(dataOutputObj, + BackupDataWriter* writer = (BackupDataWriter*) env->GetLongField(dataOutputObj, sBackupDataOutput.mBackupWriter); // Validate if (!writer) { ALOGE("No output stream provided [%s]", path.string()); - return -1; + return (jint) -1; } if (path.length() < rootpath.length()) { ALOGE("file path [%s] shorter than root path [%s]", path.string(), rootpath.string()); - return -1; + return (jint) -1; } - return write_tarfile(packageName, domain, rootpath, path, writer); + return (jint) write_tarfile(packageName, domain, rootpath, path, writer); } static const JNINativeMethod g_methods[] = { @@ -121,7 +121,7 @@ int register_android_app_backup_FullBackup(JNIEnv* env) jclass clazz = env->FindClass("android/app/backup/BackupDataOutput"); LOG_FATAL_IF(clazz == NULL, "Unable to find class android.app.backup.BackupDataOutput"); - sBackupDataOutput.mBackupWriter = env->GetFieldID(clazz, "mBackupWriter", "I"); + sBackupDataOutput.mBackupWriter = env->GetFieldID(clazz, "mBackupWriter", "J"); LOG_FATAL_IF(sBackupDataOutput.mBackupwriter == NULL, "Unable to find mBackupWriter field in android.app.backup.BackupDataOutput"); diff --git a/core/jni/android_backup_BackupDataInput.cpp b/core/jni/android_backup_BackupDataInput.cpp index 25b0007..90763b0 100644 --- a/core/jni/android_backup_BackupDataInput.cpp +++ b/core/jni/android_backup_BackupDataInput.cpp @@ -29,25 +29,25 @@ namespace android static jfieldID s_keyField = 0; static jfieldID s_dataSizeField = 0; -static int +static jlong ctor_native(JNIEnv* env, jobject clazz, jobject fileDescriptor) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); if (fd == -1) { - return NULL; + return (jlong)NULL; } - return (int)new BackupDataReader(fd); + return (jlong)new BackupDataReader(fd); } static void -dtor_native(JNIEnv* env, jobject clazz, int r) +dtor_native(JNIEnv* env, jobject clazz, jlong r) { delete (BackupDataReader*)r; } static jint -readNextHeader_native(JNIEnv* env, jobject clazz, int r, jobject entity) +readNextHeader_native(JNIEnv* env, jobject clazz, jlong r, jobject entity) { int err; bool done; @@ -89,7 +89,7 @@ readNextHeader_native(JNIEnv* env, jobject clazz, int r, jobject entity) } static jint -readEntityData_native(JNIEnv* env, jobject clazz, int r, jbyteArray data, int offset, int size) +readEntityData_native(JNIEnv* env, jobject clazz, jlong r, jbyteArray data, jint offset, jint size) { int err; BackupDataReader* reader = (BackupDataReader*)r; @@ -112,7 +112,7 @@ readEntityData_native(JNIEnv* env, jobject clazz, int r, jbyteArray data, int of } static jint -skipEntityData_native(JNIEnv* env, jobject clazz, int r) +skipEntityData_native(JNIEnv* env, jobject clazz, jlong r) { int err; BackupDataReader* reader = (BackupDataReader*)r; @@ -123,12 +123,12 @@ skipEntityData_native(JNIEnv* env, jobject clazz, int r) } static const JNINativeMethod g_methods[] = { - { "ctor", "(Ljava/io/FileDescriptor;)I", (void*)ctor_native }, - { "dtor", "(I)V", (void*)dtor_native }, - { "readNextHeader_native", "(ILandroid/app/backup/BackupDataInput$EntityHeader;)I", + { "ctor", "(Ljava/io/FileDescriptor;)J", (void*)ctor_native }, + { "dtor", "(J)V", (void*)dtor_native }, + { "readNextHeader_native", "(JLandroid/app/backup/BackupDataInput$EntityHeader;)I", (void*)readNextHeader_native }, - { "readEntityData_native", "(I[BII)I", (void*)readEntityData_native }, - { "skipEntityData_native", "(I)I", (void*)skipEntityData_native }, + { "readEntityData_native", "(J[BII)I", (void*)readEntityData_native }, + { "skipEntityData_native", "(J)I", (void*)skipEntityData_native }, }; int register_android_backup_BackupDataInput(JNIEnv* env) diff --git a/core/jni/android_backup_BackupDataOutput.cpp b/core/jni/android_backup_BackupDataOutput.cpp index e8f0fb8..8244e1b 100644 --- a/core/jni/android_backup_BackupDataOutput.cpp +++ b/core/jni/android_backup_BackupDataOutput.cpp @@ -25,25 +25,25 @@ namespace android { -static int +static jlong ctor_native(JNIEnv* env, jobject clazz, jobject fileDescriptor) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); if (fd == -1) { - return NULL; + return (jlong)NULL; } - return (int)new BackupDataWriter(fd); + return (jlong)new BackupDataWriter(fd); } static void -dtor_native(JNIEnv* env, jobject clazz, int w) +dtor_native(JNIEnv* env, jobject clazz, jlong w) { delete (BackupDataWriter*)w; } static jint -writeEntityHeader_native(JNIEnv* env, jobject clazz, int w, jstring key, int dataSize) +writeEntityHeader_native(JNIEnv* env, jobject clazz, jlong w, jstring key, jint dataSize) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -56,11 +56,11 @@ writeEntityHeader_native(JNIEnv* env, jobject clazz, int w, jstring key, int dat env->ReleaseStringUTFChars(key, keyUTF); - return err; + return (jint)err; } static jint -writeEntityData_native(JNIEnv* env, jobject clazz, int w, jbyteArray data, int size) +writeEntityData_native(JNIEnv* env, jobject clazz, jlong w, jbyteArray data, jint size) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -79,11 +79,11 @@ writeEntityData_native(JNIEnv* env, jobject clazz, int w, jbyteArray data, int s env->ReleaseByteArrayElements(data, dataBytes, JNI_ABORT); - return err; + return (jint)err; } static void -setKeyPrefix_native(JNIEnv* env, jobject clazz, int w, jstring keyPrefixObj) +setKeyPrefix_native(JNIEnv* env, jobject clazz, jlong w, jstring keyPrefixObj) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -97,11 +97,11 @@ setKeyPrefix_native(JNIEnv* env, jobject clazz, int w, jstring keyPrefixObj) } static const JNINativeMethod g_methods[] = { - { "ctor", "(Ljava/io/FileDescriptor;)I", (void*)ctor_native }, - { "dtor", "(I)V", (void*)dtor_native }, - { "writeEntityHeader_native", "(ILjava/lang/String;I)I", (void*)writeEntityHeader_native }, - { "writeEntityData_native", "(I[BI)I", (void*)writeEntityData_native }, - { "setKeyPrefix_native", "(ILjava/lang/String;)V", (void*)setKeyPrefix_native }, + { "ctor", "(Ljava/io/FileDescriptor;)J", (void*)ctor_native }, + { "dtor", "(J)V", (void*)dtor_native }, + { "writeEntityHeader_native", "(JLjava/lang/String;I)I", (void*)writeEntityHeader_native }, + { "writeEntityData_native", "(J[BI)I", (void*)writeEntityData_native }, + { "setKeyPrefix_native", "(JLjava/lang/String;)V", (void*)setKeyPrefix_native }, }; int register_android_backup_BackupDataOutput(JNIEnv* env) diff --git a/core/jni/android_backup_BackupHelperDispatcher.cpp b/core/jni/android_backup_BackupHelperDispatcher.cpp index 3e36677..a8b7d44 100644 --- a/core/jni/android_backup_BackupHelperDispatcher.cpp +++ b/core/jni/android_backup_BackupHelperDispatcher.cpp @@ -40,7 +40,7 @@ struct chunk_header_v1 { static jfieldID s_chunkSizeField = 0; static jfieldID s_keyPrefixField = 0; -static int +static jint readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) { chunk_header_v1 flattenedHeader; @@ -52,7 +52,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) amt = read(fd, &flattenedHeader.headerSize, sizeof(flattenedHeader.headerSize)); if (amt != sizeof(flattenedHeader.headerSize)) { - return -1; + return (jint) -1; } int remainingHeader = flattenedHeader.headerSize - sizeof(flattenedHeader.headerSize); @@ -62,7 +62,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) if (remainingHeader > 0) { lseek(fd, remainingHeader, SEEK_CUR); // >0 means skip this chunk - return 1; + return (jint) 1; } } @@ -70,7 +70,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize)); if (amt <= 0) { ALOGW("Failed reading chunk header"); - return -1; + return (jint) -1; } remainingHeader -= sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize); @@ -80,7 +80,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) if (remainingHeader > 0) { lseek(fd, remainingHeader, SEEK_CUR); // >0 means skip this chunk - return 1; + return (jint) 1; } } @@ -96,13 +96,13 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) remainingHeader < flattenedHeader.nameLength) { ALOGW("Malformed V1 header remainingHeader=%d dataSize=%d nameLength=%d", remainingHeader, flattenedHeader.dataSize, flattenedHeader.nameLength); - return -1; + return (jint) -1; } buf = keyPrefix.lockBuffer(flattenedHeader.nameLength); if (buf == NULL) { ALOGW("unable to allocate %d bytes", flattenedHeader.nameLength); - return -1; + return (jint) -1; } amt = read(fd, buf, flattenedHeader.nameLength); @@ -119,17 +119,17 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) env->SetIntField(headerObj, s_chunkSizeField, flattenedHeader.dataSize); env->SetObjectField(headerObj, s_keyPrefixField, env->NewStringUTF(keyPrefix.string())); - return 0; + return (jint) 0; } -static int +static jint skipChunk_native(JNIEnv* env, jobject clazz, jobject fdObj, jint bytesToSkip) { int fd = jniGetFDFromFileDescriptor(env, fdObj); lseek(fd, bytesToSkip, SEEK_CUR); - return 0; + return (jint) 0; } static int @@ -139,7 +139,7 @@ padding_len(int len) return len == 0 ? len : 4 - len; } -static int +static jint allocateHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) { int pos; @@ -161,10 +161,10 @@ allocateHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdO lseek(fd, headerSize, SEEK_CUR); - return pos; + return (jint) pos; } -static int +static jint writeHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj, jint pos) { int err; @@ -188,26 +188,26 @@ writeHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj, lseek(fd, pos, SEEK_SET); err = write(fd, &header, sizeof(chunk_header_v1)); if (err != sizeof(chunk_header_v1)) { - return errno; + return (jint) errno; } buf = env->GetStringUTFChars(nameObj, NULL); err = write(fd, buf, header.nameLength); env->ReleaseStringUTFChars(nameObj, buf); if (err != header.nameLength) { - return errno; + return (jint) errno; } if (namePadding != 0) { int zero = 0; err = write(fd, &zero, namePadding); if (err != namePadding) { - return errno; + return (jint) errno; } } lseek(fd, prevPos, SEEK_SET); - return 0; + return (jint) 0; } static const JNINativeMethod g_methods[] = { diff --git a/core/jni/android_backup_FileBackupHelperBase.cpp b/core/jni/android_backup_FileBackupHelperBase.cpp index bb3a751..66e3e9d 100644 --- a/core/jni/android_backup_FileBackupHelperBase.cpp +++ b/core/jni/android_backup_FileBackupHelperBase.cpp @@ -25,20 +25,20 @@ namespace android { -static int +static jlong ctor(JNIEnv* env, jobject clazz) { - return (int)new RestoreHelperBase(); + return (jlong)new RestoreHelperBase(); } static void -dtor(JNIEnv* env, jobject clazz, jint ptr) +dtor(JNIEnv* env, jobject clazz, jlong ptr) { delete (RestoreHelperBase*)ptr; } -static int -performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, int data, +static jint +performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, jlong data, jobject newState, jobjectArray files, jobjectArray keys) { int err; @@ -72,12 +72,12 @@ performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, int data, } free(keysUTF); - return err; + return (jint) err; } -static int -writeFile_native(JNIEnv* env, jobject clazz, jint ptr, jstring filenameObj, int backupReaderPtr) +static jint +writeFile_native(JNIEnv* env, jobject clazz, jlong ptr, jstring filenameObj, jlong backupReaderPtr) { int err; RestoreHelperBase* restore = (RestoreHelperBase*)ptr; @@ -90,11 +90,11 @@ writeFile_native(JNIEnv* env, jobject clazz, jint ptr, jstring filenameObj, int env->ReleaseStringUTFChars(filenameObj, filename); - return err; + return (jint) err; } -static int -writeSnapshot_native(JNIEnv* env, jobject clazz, jint ptr, jobject fileDescriptor) +static jint +writeSnapshot_native(JNIEnv* env, jobject clazz, jlong ptr, jobject fileDescriptor) { int err; @@ -103,17 +103,17 @@ writeSnapshot_native(JNIEnv* env, jobject clazz, jint ptr, jobject fileDescripto err = restore->WriteSnapshot(fd); - return err; + return (jint) err; } static const JNINativeMethod g_methods[] = { - { "ctor", "()I", (void*)ctor }, - { "dtor", "(I)V", (void*)dtor }, + { "ctor", "()J", (void*)ctor }, + { "dtor", "(J)V", (void*)dtor }, { "performBackup_native", - "(Ljava/io/FileDescriptor;ILjava/io/FileDescriptor;[Ljava/lang/String;[Ljava/lang/String;)I", + "(Ljava/io/FileDescriptor;JLjava/io/FileDescriptor;[Ljava/lang/String;[Ljava/lang/String;)I", (void*)performBackup_native }, - { "writeFile_native", "(ILjava/lang/String;I)I", (void*)writeFile_native }, - { "writeSnapshot_native", "(ILjava/io/FileDescriptor;)I", (void*)writeSnapshot_native }, + { "writeFile_native", "(JLjava/lang/String;J)I", (void*)writeFile_native }, + { "writeSnapshot_native", "(JLjava/io/FileDescriptor;)I", (void*)writeSnapshot_native }, }; int register_android_backup_FileBackupHelperBase(JNIEnv* env) diff --git a/core/jni/android_database_CursorWindow.cpp b/core/jni/android_database_CursorWindow.cpp index ea02f53..67f3879 100644 --- a/core/jni/android_database_CursorWindow.cpp +++ b/core/jni/android_database_CursorWindow.cpp @@ -58,7 +58,7 @@ static void throwUnknownTypeException(JNIEnv * env, jint type) { jniThrowException(env, "java/lang/IllegalStateException", msg.string()); } -static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) { +static jlong nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) { String8 name; const char* nameStr = env->GetStringUTFChars(nameObj, NULL); name.setTo(nameStr); @@ -73,10 +73,10 @@ static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursor } LOG_WINDOW("nativeInitializeEmpty: window = %p", window); - return reinterpret_cast<jint>(window); + return reinterpret_cast<jlong>(window); } -static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) { +static jlong nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); CursorWindow* window; @@ -88,10 +88,10 @@ static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) LOG_WINDOW("nativeInitializeFromBinder: numRows = %d, numColumns = %d, window = %p", window->getNumRows(), window->getNumColumns(), window); - return reinterpret_cast<jint>(window); + return reinterpret_cast<jlong>(window); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); if (window) { LOG_WINDOW("Closing window %p", window); @@ -99,12 +99,12 @@ static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) { } } -static jstring nativeGetName(JNIEnv* env, jclass clazz, jint windowPtr) { +static jstring nativeGetName(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); return env->NewStringUTF(window->name().string()); } -static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr, +static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jlong windowPtr, jobject parcelObj) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); Parcel* parcel = parcelForJavaObject(env, parcelObj); @@ -117,7 +117,7 @@ static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr, } } -static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { +static void nativeClear(JNIEnv * env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Clearing window %p", window); status_t status = window->clear(); @@ -126,30 +126,30 @@ static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { } } -static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) { +static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); return window->getNumRows(); } -static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jlong windowPtr, jint columnNum) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->setNumColumns(columnNum); return status == OK; } -static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jint windowPtr) { +static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->allocRow(); return status == OK; } -static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jint windowPtr) { +static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); window->freeLastRow(); } -static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr, +static jint nativeGetType(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window); @@ -164,7 +164,7 @@ static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr, return window->getFieldSlotType(fieldSlot); } -static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, +static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window); @@ -199,7 +199,7 @@ static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, return NULL; } -static jstring nativeGetString(JNIEnv* env, jclass clazz, jint windowPtr, +static jstring nativeGetString(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting string for %d,%d from %p", row, column, window); @@ -291,7 +291,7 @@ static void clearCharArrayBuffer(JNIEnv* env, jobject bufferObj) { } } -static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr, +static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column, jobject bufferObj) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Copying string for %d,%d from %p", row, column, window); @@ -330,7 +330,7 @@ static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr, +static jlong nativeGetLong(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting long for %d,%d from %p", row, column, window); @@ -361,7 +361,7 @@ static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr, +static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting double for %d,%d from %p", row, column, window); @@ -392,7 +392,7 @@ static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jlong windowPtr, jbyteArray valueObj, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); jsize len = env->GetArrayLength(valueObj); @@ -410,7 +410,7 @@ static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutString(JNIEnv* env, jclass clazz, jlong windowPtr, jstring valueObj, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); @@ -432,7 +432,7 @@ static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutLong(JNIEnv* env, jclass clazz, jlong windowPtr, jlong value, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putLong(row, column, value); @@ -446,7 +446,7 @@ static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jlong windowPtr, jdouble value, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putDouble(row, column, value); @@ -460,7 +460,7 @@ static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutNull(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putNull(row, column); @@ -477,47 +477,47 @@ static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, static JNINativeMethod sMethods[] = { /* name, signature, funcPtr */ - { "nativeCreate", "(Ljava/lang/String;I)I", + { "nativeCreate", "(Ljava/lang/String;I)J", (void*)nativeCreate }, - { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", + { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J", (void*)nativeCreateFromParcel }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeWriteToParcel", "(ILandroid/os/Parcel;)V", + { "nativeWriteToParcel", "(JLandroid/os/Parcel;)V", (void*)nativeWriteToParcel }, - { "nativeGetName", "(I)Ljava/lang/String;", + { "nativeGetName", "(J)Ljava/lang/String;", (void*)nativeGetName }, - { "nativeClear", "(I)V", + { "nativeClear", "(J)V", (void*)nativeClear }, - { "nativeGetNumRows", "(I)I", + { "nativeGetNumRows", "(J)I", (void*)nativeGetNumRows }, - { "nativeSetNumColumns", "(II)Z", + { "nativeSetNumColumns", "(JI)Z", (void*)nativeSetNumColumns }, - { "nativeAllocRow", "(I)Z", + { "nativeAllocRow", "(J)Z", (void*)nativeAllocRow }, - { "nativeFreeLastRow", "(I)V", + { "nativeFreeLastRow", "(J)V", (void*)nativeFreeLastRow }, - { "nativeGetType", "(III)I", + { "nativeGetType", "(JII)I", (void*)nativeGetType }, - { "nativeGetBlob", "(III)[B", + { "nativeGetBlob", "(JII)[B", (void*)nativeGetBlob }, - { "nativeGetString", "(III)Ljava/lang/String;", + { "nativeGetString", "(JII)Ljava/lang/String;", (void*)nativeGetString }, - { "nativeGetLong", "(III)J", + { "nativeGetLong", "(JII)J", (void*)nativeGetLong }, - { "nativeGetDouble", "(III)D", + { "nativeGetDouble", "(JII)D", (void*)nativeGetDouble }, - { "nativeCopyStringToBuffer", "(IIILandroid/database/CharArrayBuffer;)V", + { "nativeCopyStringToBuffer", "(JIILandroid/database/CharArrayBuffer;)V", (void*)nativeCopyStringToBuffer }, - { "nativePutBlob", "(I[BII)Z", + { "nativePutBlob", "(J[BII)Z", (void*)nativePutBlob }, - { "nativePutString", "(ILjava/lang/String;II)Z", + { "nativePutString", "(JLjava/lang/String;II)Z", (void*)nativePutString }, - { "nativePutLong", "(IJII)Z", + { "nativePutLong", "(JJII)Z", (void*)nativePutLong }, - { "nativePutDouble", "(IDII)Z", + { "nativePutDouble", "(JDII)Z", (void*)nativePutDouble }, - { "nativePutNull", "(III)Z", + { "nativePutNull", "(JII)Z", (void*)nativePutNull }, }; diff --git a/core/jni/android_database_SQLiteConnection.cpp b/core/jni/android_database_SQLiteConnection.cpp index 6e496fd..ae56432 100644 --- a/core/jni/android_database_SQLiteConnection.cpp +++ b/core/jni/android_database_SQLiteConnection.cpp @@ -109,7 +109,7 @@ static int sqliteProgressHandlerCallback(void* data) { } -static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags, +static jlong nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags, jstring labelStr, jboolean enableTrace, jboolean enableProfile) { int sqliteFlags; if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) { @@ -170,10 +170,10 @@ static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlag } ALOGV("Opened connection %p with label '%s'", db, label.string()); - return reinterpret_cast<jint>(connection); + return reinterpret_cast<jlong>(connection); } -static void nativeClose(JNIEnv* env, jclass clazz, jint connectionPtr) { +static void nativeClose(JNIEnv* env, jclass clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); if (connection) { @@ -243,7 +243,7 @@ static void sqliteCustomFunctionDestructor(void* data) { env->DeleteGlobalRef(functionObjGlobal); } -static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connectionPtr, +static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jlong connectionPtr, jobject functionObj) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -267,7 +267,7 @@ static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connect } } -static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint connectionPtr, +static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jlong connectionPtr, jstring localeStr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -280,7 +280,7 @@ static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint con } } -static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr, +static jlong nativePrepareStatement(JNIEnv* env, jclass clazz, jlong connectionPtr, jstring sqlString) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -308,11 +308,11 @@ static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr } ALOGV("Prepared statement %p on connection %p", statement, connection->db); - return reinterpret_cast<jint>(statement); + return reinterpret_cast<jlong>(statement); } -static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -323,32 +323,32 @@ static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPt sqlite3_finalize(statement); } -static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_bind_parameter_count(statement); } -static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_stmt_readonly(statement) != 0; } -static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_column_count(statement); } -static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index) { +static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -363,8 +363,8 @@ static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr return NULL; } -static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index) { +static void nativeBindNull(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -374,8 +374,8 @@ static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jlong value) { +static void nativeBindLong(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jlong value) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -385,8 +385,8 @@ static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jdouble value) { +static void nativeBindDouble(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jdouble value) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -396,8 +396,8 @@ static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jstring valueString) { +static void nativeBindString(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jstring valueString) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -411,8 +411,8 @@ static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jbyteArray valueArray) { +static void nativeBindBlob(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jbyteArray valueArray) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -425,8 +425,8 @@ static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -450,8 +450,8 @@ static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_st return err; } -static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeExecute(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -459,7 +459,7 @@ static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr, } static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -468,7 +468,7 @@ static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz, } static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -486,7 +486,7 @@ static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3 } static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -498,7 +498,7 @@ static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz, } static jstring nativeExecuteForString(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -548,7 +548,7 @@ static int createAshmemRegionWithData(JNIEnv* env, const void* data, size_t leng } static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -665,7 +665,7 @@ static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window, } static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr, jint windowPtr, + jlong connectionPtr, jlong statementPtr, jlong windowPtr, jint startPos, jint requiredPos, jboolean countAllRows) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -760,7 +760,7 @@ static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz, return result; } -static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) { +static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); int cur = -1; @@ -769,12 +769,12 @@ static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) return cur; } -static void nativeCancel(JNIEnv* env, jobject clazz, jint connectionPtr) { +static void nativeCancel(JNIEnv* env, jobject clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); connection->canceled = true; } -static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr, +static void nativeResetCancel(JNIEnv* env, jobject clazz, jlong connectionPtr, jboolean cancelable) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); connection->canceled = false; @@ -791,57 +791,57 @@ static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr, static JNINativeMethod sMethods[] = { /* name, signature, funcPtr */ - { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)I", + { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)J", (void*)nativeOpen }, - { "nativeClose", "(I)V", + { "nativeClose", "(J)V", (void*)nativeClose }, - { "nativeRegisterCustomFunction", "(ILandroid/database/sqlite/SQLiteCustomFunction;)V", + { "nativeRegisterCustomFunction", "(JLandroid/database/sqlite/SQLiteCustomFunction;)V", (void*)nativeRegisterCustomFunction }, - { "nativeRegisterLocalizedCollators", "(ILjava/lang/String;)V", + { "nativeRegisterLocalizedCollators", "(JLjava/lang/String;)V", (void*)nativeRegisterLocalizedCollators }, - { "nativePrepareStatement", "(ILjava/lang/String;)I", + { "nativePrepareStatement", "(JLjava/lang/String;)J", (void*)nativePrepareStatement }, - { "nativeFinalizeStatement", "(II)V", + { "nativeFinalizeStatement", "(JJ)V", (void*)nativeFinalizeStatement }, - { "nativeGetParameterCount", "(II)I", + { "nativeGetParameterCount", "(JJ)I", (void*)nativeGetParameterCount }, - { "nativeIsReadOnly", "(II)Z", + { "nativeIsReadOnly", "(JJ)Z", (void*)nativeIsReadOnly }, - { "nativeGetColumnCount", "(II)I", + { "nativeGetColumnCount", "(JJ)I", (void*)nativeGetColumnCount }, - { "nativeGetColumnName", "(III)Ljava/lang/String;", + { "nativeGetColumnName", "(JJI)Ljava/lang/String;", (void*)nativeGetColumnName }, - { "nativeBindNull", "(III)V", + { "nativeBindNull", "(JJI)V", (void*)nativeBindNull }, - { "nativeBindLong", "(IIIJ)V", + { "nativeBindLong", "(JJIJ)V", (void*)nativeBindLong }, - { "nativeBindDouble", "(IIID)V", + { "nativeBindDouble", "(JJID)V", (void*)nativeBindDouble }, - { "nativeBindString", "(IIILjava/lang/String;)V", + { "nativeBindString", "(JJILjava/lang/String;)V", (void*)nativeBindString }, - { "nativeBindBlob", "(III[B)V", + { "nativeBindBlob", "(JJI[B)V", (void*)nativeBindBlob }, - { "nativeResetStatementAndClearBindings", "(II)V", + { "nativeResetStatementAndClearBindings", "(JJ)V", (void*)nativeResetStatementAndClearBindings }, - { "nativeExecute", "(II)V", + { "nativeExecute", "(JJ)V", (void*)nativeExecute }, - { "nativeExecuteForLong", "(II)J", + { "nativeExecuteForLong", "(JJ)J", (void*)nativeExecuteForLong }, - { "nativeExecuteForString", "(II)Ljava/lang/String;", + { "nativeExecuteForString", "(JJ)Ljava/lang/String;", (void*)nativeExecuteForString }, - { "nativeExecuteForBlobFileDescriptor", "(II)I", + { "nativeExecuteForBlobFileDescriptor", "(JJ)I", (void*)nativeExecuteForBlobFileDescriptor }, - { "nativeExecuteForChangedRowCount", "(II)I", + { "nativeExecuteForChangedRowCount", "(JJ)I", (void*)nativeExecuteForChangedRowCount }, - { "nativeExecuteForLastInsertedRowId", "(II)J", + { "nativeExecuteForLastInsertedRowId", "(JJ)J", (void*)nativeExecuteForLastInsertedRowId }, - { "nativeExecuteForCursorWindow", "(IIIIIZ)J", + { "nativeExecuteForCursorWindow", "(JJJIIZ)J", (void*)nativeExecuteForCursorWindow }, - { "nativeGetDbLookaside", "(I)I", + { "nativeGetDbLookaside", "(J)I", (void*)nativeGetDbLookaside }, - { "nativeCancel", "(I)V", + { "nativeCancel", "(J)V", (void*)nativeCancel }, - { "nativeResetCancel", "(IZ)V", + { "nativeResetCancel", "(JZ)V", (void*)nativeResetCancel }, }; diff --git a/core/jni/android_hardware_Camera.cpp b/core/jni/android_hardware_Camera.cpp index 09d8d0f..58b61ba 100644 --- a/core/jni/android_hardware_Camera.cpp +++ b/core/jni/android_hardware_Camera.cpp @@ -113,7 +113,7 @@ sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, JNICameraContext** pCont { sp<Camera> camera; Mutex::Autolock _l(sLock); - JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); if (context != NULL) { camera = context->getCamera(); } @@ -500,7 +500,7 @@ static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, camera->setListener(context); // save context in opaque field - env->SetIntField(thiz, fields.context, (int)context.get()); + env->SetLongField(thiz, fields.context, (jlong)context.get()); } // disconnect from camera service @@ -515,10 +515,10 @@ static void android_hardware_Camera_release(JNIEnv *env, jobject thiz) sp<Camera> camera; { Mutex::Autolock _l(sLock); - context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); // Make sure we do not attempt to callback on a deleted Java object. - env->SetIntField(thiz, fields.context, 0); + env->SetLongField(thiz, fields.context, 0); } // clean up if release has not been called before @@ -627,13 +627,13 @@ static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz) c->stopPreview(); } -static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz) +static jboolean android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz) { ALOGV("previewEnabled"); sp<Camera> c = get_native_camera(env, thiz, NULL); - if (c == 0) return false; + if (c == 0) return JNI_FALSE; - return c->previewEnabled(); + return c->previewEnabled() ? JNI_TRUE : JNI_FALSE; } static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer) @@ -651,10 +651,10 @@ static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject t context->setCallbackMode(env, installed, manualBuffer); } -static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, int msgType) { +static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, jint msgType) { ALOGV("addCallbackBuffer: 0x%x", msgType); - JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); if (context != NULL) { context->addCallbackBuffer(env, bytes, msgType); @@ -685,7 +685,7 @@ static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz) } } -static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, int msgType) +static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, jint msgType) { ALOGV("takePicture"); JNICameraContext* context; @@ -999,7 +999,7 @@ static int find_fields(JNIEnv *env, field *fields, int count) int register_android_hardware_Camera(JNIEnv *env) { field fields_to_find[] = { - { "android/hardware/Camera", "mNativeContext", "I", &fields.context }, + { "android/hardware/Camera", "mNativeContext", "J", &fields.context }, { "android/hardware/Camera$CameraInfo", "facing", "I", &fields.facing }, { "android/hardware/Camera$CameraInfo", "orientation", "I", &fields.orientation }, { "android/hardware/Camera$CameraInfo", "canDisableShutterSound", "Z", diff --git a/core/jni/android_hardware_SensorManager.cpp b/core/jni/android_hardware_SensorManager.cpp index 793d1bf..7a4728d 100644 --- a/core/jni/android_hardware_SensorManager.cpp +++ b/core/jni/android_hardware_SensorManager.cpp @@ -49,6 +49,8 @@ struct SensorOffsets jfieldID minDelay; jfieldID fifoReservedEventCount; jfieldID fifoMaxEventCount; + jfieldID stringType; + jfieldID requiredPermission; } gSensorOffsets; @@ -73,6 +75,9 @@ nativeClassInit (JNIEnv *_env, jclass _this) sensorOffsets.fifoReservedEventCount = _env->GetFieldID(sensorClass, "mFifoReservedEventCount", "I"); sensorOffsets.fifoMaxEventCount = _env->GetFieldID(sensorClass, "mFifoMaxEventCount", "I"); + sensorOffsets.stringType = _env->GetFieldID(sensorClass, "mStringType", "Ljava/lang/String;"); + sensorOffsets.requiredPermission = _env->GetFieldID(sensorClass, "mRequiredPermission", + "Ljava/lang/String;"); } static jint @@ -89,6 +94,8 @@ nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next) const SensorOffsets& sensorOffsets(gSensorOffsets); jstring name = env->NewStringUTF(list->getName().string()); jstring vendor = env->NewStringUTF(list->getVendor().string()); + jstring stringType = env->NewStringUTF(list->getStringType().string()); + jstring requiredPermission = env->NewStringUTF(list->getRequiredPermission().string()); env->SetObjectField(sensor, sensorOffsets.name, name); env->SetObjectField(sensor, sensorOffsets.vendor, vendor); env->SetIntField(sensor, sensorOffsets.version, list->getVersion()); @@ -100,7 +107,11 @@ nativeGetNextSensor(JNIEnv *env, jclass clazz, jobject sensor, jint next) env->SetIntField(sensor, sensorOffsets.minDelay, list->getMinDelay()); env->SetIntField(sensor, sensorOffsets.fifoReservedEventCount, list->getFifoReservedEventCount()); - env->SetIntField(sensor, sensorOffsets.fifoMaxEventCount, list->getFifoMaxEventCount()); + env->SetIntField(sensor, sensorOffsets.fifoMaxEventCount, + list->getFifoMaxEventCount()); + env->SetObjectField(sensor, sensorOffsets.stringType, stringType); + env->SetObjectField(sensor, sensorOffsets.requiredPermission, + requiredPermission); next++; return size_t(next) < count ? next : 0; } @@ -187,7 +198,7 @@ private: } }; -static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) { +static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) { SensorManager& mgr(SensorManager::getInstance()); sp<SensorEventQueue> queue(mgr.createEventQueue()); @@ -199,28 +210,28 @@ static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch); receiver->incStrong((void*)nativeInitSensorEventQueue); - return jint(receiver.get()); + return jlong(receiver.get()); } -static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle, jint rate_us, +static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle, jint rate_us, jint maxBatchReportLatency, jint reservedFlags) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency, reservedFlags); } -static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle) { +static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->disableSensor(handle); } -static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jint eventQ, jint handle) { +static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jlong eventQ, jint handle) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); receiver->destroy(); receiver->decStrong((void*)nativeInitSensorEventQueue); } -static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jint eventQ) { +static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jlong eventQ) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->flush(); } @@ -239,23 +250,23 @@ static JNINativeMethod gSystemSensorManagerMethods[] = { static JNINativeMethod gBaseEventQueueMethods[] = { {"nativeInitBaseEventQueue", - "(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)I", + "(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)J", (void*)nativeInitSensorEventQueue }, {"nativeEnableSensor", - "(IIIII)I", + "(JIIII)I", (void*)nativeEnableSensor }, {"nativeDisableSensor", - "(II)I", + "(JI)I", (void*)nativeDisableSensor }, {"nativeDestroySensorEventQueue", - "(I)V", + "(J)V", (void*)nativeDestroySensorEventQueue }, {"nativeFlushSensor", - "(I)I", + "(J)I", (void*)nativeFlushSensor }, }; diff --git a/core/jni/android_hardware_UsbDeviceConnection.cpp b/core/jni/android_hardware_UsbDeviceConnection.cpp index cea5bbf..c10b963 100644 --- a/core/jni/android_hardware_UsbDeviceConnection.cpp +++ b/core/jni/android_hardware_UsbDeviceConnection.cpp @@ -35,7 +35,7 @@ static jfieldID field_context; struct usb_device* get_device_from_object(JNIEnv* env, jobject connection) { - return (struct usb_device*)env->GetIntField(connection, field_context); + return (struct usb_device*)env->GetLongField(connection, field_context); } static jboolean @@ -46,19 +46,19 @@ android_hardware_UsbDeviceConnection_open(JNIEnv *env, jobject thiz, jstring dev // duplicate the file descriptor, since ParcelFileDescriptor will eventually close its copy fd = dup(fd); if (fd < 0) - return false; + return JNI_FALSE; const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL); struct usb_device* device = usb_device_new(deviceNameStr, fd); if (device) { - env->SetIntField(thiz, field_context, (int)device); + env->SetLongField(thiz, field_context, (jlong)device); } else { ALOGE("usb_device_open failed for %s", deviceNameStr); close(fd); } env->ReleaseStringUTFChars(deviceName, deviceNameStr); - return (device != NULL); + return (device != NULL) ? JNI_TRUE : JNI_FALSE; } static void @@ -68,7 +68,7 @@ android_hardware_UsbDeviceConnection_close(JNIEnv *env, jobject thiz) struct usb_device* device = get_device_from_object(env, thiz); if (device) { usb_device_close(device); - env->SetIntField(thiz, field_context, 0); + env->SetLongField(thiz, field_context, 0); } } @@ -106,12 +106,12 @@ android_hardware_UsbDeviceConnection_get_desc(JNIEnv *env, jobject thiz) static jboolean android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz, - int interfaceID, jboolean force) + jint interfaceID, jboolean force) { struct usb_device* device = get_device_from_object(env, thiz); if (!device) { ALOGE("device is closed in native_claim_interface"); - return -1; + return JNI_FALSE; } int ret = usb_device_claim_interface(device, interfaceID); @@ -120,11 +120,11 @@ android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz, usb_device_connect_kernel_driver(device, interfaceID, false); ret = usb_device_claim_interface(device, interfaceID); } - return ret == 0; + return (ret == 0) ? JNI_TRUE : JNI_FALSE; } static jint -android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, int interfaceID) +android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, jint interfaceID) { struct usb_device* device = get_device_from_object(env, thiz); if (!device) { @@ -246,7 +246,7 @@ int register_android_hardware_UsbDeviceConnection(JNIEnv *env) ALOGE("Can't find android/hardware/usb/UsbDeviceConnection"); return -1; } - field_context = env->GetFieldID(clazz, "mNativeContext", "I"); + field_context = env->GetFieldID(clazz, "mNativeContext", "J"); if (field_context == NULL) { ALOGE("Can't find UsbDeviceConnection.mNativeContext"); return -1; diff --git a/core/jni/android_hardware_UsbRequest.cpp b/core/jni/android_hardware_UsbRequest.cpp index 32d5135..01eaec4 100644 --- a/core/jni/android_hardware_UsbRequest.cpp +++ b/core/jni/android_hardware_UsbRequest.cpp @@ -32,7 +32,7 @@ static jfieldID field_context; struct usb_request* get_request_from_object(JNIEnv* env, jobject java_request) { - return (struct usb_request*)env->GetIntField(java_request, field_context); + return (struct usb_request*)env->GetLongField(java_request, field_context); } // in android_hardware_UsbDeviceConnection.cpp @@ -61,7 +61,7 @@ android_hardware_UsbRequest_init(JNIEnv *env, jobject thiz, jobject java_device, struct usb_request* request = usb_request_new(device, &desc); if (request) - env->SetIntField(thiz, field_context, (int)request); + env->SetLongField(thiz, field_context, (jlong)request); return (request != NULL); } @@ -72,7 +72,7 @@ android_hardware_UsbRequest_close(JNIEnv *env, jobject thiz) struct usb_request* request = get_request_from_object(env, thiz); if (request) { usb_request_free(request); - env->SetIntField(thiz, field_context, 0); + env->SetLongField(thiz, field_context, 0); } } @@ -114,14 +114,14 @@ android_hardware_UsbRequest_queue_array(JNIEnv *env, jobject thiz, } } -static int +static jint android_hardware_UsbRequest_dequeue_array(JNIEnv *env, jobject thiz, jbyteArray buffer, jint length, jboolean out) { struct usb_request* request = get_request_from_object(env, thiz); if (!request) { ALOGE("request is closed in native_dequeue"); - return -1; + return (jint) -1; } if (buffer && length && request->buffer && !out) { @@ -130,7 +130,7 @@ android_hardware_UsbRequest_dequeue_array(JNIEnv *env, jobject thiz, } free(request->buffer); env->DeleteGlobalRef((jobject)request->client_data); - return request->actual_length; + return (jint) request->actual_length; } static jboolean @@ -164,17 +164,17 @@ android_hardware_UsbRequest_queue_direct(JNIEnv *env, jobject thiz, } } -static int +static jint android_hardware_UsbRequest_dequeue_direct(JNIEnv *env, jobject thiz) { struct usb_request* request = get_request_from_object(env, thiz); if (!request) { ALOGE("request is closed in native_dequeue"); - return -1; + return (jint) -1; } // all we need to do is delete our global ref env->DeleteGlobalRef((jobject)request->client_data); - return request->actual_length; + return (jint) request->actual_length; } static jboolean @@ -207,7 +207,7 @@ int register_android_hardware_UsbRequest(JNIEnv *env) ALOGE("Can't find android/hardware/usb/UsbRequest"); return -1; } - field_context = env->GetFieldID(clazz, "mNativeContext", "I"); + field_context = env->GetFieldID(clazz, "mNativeContext", "J"); if (field_context == NULL) { ALOGE("Can't find UsbRequest.mNativeContext"); return -1; diff --git a/core/jni/android_media_AudioRecord.cpp b/core/jni/android_media_AudioRecord.cpp index 1c43cc5..b22668b 100644 --- a/core/jni/android_media_AudioRecord.cpp +++ b/core/jni/android_media_AudioRecord.cpp @@ -136,7 +136,7 @@ static sp<AudioRecord> getAudioRecord(JNIEnv* env, jobject thiz) { Mutex::Autolock l(sLock); AudioRecord* const ar = - (AudioRecord*)env->GetIntField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj); + (AudioRecord*)env->GetLongField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj); return sp<AudioRecord>(ar); } @@ -144,19 +144,19 @@ static sp<AudioRecord> setAudioRecord(JNIEnv* env, jobject thiz, const sp<AudioR { Mutex::Autolock l(sLock); sp<AudioRecord> old = - (AudioRecord*)env->GetIntField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj); + (AudioRecord*)env->GetLongField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj); if (ar.get()) { ar->incStrong((void*)setAudioRecord); } if (old != 0) { old->decStrong((void*)setAudioRecord); } - env->SetIntField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj, (int)ar.get()); + env->SetLongField(thiz, javaAudioRecordFields.nativeRecorderInJavaObj, (jlong)ar.get()); return old; } // ---------------------------------------------------------------------------- -static int +static jint android_media_AudioRecord_setup(JNIEnv *env, jobject thiz, jobject weak_this, jint source, jint sampleRateInHertz, jint channelMask, // Java channel masks map directly to the native definition @@ -168,7 +168,7 @@ android_media_AudioRecord_setup(JNIEnv *env, jobject thiz, jobject weak_this, if (!audio_is_input_channel(channelMask)) { ALOGE("Error creating AudioRecord: channel mask %#x is not valid.", channelMask); - return AUDIORECORD_ERROR_SETUP_INVALIDCHANNELMASK; + return (jint) AUDIORECORD_ERROR_SETUP_INVALIDCHANNELMASK; } uint32_t nbChannels = popcount(channelMask); @@ -176,7 +176,7 @@ android_media_AudioRecord_setup(JNIEnv *env, jobject thiz, jobject weak_this, if ((audioFormat != ENCODING_PCM_16BIT) && (audioFormat != ENCODING_PCM_8BIT)) { ALOGE("Error creating AudioRecord: unsupported audio format."); - return AUDIORECORD_ERROR_SETUP_INVALIDFORMAT; + return (jint) AUDIORECORD_ERROR_SETUP_INVALIDFORMAT; } int bytesPerSample = audioFormat == ENCODING_PCM_16BIT ? 2 : 1; @@ -185,31 +185,31 @@ android_media_AudioRecord_setup(JNIEnv *env, jobject thiz, jobject weak_this, if (buffSizeInBytes == 0) { ALOGE("Error creating AudioRecord: frameCount is 0."); - return AUDIORECORD_ERROR_SETUP_ZEROFRAMECOUNT; + return (jint) AUDIORECORD_ERROR_SETUP_ZEROFRAMECOUNT; } int frameSize = nbChannels * bytesPerSample; size_t frameCount = buffSizeInBytes / frameSize; if ((uint32_t(source) >= AUDIO_SOURCE_CNT) && (uint32_t(source) != AUDIO_SOURCE_HOTWORD)) { ALOGE("Error creating AudioRecord: unknown source."); - return AUDIORECORD_ERROR_SETUP_INVALIDSOURCE; + return (jint) AUDIORECORD_ERROR_SETUP_INVALIDSOURCE; } jclass clazz = env->GetObjectClass(thiz); if (clazz == NULL) { ALOGE("Can't find %s when setting up callback.", kClassPathName); - return AUDIORECORD_ERROR_SETUP_NATIVEINITFAILED; + return (jint) AUDIORECORD_ERROR_SETUP_NATIVEINITFAILED; } if (jSession == NULL) { ALOGE("Error creating AudioRecord: invalid session ID pointer"); - return AUDIORECORD_ERROR; + return (jint) AUDIORECORD_ERROR; } jint* nSession = (jint *) env->GetPrimitiveArrayCritical(jSession, NULL); if (nSession == NULL) { ALOGE("Error creating AudioRecord: Error retrieving session id pointer"); - return AUDIORECORD_ERROR; + return (jint) AUDIORECORD_ERROR; } int sessionId = nSession[0]; env->ReleasePrimitiveArrayCritical(jSession, nSession, 0); @@ -262,33 +262,33 @@ android_media_AudioRecord_setup(JNIEnv *env, jobject thiz, jobject weak_this, // save our newly created callback information in the "nativeCallbackCookie" field // of the Java object (in mNativeCallbackCookie) so we can free the memory in finalize() - env->SetIntField(thiz, javaAudioRecordFields.nativeCallbackCookie, (int)lpCallbackData); + env->SetLongField(thiz, javaAudioRecordFields.nativeCallbackCookie, (jlong)lpCallbackData); - return AUDIORECORD_SUCCESS; + return (jint) AUDIORECORD_SUCCESS; // failure: native_init_failure: env->DeleteGlobalRef(lpCallbackData->audioRecord_class); env->DeleteGlobalRef(lpCallbackData->audioRecord_ref); delete lpCallbackData; - env->SetIntField(thiz, javaAudioRecordFields.nativeCallbackCookie, 0); + env->SetLongField(thiz, javaAudioRecordFields.nativeCallbackCookie, 0); - return AUDIORECORD_ERROR_SETUP_NATIVEINITFAILED; + return (jint) AUDIORECORD_ERROR_SETUP_NATIVEINITFAILED; } // ---------------------------------------------------------------------------- -static int +static jint android_media_AudioRecord_start(JNIEnv *env, jobject thiz, jint event, jint triggerSession) { sp<AudioRecord> lpRecorder = getAudioRecord(env, thiz); if (lpRecorder == NULL ) { jniThrowException(env, "java/lang/IllegalStateException", NULL); - return AUDIORECORD_ERROR; + return (jint) AUDIORECORD_ERROR; } - return android_media_translateRecorderErrorCode( + return (jint) android_media_translateRecorderErrorCode( lpRecorder->start((AudioSystem::sync_event_t)event, triggerSession)); } @@ -319,12 +319,12 @@ static void android_media_AudioRecord_release(JNIEnv *env, jobject thiz) { ALOGV("About to delete lpRecorder: %x\n", (int)lpRecorder.get()); lpRecorder->stop(); - audiorecord_callback_cookie *lpCookie = (audiorecord_callback_cookie *)env->GetIntField( + audiorecord_callback_cookie *lpCookie = (audiorecord_callback_cookie *)env->GetLongField( thiz, javaAudioRecordFields.nativeCallbackCookie); // reset the native resources in the Java object so any attempt to access // them after a call to release fails. - env->SetIntField(thiz, javaAudioRecordFields.nativeCallbackCookie, 0); + env->SetLongField(thiz, javaAudioRecordFields.nativeCallbackCookie, 0); // delete the callback information if (lpCookie) { @@ -585,7 +585,7 @@ int register_android_media_AudioRecord(JNIEnv *env) // mNativeRecorderInJavaObj javaAudioRecordFields.nativeRecorderInJavaObj = env->GetFieldID(audioRecordClass, - JAVA_NATIVERECORDERINJAVAOBJ_FIELD_NAME, "I"); + JAVA_NATIVERECORDERINJAVAOBJ_FIELD_NAME, "J"); if (javaAudioRecordFields.nativeRecorderInJavaObj == NULL) { ALOGE("Can't find AudioRecord.%s", JAVA_NATIVERECORDERINJAVAOBJ_FIELD_NAME); return -1; @@ -593,7 +593,7 @@ int register_android_media_AudioRecord(JNIEnv *env) // mNativeCallbackCookie javaAudioRecordFields.nativeCallbackCookie = env->GetFieldID( audioRecordClass, - JAVA_NATIVECALLBACKINFO_FIELD_NAME, "I"); + JAVA_NATIVECALLBACKINFO_FIELD_NAME, "J"); if (javaAudioRecordFields.nativeCallbackCookie == NULL) { ALOGE("Can't find AudioRecord.%s", JAVA_NATIVECALLBACKINFO_FIELD_NAME); return -1; diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp index 7d99464..a19d111 100644 --- a/core/jni/android_media_AudioSystem.cpp +++ b/core/jni/android_media_AudioSystem.cpp @@ -52,10 +52,10 @@ static int check_AudioSystem_Command(status_t status) return kAudioStatusError; } -static int +static jint android_media_AudioSystem_muteMicrophone(JNIEnv *env, jobject thiz, jboolean on) { - return check_AudioSystem_Command(AudioSystem::muteMicrophone(on)); + return (jint) check_AudioSystem_Command(AudioSystem::muteMicrophone(on)); } static jboolean @@ -91,7 +91,7 @@ android_media_AudioSystem_isSourceActive(JNIEnv *env, jobject thiz, jint source) return state; } -static int +static jint android_media_AudioSystem_setParameters(JNIEnv *env, jobject thiz, jstring keyValuePairs) { const jchar* c_keyValuePairs = env->GetStringCritical(keyValuePairs, 0); @@ -101,7 +101,7 @@ android_media_AudioSystem_setParameters(JNIEnv *env, jobject thiz, jstring keyVa env->ReleaseStringCritical(keyValuePairs, c_keyValuePairs); } int status = check_AudioSystem_Command(AudioSystem::setParameters(0, c_keyValuePairs8)); - return status; + return (jint) status; } static jstring @@ -131,7 +131,7 @@ android_media_AudioSystem_error_callback(status_t err) check_AudioSystem_Command(err)); } -static int +static jint android_media_AudioSystem_setDeviceConnectionState(JNIEnv *env, jobject thiz, jint device, jint state, jstring device_address) { const char *c_address = env->GetStringUTFChars(device_address, NULL); @@ -139,60 +139,60 @@ android_media_AudioSystem_setDeviceConnectionState(JNIEnv *env, jobject thiz, ji static_cast <audio_policy_dev_state_t>(state), c_address)); env->ReleaseStringUTFChars(device_address, c_address); - return status; + return (jint) status; } -static int +static jint android_media_AudioSystem_getDeviceConnectionState(JNIEnv *env, jobject thiz, jint device, jstring device_address) { const char *c_address = env->GetStringUTFChars(device_address, NULL); int state = static_cast <int>(AudioSystem::getDeviceConnectionState(static_cast <audio_devices_t>(device), c_address)); env->ReleaseStringUTFChars(device_address, c_address); - return state; + return (jint) state; } -static int +static jint android_media_AudioSystem_setPhoneState(JNIEnv *env, jobject thiz, jint state) { - return check_AudioSystem_Command(AudioSystem::setPhoneState((audio_mode_t) state)); + return (jint) check_AudioSystem_Command(AudioSystem::setPhoneState((audio_mode_t) state)); } -static int +static jint android_media_AudioSystem_setForceUse(JNIEnv *env, jobject thiz, jint usage, jint config) { - return check_AudioSystem_Command(AudioSystem::setForceUse(static_cast <audio_policy_force_use_t>(usage), + return (jint) check_AudioSystem_Command(AudioSystem::setForceUse(static_cast <audio_policy_force_use_t>(usage), static_cast <audio_policy_forced_cfg_t>(config))); } -static int +static jint android_media_AudioSystem_getForceUse(JNIEnv *env, jobject thiz, jint usage) { - return static_cast <int>(AudioSystem::getForceUse(static_cast <audio_policy_force_use_t>(usage))); + return static_cast <jint>(AudioSystem::getForceUse(static_cast <audio_policy_force_use_t>(usage))); } -static int +static jint android_media_AudioSystem_initStreamVolume(JNIEnv *env, jobject thiz, jint stream, jint indexMin, jint indexMax) { - return check_AudioSystem_Command(AudioSystem::initStreamVolume(static_cast <audio_stream_type_t>(stream), + return (jint) check_AudioSystem_Command(AudioSystem::initStreamVolume(static_cast <audio_stream_type_t>(stream), indexMin, indexMax)); } -static int +static jint android_media_AudioSystem_setStreamVolumeIndex(JNIEnv *env, jobject thiz, jint stream, jint index, jint device) { - return check_AudioSystem_Command( + return (jint) check_AudioSystem_Command( AudioSystem::setStreamVolumeIndex(static_cast <audio_stream_type_t>(stream), index, (audio_devices_t)device)); } -static int +static jint android_media_AudioSystem_getStreamVolumeIndex(JNIEnv *env, jobject thiz, jint stream, @@ -205,13 +205,13 @@ android_media_AudioSystem_getStreamVolumeIndex(JNIEnv *env, != NO_ERROR) { index = -1; } - return index; + return (jint) index; } -static int +static jint android_media_AudioSystem_setMasterVolume(JNIEnv *env, jobject thiz, jfloat value) { - return check_AudioSystem_Command(AudioSystem::setMasterVolume(value)); + return (jint) check_AudioSystem_Command(AudioSystem::setMasterVolume(value)); } static jfloat @@ -224,10 +224,10 @@ android_media_AudioSystem_getMasterVolume(JNIEnv *env, jobject thiz) return value; } -static int +static jint android_media_AudioSystem_setMasterMute(JNIEnv *env, jobject thiz, jboolean mute) { - return check_AudioSystem_Command(AudioSystem::setMasterMute(mute)); + return (jint) check_AudioSystem_Command(AudioSystem::setMasterMute(mute)); } static jfloat @@ -275,10 +275,10 @@ android_media_AudioSystem_setLowRamDevice(JNIEnv *env, jobject clazz, jboolean i return (jint) AudioSystem::setLowRamDevice((bool) isLowRamDevice); } -static int +static jint android_media_AudioSystem_checkAudioFlinger(JNIEnv *env, jobject clazz) { - return check_AudioSystem_Command(AudioSystem::checkAudioFlinger()); + return (jint) check_AudioSystem_Command(AudioSystem::checkAudioFlinger()); } // ---------------------------------------------------------------------------- diff --git a/core/jni/android_media_AudioTrack.cpp b/core/jni/android_media_AudioTrack.cpp index 225bf06..dc8d9d8 100644 --- a/core/jni/android_media_AudioTrack.cpp +++ b/core/jni/android_media_AudioTrack.cpp @@ -174,7 +174,7 @@ static sp<AudioTrack> getAudioTrack(JNIEnv* env, jobject thiz) { Mutex::Autolock l(sLock); AudioTrack* const at = - (AudioTrack*)env->GetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj); + (AudioTrack*)env->GetLongField(thiz, javaAudioTrackFields.nativeTrackInJavaObj); return sp<AudioTrack>(at); } @@ -182,19 +182,19 @@ static sp<AudioTrack> setAudioTrack(JNIEnv* env, jobject thiz, const sp<AudioTra { Mutex::Autolock l(sLock); sp<AudioTrack> old = - (AudioTrack*)env->GetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj); + (AudioTrack*)env->GetLongField(thiz, javaAudioTrackFields.nativeTrackInJavaObj); if (at.get()) { at->incStrong((void*)setAudioTrack); } if (old != 0) { old->decStrong((void*)setAudioTrack); } - env->SetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj, (int)at.get()); + env->SetLongField(thiz, javaAudioTrackFields.nativeTrackInJavaObj, (jlong)at.get()); return old; } // ---------------------------------------------------------------------------- -static int +static jint android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_this, jint streamType, jint sampleRateInHertz, jint javaChannelMask, jint audioFormat, jint buffSizeInBytes, jint memoryMode, jintArray jSession) @@ -206,11 +206,11 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th if (AudioSystem::getOutputFrameCount(&afFrameCount, (audio_stream_type_t) streamType) != NO_ERROR) { ALOGE("Error creating AudioTrack: Could not get AudioSystem frame count."); - return AUDIOTRACK_ERROR_SETUP_AUDIOSYSTEM; + return (jint) AUDIOTRACK_ERROR_SETUP_AUDIOSYSTEM; } if (AudioSystem::getOutputSamplingRate(&afSampleRate, (audio_stream_type_t) streamType) != NO_ERROR) { ALOGE("Error creating AudioTrack: Could not get AudioSystem sampling rate."); - return AUDIOTRACK_ERROR_SETUP_AUDIOSYSTEM; + return (jint) AUDIOTRACK_ERROR_SETUP_AUDIOSYSTEM; } // Java channel masks don't map directly to the native definition, but it's a simple shift @@ -219,7 +219,7 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th if (!audio_is_output_channel(nativeChannelMask)) { ALOGE("Error creating AudioTrack: invalid channel mask %#x.", javaChannelMask); - return AUDIOTRACK_ERROR_SETUP_INVALIDCHANNELMASK; + return (jint) AUDIOTRACK_ERROR_SETUP_INVALIDCHANNELMASK; } int nbChannels = popcount(nativeChannelMask); @@ -239,7 +239,7 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th break; default: ALOGE("Error creating AudioTrack: unknown stream type."); - return AUDIOTRACK_ERROR_SETUP_INVALIDSTREAMTYPE; + return (jint) AUDIOTRACK_ERROR_SETUP_INVALIDSTREAMTYPE; } // check the format. @@ -247,7 +247,7 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th if ((audioFormat != ENCODING_PCM_16BIT) && (audioFormat != ENCODING_PCM_8BIT)) { ALOGE("Error creating AudioTrack: unsupported audio format."); - return AUDIOTRACK_ERROR_SETUP_INVALIDFORMAT; + return (jint) AUDIOTRACK_ERROR_SETUP_INVALIDFORMAT; } // for the moment 8bitPCM in MODE_STATIC is not supported natively in the AudioTrack C++ class @@ -272,18 +272,18 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th jclass clazz = env->GetObjectClass(thiz); if (clazz == NULL) { ALOGE("Can't find %s when setting up callback.", kClassPathName); - return AUDIOTRACK_ERROR_SETUP_NATIVEINITFAILED; + return (jint) AUDIOTRACK_ERROR_SETUP_NATIVEINITFAILED; } if (jSession == NULL) { ALOGE("Error creating AudioTrack: invalid session ID pointer"); - return AUDIOTRACK_ERROR; + return (jint) AUDIOTRACK_ERROR; } jint* nSession = (jint *) env->GetPrimitiveArrayCritical(jSession, NULL); if (nSession == NULL) { ALOGE("Error creating AudioTrack: Error retrieving session id pointer"); - return AUDIOTRACK_ERROR; + return (jint) AUDIOTRACK_ERROR; } int sessionId = nSession[0]; env->ReleasePrimitiveArrayCritical(jSession, nSession, 0); @@ -370,10 +370,10 @@ android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_th setAudioTrack(env, thiz, lpTrack); // save the JNI resources so we can free them later - //ALOGV("storing lpJniStorage: %x\n", (int)lpJniStorage); - env->SetIntField(thiz, javaAudioTrackFields.jniData, (int)lpJniStorage); + //ALOGV("storing lpJniStorage: %x\n", (long)lpJniStorage); + env->SetLongField(thiz, javaAudioTrackFields.jniData, (jlong)lpJniStorage); - return AUDIOTRACK_SUCCESS; + return (jint) AUDIOTRACK_SUCCESS; // failures: native_init_failure: @@ -383,9 +383,9 @@ native_init_failure: env->DeleteGlobalRef(lpJniStorage->mCallbackData.audioTrack_class); env->DeleteGlobalRef(lpJniStorage->mCallbackData.audioTrack_ref); delete lpJniStorage; - env->SetIntField(thiz, javaAudioTrackFields.jniData, 0); + env->SetLongField(thiz, javaAudioTrackFields.jniData, 0); - return AUDIOTRACK_ERROR_SETUP_NATIVEINITFAILED; + return (jint) AUDIOTRACK_ERROR_SETUP_NATIVEINITFAILED; } @@ -474,11 +474,11 @@ static void android_media_AudioTrack_native_release(JNIEnv *env, jobject thiz) lpTrack->stop(); // delete the JNI data - AudioTrackJniStorage* pJniStorage = (AudioTrackJniStorage *)env->GetIntField( + AudioTrackJniStorage* pJniStorage = (AudioTrackJniStorage *)env->GetLongField( thiz, javaAudioTrackFields.jniData); // reset the native resources in the Java object so any attempt to access // them after a call to release fails. - env->SetIntField(thiz, javaAudioTrackFields.jniData, 0); + env->SetLongField(thiz, javaAudioTrackFields.jniData, 0); if (pJniStorage) { Mutex::Autolock l(sLock); @@ -955,7 +955,7 @@ int register_android_media_AudioTrack(JNIEnv *env) // nativeTrackInJavaObj javaAudioTrackFields.nativeTrackInJavaObj = env->GetFieldID( audioTrackClass, - JAVA_NATIVETRACKINJAVAOBJ_FIELD_NAME, "I"); + JAVA_NATIVETRACKINJAVAOBJ_FIELD_NAME, "J"); if (javaAudioTrackFields.nativeTrackInJavaObj == NULL) { ALOGE("Can't find AudioTrack.%s", JAVA_NATIVETRACKINJAVAOBJ_FIELD_NAME); return -1; @@ -963,7 +963,7 @@ int register_android_media_AudioTrack(JNIEnv *env) // jniData; javaAudioTrackFields.jniData = env->GetFieldID( audioTrackClass, - JAVA_JNIDATA_FIELD_NAME, "I"); + JAVA_JNIDATA_FIELD_NAME, "J"); if (javaAudioTrackFields.jniData == NULL) { ALOGE("Can't find AudioTrack.%s", JAVA_JNIDATA_FIELD_NAME); return -1; diff --git a/core/jni/android_media_JetPlayer.cpp b/core/jni/android_media_JetPlayer.cpp index 5795aba..69f5711 100644 --- a/core/jni/android_media_JetPlayer.cpp +++ b/core/jni/android_media_JetPlayer.cpp @@ -87,12 +87,12 @@ android_media_JetPlayer_setup(JNIEnv *env, jobject thiz, jobject weak_this, if (result==EAS_SUCCESS) { // save our newly created C++ JetPlayer in the "nativePlayerInJavaObj" field // of the Java object (in mNativePlayerInJavaObj) - env->SetIntField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, (int)lpJet); + env->SetLongField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, (jlong)lpJet); return JNI_TRUE; } else { ALOGE("android_media_JetPlayer_setup(): initialization failed with EAS error code %d", (int)result); delete lpJet; - env->SetIntField(weak_this, javaJetPlayerFields.nativePlayerInJavaObj, 0); + env->SetLongField(weak_this, javaJetPlayerFields.nativePlayerInJavaObj, 0); return JNI_FALSE; } } @@ -103,7 +103,7 @@ static void android_media_JetPlayer_finalize(JNIEnv *env, jobject thiz) { ALOGV("android_media_JetPlayer_finalize(): entering."); - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet != NULL) { lpJet->release(); @@ -119,7 +119,7 @@ static void android_media_JetPlayer_release(JNIEnv *env, jobject thiz) { android_media_JetPlayer_finalize(env, thiz); - env->SetIntField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, 0); + env->SetLongField(thiz, javaJetPlayerFields.nativePlayerInJavaObj, 0); ALOGV("android_media_JetPlayer_release() done"); } @@ -128,7 +128,7 @@ android_media_JetPlayer_release(JNIEnv *env, jobject thiz) static jboolean android_media_JetPlayer_loadFromFile(JNIEnv *env, jobject thiz, jstring path) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -165,7 +165,7 @@ static jboolean android_media_JetPlayer_loadFromFileD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -195,7 +195,7 @@ android_media_JetPlayer_loadFromFileD(JNIEnv *env, jobject thiz, static jboolean android_media_JetPlayer_closeFile(JNIEnv *env, jobject thiz) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -217,7 +217,7 @@ android_media_JetPlayer_closeFile(JNIEnv *env, jobject thiz) static jboolean android_media_JetPlayer_play(JNIEnv *env, jobject thiz) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -241,7 +241,7 @@ android_media_JetPlayer_play(JNIEnv *env, jobject thiz) static jboolean android_media_JetPlayer_pause(JNIEnv *env, jobject thiz) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -271,7 +271,7 @@ android_media_JetPlayer_queueSegment(JNIEnv *env, jobject thiz, jint segmentNum, jint libNum, jint repeatCount, jint transpose, jint muteFlags, jbyte userID) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -298,7 +298,7 @@ android_media_JetPlayer_queueSegmentMuteArray(JNIEnv *env, jobject thiz, jint segmentNum, jint libNum, jint repeatCount, jint transpose, jbooleanArray muteArray, jbyte userID) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -344,7 +344,7 @@ static jboolean android_media_JetPlayer_setMuteFlags(JNIEnv *env, jobject thiz, jint muteFlags /*unsigned?*/, jboolean bSync) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -369,7 +369,7 @@ static jboolean android_media_JetPlayer_setMuteArray(JNIEnv *env, jobject thiz, jbooleanArray muteArray, jboolean bSync) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -415,7 +415,7 @@ static jboolean android_media_JetPlayer_setMuteFlag(JNIEnv *env, jobject thiz, jint trackId, jboolean muteFlag, jboolean bSync) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -441,7 +441,7 @@ android_media_JetPlayer_setMuteFlag(JNIEnv *env, jobject thiz, static jboolean android_media_JetPlayer_triggerClip(JNIEnv *env, jobject thiz, jint clipId) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -466,7 +466,7 @@ android_media_JetPlayer_triggerClip(JNIEnv *env, jobject thiz, jint clipId) static jboolean android_media_JetPlayer_clearQueue(JNIEnv *env, jobject thiz) { - JetPlayer *lpJet = (JetPlayer *)env->GetIntField( + JetPlayer *lpJet = (JetPlayer *)env->GetLongField( thiz, javaJetPlayerFields.nativePlayerInJavaObj); if (lpJet == NULL) { jniThrowException(env, "java/lang/IllegalStateException", @@ -533,7 +533,7 @@ int register_android_media_JetPlayer(JNIEnv *env) // Get the mNativePlayerInJavaObj variable field javaJetPlayerFields.nativePlayerInJavaObj = env->GetFieldID( jetPlayerClass, - JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME, "I"); + JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME, "J"); if (javaJetPlayerFields.nativePlayerInJavaObj == NULL) { ALOGE("Can't find JetPlayer.%s", JAVA_NATIVEJETPLAYERINJAVAOBJ_FIELD_NAME); return -1; diff --git a/core/jni/android_media_RemoteDisplay.cpp b/core/jni/android_media_RemoteDisplay.cpp index 463be5e..1cd3fbb 100644 --- a/core/jni/android_media_RemoteDisplay.cpp +++ b/core/jni/android_media_RemoteDisplay.cpp @@ -134,7 +134,7 @@ private: // ---------------------------------------------------------------------------- -static jint nativeListen(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr) { +static jlong nativeListen(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr) { ScopedUtfChars iface(env, ifaceStr); sp<IServiceManager> sm = defaultServiceManager(); @@ -155,20 +155,20 @@ static jint nativeListen(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr } NativeRemoteDisplay* wrapper = new NativeRemoteDisplay(display, client); - return reinterpret_cast<jint>(wrapper); + return reinterpret_cast<jlong>(wrapper); } -static void nativePause(JNIEnv* env, jobject remoteDisplayObj, jint ptr) { +static void nativePause(JNIEnv* env, jobject remoteDisplayObj, jlong ptr) { NativeRemoteDisplay* wrapper = reinterpret_cast<NativeRemoteDisplay*>(ptr); wrapper->pause(); } -static void nativeResume(JNIEnv* env, jobject remoteDisplayObj, jint ptr) { +static void nativeResume(JNIEnv* env, jobject remoteDisplayObj, jlong ptr) { NativeRemoteDisplay* wrapper = reinterpret_cast<NativeRemoteDisplay*>(ptr); wrapper->resume(); } -static void nativeDispose(JNIEnv* env, jobject remoteDisplayObj, jint ptr) { +static void nativeDispose(JNIEnv* env, jobject remoteDisplayObj, jlong ptr) { NativeRemoteDisplay* wrapper = reinterpret_cast<NativeRemoteDisplay*>(ptr); delete wrapper; } @@ -176,13 +176,13 @@ static void nativeDispose(JNIEnv* env, jobject remoteDisplayObj, jint ptr) { // ---------------------------------------------------------------------------- static JNINativeMethod gMethods[] = { - {"nativeListen", "(Ljava/lang/String;)I", + {"nativeListen", "(Ljava/lang/String;)J", (void*)nativeListen }, - {"nativeDispose", "(I)V", + {"nativeDispose", "(J)V", (void*)nativeDispose }, - {"nativePause", "(I)V", + {"nativePause", "(J)V", (void*)nativePause }, - {"nativeResume", "(I)V", + {"nativeResume", "(J)V", (void*)nativeResume }, }; diff --git a/core/jni/android_media_ToneGenerator.cpp b/core/jni/android_media_ToneGenerator.cpp index 76e42bc..ca00709 100644 --- a/core/jni/android_media_ToneGenerator.cpp +++ b/core/jni/android_media_ToneGenerator.cpp @@ -39,9 +39,9 @@ struct fields_t { static fields_t fields; static jboolean android_media_ToneGenerator_startTone(JNIEnv *env, jobject thiz, jint toneType, jint durationMs) { - ALOGV("android_media_ToneGenerator_startTone: %x", (int)thiz); + ALOGV("android_media_ToneGenerator_startTone: %p", thiz); - ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetLongField(thiz, fields.context); if (lpToneGen == NULL) { jniThrowRuntimeException(env, "Method called after release()"); @@ -52,12 +52,12 @@ static jboolean android_media_ToneGenerator_startTone(JNIEnv *env, jobject thiz, } static void android_media_ToneGenerator_stopTone(JNIEnv *env, jobject thiz) { - ALOGV("android_media_ToneGenerator_stopTone: %x", (int)thiz); + ALOGV("android_media_ToneGenerator_stopTone: %p", thiz); - ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetLongField(thiz, fields.context); - ALOGV("ToneGenerator lpToneGen: %x", (unsigned int)lpToneGen); + ALOGV("ToneGenerator lpToneGen: %p", lpToneGen); if (lpToneGen == NULL) { jniThrowRuntimeException(env, "Method called after release()"); return; @@ -66,7 +66,7 @@ static void android_media_ToneGenerator_stopTone(JNIEnv *env, jobject thiz) { } static jint android_media_ToneGenerator_getAudioSessionId(JNIEnv *env, jobject thiz) { - ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetLongField(thiz, fields.context); if (lpToneGen == NULL) { jniThrowRuntimeException(env, "Method called after release()"); @@ -76,11 +76,11 @@ static jint android_media_ToneGenerator_getAudioSessionId(JNIEnv *env, jobject t } static void android_media_ToneGenerator_release(JNIEnv *env, jobject thiz) { - ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetLongField(thiz, fields.context); - ALOGV("android_media_ToneGenerator_release lpToneGen: %x", (int)lpToneGen); + ALOGV("android_media_ToneGenerator_release lpToneGen: %p", lpToneGen); - env->SetIntField(thiz, fields.context, 0); + env->SetLongField(thiz, fields.context, 0); delete lpToneGen; } @@ -89,11 +89,11 @@ static void android_media_ToneGenerator_native_setup(JNIEnv *env, jobject thiz, jint streamType, jint volume) { ToneGenerator *lpToneGen = new ToneGenerator((audio_stream_type_t) streamType, AudioSystem::linearToLog(volume), true); - env->SetIntField(thiz, fields.context, 0); + env->SetLongField(thiz, fields.context, 0); - ALOGV("android_media_ToneGenerator_native_setup jobject: %x", (int)thiz); + ALOGV("android_media_ToneGenerator_native_setup jobject: %p", thiz); - ALOGV("ToneGenerator lpToneGen: %x", (unsigned int)lpToneGen); + ALOGV("ToneGenerator lpToneGen: %p", lpToneGen); if (!lpToneGen->isInited()) { ALOGE("ToneGenerator init failed"); @@ -103,16 +103,16 @@ static void android_media_ToneGenerator_native_setup(JNIEnv *env, jobject thiz, } // Stow our new C++ ToneGenerator in an opaque field in the Java object. - env->SetIntField(thiz, fields.context, (int)lpToneGen); + env->SetLongField(thiz, fields.context, (jlong)lpToneGen); - ALOGV("ToneGenerator fields.context: %x", env->GetIntField(thiz, fields.context)); + ALOGV("ToneGenerator fields.context: %p", (void*) env->GetLongField(thiz, fields.context)); } static void android_media_ToneGenerator_native_finalize(JNIEnv *env, jobject thiz) { - ALOGV("android_media_ToneGenerator_native_finalize jobject: %x", (int)thiz); + ALOGV("android_media_ToneGenerator_native_finalize jobject: %p", thiz); - ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetLongField(thiz, fields.context); if (lpToneGen != NULL) { @@ -142,12 +142,12 @@ int register_android_media_ToneGenerator(JNIEnv *env) { return -1; } - fields.context = env->GetFieldID(clazz, "mNativeContext", "I"); + fields.context = env->GetFieldID(clazz, "mNativeContext", "J"); if (fields.context == NULL) { ALOGE("Can't find ToneGenerator.mNativeContext"); return -1; } - ALOGV("register_android_media_ToneGenerator ToneGenerator fields.context: %x", (unsigned int)fields.context); + ALOGV("register_android_media_ToneGenerator ToneGenerator fields.context: %p", fields.context); return AndroidRuntime::registerNativeMethods(env, "android/media/ToneGenerator", gMethods, NELEM(gMethods)); diff --git a/core/jni/android_net_LocalSocketImpl.cpp b/core/jni/android_net_LocalSocketImpl.cpp index b9ed28e..9f79f74 100644 --- a/core/jni/android_net_LocalSocketImpl.cpp +++ b/core/jni/android_net_LocalSocketImpl.cpp @@ -35,6 +35,7 @@ #include <cutils/sockets.h> #include <netinet/tcp.h> +#include <ScopedUtfChars.h> namespace android { @@ -52,25 +53,22 @@ socket_connect_local(JNIEnv *env, jobject object, jobject fileDescriptor, jstring name, jint namespaceId) { int ret; - const char *nameUtf8; int fd; - nameUtf8 = env->GetStringUTFChars(name, NULL); - fd = jniGetFDFromFileDescriptor(env, fileDescriptor); if (env->ExceptionOccurred() != NULL) { return; } + ScopedUtfChars nameUtf8(env, name); + ret = socket_local_client_connect( fd, - nameUtf8, + nameUtf8.c_str(), namespaceId, SOCK_STREAM); - env->ReleaseStringUTFChars(name, nameUtf8); - if (ret < 0) { jniThrowIOException(env, errno); return; @@ -89,11 +87,10 @@ socket_bind_local (JNIEnv *env, jobject object, jobject fileDescriptor, { int ret; int fd; - const char *nameUtf8; - if (name == NULL) { jniThrowNullPointerException(env, NULL); + return; } fd = jniGetFDFromFileDescriptor(env, fileDescriptor); @@ -102,11 +99,9 @@ socket_bind_local (JNIEnv *env, jobject object, jobject fileDescriptor, return; } - nameUtf8 = env->GetStringUTFChars(name, NULL); - - ret = socket_local_server_bind(fd, nameUtf8, namespaceId); + ScopedUtfChars nameUtf8(env, name); - env->ReleaseStringUTFChars(name, nameUtf8); + ret = socket_local_server_bind(fd, nameUtf8.c_str(), namespaceId); if (ret < 0) { jniThrowIOException(env, errno); @@ -451,6 +446,7 @@ static int socket_process_cmsg(JNIEnv *env, jobject thisJ, struct msghdr * pMsg) if (count < 0) { jniThrowException(env, "java/io/IOException", "invalid cmsg length"); + return -1; } fdArray = env->NewObjectArray(count, class_FileDescriptor, NULL); diff --git a/core/jni/android_opengl_GLES20.cpp b/core/jni/android_opengl_GLES20.cpp index 9bc69ae..db03b70 100644 --- a/core/jni/android_opengl_GLES20.cpp +++ b/core/jni/android_opengl_GLES20.cpp @@ -353,6 +353,7 @@ android_glBindAttribLocation__IILjava_lang_String_2 const char* _nativename = 0; if (!name) { + _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; _exceptionMessage = "name == null"; goto exit; @@ -2454,6 +2455,7 @@ android_glGetAttribLocation__ILjava_lang_String_2 const char* _nativename = 0; if (!name) { + _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; _exceptionMessage = "name == null"; goto exit; @@ -3602,6 +3604,7 @@ android_glGetUniformLocation__ILjava_lang_String_2 const char* _nativename = 0; if (!name) { + _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; _exceptionMessage = "name == null"; goto exit; diff --git a/core/jni/android_opengl_GLES30.cpp b/core/jni/android_opengl_GLES30.cpp index 832d643..4c62a75 100644 --- a/core/jni/android_opengl_GLES30.cpp +++ b/core/jni/android_opengl_GLES30.cpp @@ -2511,6 +2511,7 @@ android_glGetFragDataLocation__ILjava_lang_String_2 const char* _nativename = 0; if (!name) { + _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; _exceptionMessage = "name == null"; goto exit; @@ -3361,6 +3362,7 @@ android_glGetUniformBlockIndex__ILjava_lang_String_2 const char* _nativeuniformBlockName = 0; if (!uniformBlockName) { + _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; _exceptionMessage = "uniformBlockName == null"; goto exit; diff --git a/core/jni/android_os_Debug.cpp b/core/jni/android_os_Debug.cpp index 054ee4f..a041693 100644 --- a/core/jni/android_os_Debug.cpp +++ b/core/jni/android_os_Debug.cpp @@ -675,6 +675,7 @@ static jint read_binder_stat(const char* stat) // loop until we have the block that represents this process do { if (fgets(line, 1024, fp) == 0) { + fclose(fp); return -1; } } while (strncmp(compare, line, len)); @@ -684,13 +685,16 @@ static jint read_binder_stat(const char* stat) do { if (fgets(line, 1024, fp) == 0) { + fclose(fp); return -1; } } while (strncmp(compare, line, len)); // we have the line, now increment the line ptr to the value char* ptr = line + len; - return atoi(ptr); + jint result = atoi(ptr); + fclose(fp); + return result; } static jint android_os_Debug_getBinderSentTransactions(JNIEnv *env, jobject clazz) diff --git a/core/jni/android_os_MemoryFile.cpp b/core/jni/android_os_MemoryFile.cpp index 7134191..27b29bc 100644 --- a/core/jni/android_os_MemoryFile.cpp +++ b/core/jni/android_os_MemoryFile.cpp @@ -43,19 +43,20 @@ static jobject android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring na return jniCreateFileDescriptor(env, result); } -static jint android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jobject fileDescriptor, +static jlong android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jobject fileDescriptor, jint length, jint prot) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); - jint result = (jint)mmap(NULL, length, prot, MAP_SHARED, fd, 0); - if (!result) + void* result = mmap(NULL, length, prot, MAP_SHARED, fd, 0); + if (result == MAP_FAILED) { jniThrowException(env, "java/io/IOException", "mmap failed"); - return result; + } + return reinterpret_cast<jlong>(result); } -static void android_os_MemoryFile_munmap(JNIEnv* env, jobject clazz, jint addr, jint length) +static void android_os_MemoryFile_munmap(JNIEnv* env, jobject clazz, jlong addr, jint length) { - int result = munmap((void *)addr, length); + int result = munmap(reinterpret_cast<void *>(addr), length); if (result < 0) jniThrowException(env, "java/io/IOException", "munmap failed"); } @@ -70,7 +71,7 @@ static void android_os_MemoryFile_close(JNIEnv* env, jobject clazz, jobject file } static jint android_os_MemoryFile_read(JNIEnv* env, jobject clazz, - jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset, + jobject fileDescriptor, jlong address, jbyteArray buffer, jint srcOffset, jint destOffset, jint count, jboolean unpinned) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); @@ -89,7 +90,7 @@ static jint android_os_MemoryFile_read(JNIEnv* env, jobject clazz, } static jint android_os_MemoryFile_write(JNIEnv* env, jobject clazz, - jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset, + jobject fileDescriptor, jlong address, jbyteArray buffer, jint srcOffset, jint destOffset, jint count, jboolean unpinned) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); @@ -138,11 +139,11 @@ static jint android_os_MemoryFile_get_size(JNIEnv* env, jobject clazz, static const JNINativeMethod methods[] = { {"native_open", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_MemoryFile_open}, - {"native_mmap", "(Ljava/io/FileDescriptor;II)I", (void*)android_os_MemoryFile_mmap}, - {"native_munmap", "(II)V", (void*)android_os_MemoryFile_munmap}, + {"native_mmap", "(Ljava/io/FileDescriptor;II)J", (void*)android_os_MemoryFile_mmap}, + {"native_munmap", "(JI)V", (void*)android_os_MemoryFile_munmap}, {"native_close", "(Ljava/io/FileDescriptor;)V", (void*)android_os_MemoryFile_close}, - {"native_read", "(Ljava/io/FileDescriptor;I[BIIIZ)I", (void*)android_os_MemoryFile_read}, - {"native_write", "(Ljava/io/FileDescriptor;I[BIIIZ)V", (void*)android_os_MemoryFile_write}, + {"native_read", "(Ljava/io/FileDescriptor;J[BIIIZ)I", (void*)android_os_MemoryFile_read}, + {"native_write", "(Ljava/io/FileDescriptor;J[BIIIZ)V", (void*)android_os_MemoryFile_write}, {"native_pin", "(Ljava/io/FileDescriptor;Z)V", (void*)android_os_MemoryFile_pin}, {"native_get_size", "(Ljava/io/FileDescriptor;)I", (void*)android_os_MemoryFile_get_size} diff --git a/core/jni/android_os_MessageQueue.cpp b/core/jni/android_os_MessageQueue.cpp index c9c3720..a8ed895 100644 --- a/core/jni/android_os_MessageQueue.cpp +++ b/core/jni/android_os_MessageQueue.cpp @@ -110,11 +110,11 @@ void NativeMessageQueue::wake() { // ---------------------------------------------------------------------------- sp<MessageQueue> android_os_MessageQueue_getMessageQueue(JNIEnv* env, jobject messageQueueObj) { - jint intPtr = env->GetIntField(messageQueueObj, gMessageQueueClassInfo.mPtr); - return reinterpret_cast<NativeMessageQueue*>(intPtr); + jlong ptr = env->GetLongField(messageQueueObj, gMessageQueueClassInfo.mPtr); + return reinterpret_cast<NativeMessageQueue*>(ptr); } -static jint android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) { +static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) { NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue(); if (!nativeMessageQueue) { jniThrowRuntimeException(env, "Unable to allocate native queue"); @@ -122,26 +122,26 @@ static jint android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) { } nativeMessageQueue->incStrong(env); - return reinterpret_cast<jint>(nativeMessageQueue); + return reinterpret_cast<jlong>(nativeMessageQueue); } -static void android_os_MessageQueue_nativeDestroy(JNIEnv* env, jclass clazz, jint ptr) { +static void android_os_MessageQueue_nativeDestroy(JNIEnv* env, jclass clazz, jlong ptr) { NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr); nativeMessageQueue->decStrong(env); } static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jclass clazz, - jint ptr, jint timeoutMillis) { + jlong ptr, jint timeoutMillis) { NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr); nativeMessageQueue->pollOnce(env, timeoutMillis); } -static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jint ptr) { +static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) { NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr); return nativeMessageQueue->wake(); } -static jboolean android_os_MessageQueue_nativeIsIdling(JNIEnv* env, jclass clazz, jint ptr) { +static jboolean android_os_MessageQueue_nativeIsIdling(JNIEnv* env, jclass clazz, jlong ptr) { NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr); return nativeMessageQueue->getLooper()->isIdling(); } @@ -150,11 +150,11 @@ static jboolean android_os_MessageQueue_nativeIsIdling(JNIEnv* env, jclass clazz static JNINativeMethod gMessageQueueMethods[] = { /* name, signature, funcPtr */ - { "nativeInit", "()I", (void*)android_os_MessageQueue_nativeInit }, - { "nativeDestroy", "(I)V", (void*)android_os_MessageQueue_nativeDestroy }, - { "nativePollOnce", "(II)V", (void*)android_os_MessageQueue_nativePollOnce }, - { "nativeWake", "(I)V", (void*)android_os_MessageQueue_nativeWake }, - { "nativeIsIdling", "(I)Z", (void*)android_os_MessageQueue_nativeIsIdling } + { "nativeInit", "()J", (void*)android_os_MessageQueue_nativeInit }, + { "nativeDestroy", "(J)V", (void*)android_os_MessageQueue_nativeDestroy }, + { "nativePollOnce", "(JI)V", (void*)android_os_MessageQueue_nativePollOnce }, + { "nativeWake", "(J)V", (void*)android_os_MessageQueue_nativeWake }, + { "nativeIsIdling", "(J)Z", (void*)android_os_MessageQueue_nativeIsIdling } }; #define FIND_CLASS(var, className) \ @@ -174,7 +174,7 @@ int register_android_os_MessageQueue(JNIEnv* env) { FIND_CLASS(clazz, "android/os/MessageQueue"); GET_FIELD_ID(gMessageQueueClassInfo.mPtr, clazz, - "mPtr", "I"); + "mPtr", "J"); return 0; } diff --git a/core/jni/android_os_Parcel.cpp b/core/jni/android_os_Parcel.cpp index aa451e3..50f6c73 100644 --- a/core/jni/android_os_Parcel.cpp +++ b/core/jni/android_os_Parcel.cpp @@ -69,7 +69,7 @@ static struct parcel_offsets_t Parcel* parcelForJavaObject(JNIEnv* env, jobject obj) { if (obj) { - Parcel* p = (Parcel*)env->GetIntField(obj, gParcelOffsets.mNativePtr); + Parcel* p = (Parcel*)env->GetLongField(obj, gParcelOffsets.mNativePtr); if (p != NULL) { return p; } @@ -88,31 +88,31 @@ void recycleJavaParcelObject(JNIEnv* env, jobject parcelObj) env->CallVoidMethod(parcelObj, gParcelOffsets.recycle); } -static jint android_os_Parcel_dataSize(JNIEnv* env, jclass clazz, jint nativePtr) +static jint android_os_Parcel_dataSize(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); return parcel ? parcel->dataSize() : 0; } -static jint android_os_Parcel_dataAvail(JNIEnv* env, jclass clazz, jint nativePtr) +static jint android_os_Parcel_dataAvail(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); return parcel ? parcel->dataAvail() : 0; } -static jint android_os_Parcel_dataPosition(JNIEnv* env, jclass clazz, jint nativePtr) +static jint android_os_Parcel_dataPosition(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); return parcel ? parcel->dataPosition() : 0; } -static jint android_os_Parcel_dataCapacity(JNIEnv* env, jclass clazz, jint nativePtr) +static jint android_os_Parcel_dataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); return parcel ? parcel->dataCapacity() : 0; } -static void android_os_Parcel_setDataSize(JNIEnv* env, jclass clazz, jint nativePtr, jint size) +static void android_os_Parcel_setDataSize(JNIEnv* env, jclass clazz, jlong nativePtr, jint size) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -123,7 +123,7 @@ static void android_os_Parcel_setDataSize(JNIEnv* env, jclass clazz, jint native } } -static void android_os_Parcel_setDataPosition(JNIEnv* env, jclass clazz, jint nativePtr, jint pos) +static void android_os_Parcel_setDataPosition(JNIEnv* env, jclass clazz, jlong nativePtr, jint pos) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -131,7 +131,7 @@ static void android_os_Parcel_setDataPosition(JNIEnv* env, jclass clazz, jint na } } -static void android_os_Parcel_setDataCapacity(JNIEnv* env, jclass clazz, jint nativePtr, jint size) +static void android_os_Parcel_setDataCapacity(JNIEnv* env, jclass clazz, jlong nativePtr, jint size) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -142,7 +142,7 @@ static void android_os_Parcel_setDataCapacity(JNIEnv* env, jclass clazz, jint na } } -static jboolean android_os_Parcel_pushAllowFds(JNIEnv* env, jclass clazz, jint nativePtr, jboolean allowFds) +static jboolean android_os_Parcel_pushAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean allowFds) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); jboolean ret = JNI_TRUE; @@ -152,7 +152,7 @@ static jboolean android_os_Parcel_pushAllowFds(JNIEnv* env, jclass clazz, jint n return ret; } -static void android_os_Parcel_restoreAllowFds(JNIEnv* env, jclass clazz, jint nativePtr, jboolean lastValue) +static void android_os_Parcel_restoreAllowFds(JNIEnv* env, jclass clazz, jlong nativePtr, jboolean lastValue) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -160,7 +160,7 @@ static void android_os_Parcel_restoreAllowFds(JNIEnv* env, jclass clazz, jint na } } -static void android_os_Parcel_writeNative(JNIEnv* env, jclass clazz, jint nativePtr, jobject data, +static void android_os_Parcel_writeNative(JNIEnv* env, jclass clazz, jlong nativePtr, jobject data, jint offset, jint length) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); @@ -187,7 +187,7 @@ static void android_os_Parcel_writeNative(JNIEnv* env, jclass clazz, jint native } } -static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jint nativePtr, jint val) { +static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jlong nativePtr, jint val) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); const status_t err = parcel->writeInt32(val); if (err != NO_ERROR) { @@ -195,7 +195,7 @@ static void android_os_Parcel_writeInt(JNIEnv* env, jclass clazz, jint nativePtr } } -static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jint nativePtr, jlong val) +static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jlong nativePtr, jlong val) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -206,7 +206,7 @@ static void android_os_Parcel_writeLong(JNIEnv* env, jclass clazz, jint nativePt } } -static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jint nativePtr, jfloat val) +static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jlong nativePtr, jfloat val) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -217,7 +217,7 @@ static void android_os_Parcel_writeFloat(JNIEnv* env, jclass clazz, jint nativeP } } -static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jint nativePtr, jdouble val) +static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jlong nativePtr, jdouble val) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -228,7 +228,7 @@ static void android_os_Parcel_writeDouble(JNIEnv* env, jclass clazz, jint native } } -static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jint nativePtr, jstring val) +static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jlong nativePtr, jstring val) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -248,7 +248,7 @@ static void android_os_Parcel_writeString(JNIEnv* env, jclass clazz, jint native } } -static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jint nativePtr, jobject object) +static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -259,7 +259,7 @@ static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jint } } -static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jint nativePtr, jobject object) +static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr, jobject object) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -271,7 +271,7 @@ static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jclass clazz, jin } } -static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jint nativePtr) +static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, jlong nativePtr) { jbyteArray ret = NULL; @@ -297,7 +297,7 @@ static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jclass clazz, j return ret; } -static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jint nativePtr) +static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -306,7 +306,7 @@ static jint android_os_Parcel_readInt(JNIEnv* env, jclass clazz, jint nativePtr) return 0; } -static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jint nativePtr) +static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -315,7 +315,7 @@ static jlong android_os_Parcel_readLong(JNIEnv* env, jclass clazz, jint nativePt return 0; } -static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jint nativePtr) +static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -324,7 +324,7 @@ static jfloat android_os_Parcel_readFloat(JNIEnv* env, jclass clazz, jint native return 0; } -static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jint nativePtr) +static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -333,7 +333,7 @@ static jdouble android_os_Parcel_readDouble(JNIEnv* env, jclass clazz, jint nati return 0; } -static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jint nativePtr) +static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -347,7 +347,7 @@ static jstring android_os_Parcel_readString(JNIEnv* env, jclass clazz, jint nati return NULL; } -static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jint nativePtr) +static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -356,7 +356,7 @@ static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jin return NULL; } -static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jclass clazz, jint nativePtr) +static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -468,13 +468,13 @@ static void android_os_Parcel_clearFileDescriptor(JNIEnv* env, jclass clazz, job } } -static jint android_os_Parcel_create(JNIEnv* env, jclass clazz) +static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz) { Parcel* parcel = new Parcel(); - return reinterpret_cast<jint>(parcel); + return reinterpret_cast<jlong>(parcel); } -static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jint nativePtr) +static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel != NULL) { @@ -482,13 +482,13 @@ static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jint nativeP } } -static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jint nativePtr) +static void android_os_Parcel_destroy(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); delete parcel; } -static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jint nativePtr) +static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jlong nativePtr) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); if (parcel == NULL) { @@ -517,7 +517,7 @@ static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jclass clazz, jint nat return ret; } -static void android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jint nativePtr, +static void android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jlong nativePtr, jbyteArray data, jint offset, jint length) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); @@ -538,8 +538,8 @@ static void android_os_Parcel_unmarshall(JNIEnv* env, jclass clazz, jint nativeP } } -static void android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jint thisNativePtr, - jint otherNativePtr, jint offset, jint length) +static void android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jlong thisNativePtr, + jlong otherNativePtr, jint offset, jint length) { Parcel* thisParcel = reinterpret_cast<Parcel*>(thisNativePtr); if (thisParcel == NULL) { @@ -556,7 +556,7 @@ static void android_os_Parcel_appendFrom(JNIEnv* env, jclass clazz, jint thisNat } } -static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, jint nativePtr) +static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, jlong nativePtr) { jboolean ret = JNI_FALSE; Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); @@ -568,7 +568,7 @@ static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jclass clazz, return ret; } -static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jint nativePtr, +static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jlong nativePtr, jstring name) { Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); @@ -583,7 +583,7 @@ static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jin } } -static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jint nativePtr, jstring name) +static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jlong nativePtr, jstring name) { jboolean ret = JNI_FALSE; @@ -622,50 +622,50 @@ static void android_os_Parcel_enforceInterface(JNIEnv* env, jclass clazz, jint n // ---------------------------------------------------------------------------- static const JNINativeMethod gParcelMethods[] = { - {"nativeDataSize", "(I)I", (void*)android_os_Parcel_dataSize}, - {"nativeDataAvail", "(I)I", (void*)android_os_Parcel_dataAvail}, - {"nativeDataPosition", "(I)I", (void*)android_os_Parcel_dataPosition}, - {"nativeDataCapacity", "(I)I", (void*)android_os_Parcel_dataCapacity}, - {"nativeSetDataSize", "(II)V", (void*)android_os_Parcel_setDataSize}, - {"nativeSetDataPosition", "(II)V", (void*)android_os_Parcel_setDataPosition}, - {"nativeSetDataCapacity", "(II)V", (void*)android_os_Parcel_setDataCapacity}, - - {"nativePushAllowFds", "(IZ)Z", (void*)android_os_Parcel_pushAllowFds}, - {"nativeRestoreAllowFds", "(IZ)V", (void*)android_os_Parcel_restoreAllowFds}, - - {"nativeWriteByteArray", "(I[BII)V", (void*)android_os_Parcel_writeNative}, - {"nativeWriteInt", "(II)V", (void*)android_os_Parcel_writeInt}, - {"nativeWriteLong", "(IJ)V", (void*)android_os_Parcel_writeLong}, - {"nativeWriteFloat", "(IF)V", (void*)android_os_Parcel_writeFloat}, - {"nativeWriteDouble", "(ID)V", (void*)android_os_Parcel_writeDouble}, - {"nativeWriteString", "(ILjava/lang/String;)V", (void*)android_os_Parcel_writeString}, - {"nativeWriteStrongBinder", "(ILandroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder}, - {"nativeWriteFileDescriptor", "(ILjava/io/FileDescriptor;)V", (void*)android_os_Parcel_writeFileDescriptor}, - - {"nativeCreateByteArray", "(I)[B", (void*)android_os_Parcel_createByteArray}, - {"nativeReadInt", "(I)I", (void*)android_os_Parcel_readInt}, - {"nativeReadLong", "(I)J", (void*)android_os_Parcel_readLong}, - {"nativeReadFloat", "(I)F", (void*)android_os_Parcel_readFloat}, - {"nativeReadDouble", "(I)D", (void*)android_os_Parcel_readDouble}, - {"nativeReadString", "(I)Ljava/lang/String;", (void*)android_os_Parcel_readString}, - {"nativeReadStrongBinder", "(I)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder}, - {"nativeReadFileDescriptor", "(I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor}, + {"nativeDataSize", "(J)I", (void*)android_os_Parcel_dataSize}, + {"nativeDataAvail", "(J)I", (void*)android_os_Parcel_dataAvail}, + {"nativeDataPosition", "(J)I", (void*)android_os_Parcel_dataPosition}, + {"nativeDataCapacity", "(J)I", (void*)android_os_Parcel_dataCapacity}, + {"nativeSetDataSize", "(JI)V", (void*)android_os_Parcel_setDataSize}, + {"nativeSetDataPosition", "(JI)V", (void*)android_os_Parcel_setDataPosition}, + {"nativeSetDataCapacity", "(JI)V", (void*)android_os_Parcel_setDataCapacity}, + + {"nativePushAllowFds", "(JZ)Z", (void*)android_os_Parcel_pushAllowFds}, + {"nativeRestoreAllowFds", "(JZ)V", (void*)android_os_Parcel_restoreAllowFds}, + + {"nativeWriteByteArray", "(J[BII)V", (void*)android_os_Parcel_writeNative}, + {"nativeWriteInt", "(JI)V", (void*)android_os_Parcel_writeInt}, + {"nativeWriteLong", "(JJ)V", (void*)android_os_Parcel_writeLong}, + {"nativeWriteFloat", "(JF)V", (void*)android_os_Parcel_writeFloat}, + {"nativeWriteDouble", "(JD)V", (void*)android_os_Parcel_writeDouble}, + {"nativeWriteString", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeString}, + {"nativeWriteStrongBinder", "(JLandroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder}, + {"nativeWriteFileDescriptor", "(JLjava/io/FileDescriptor;)V", (void*)android_os_Parcel_writeFileDescriptor}, + + {"nativeCreateByteArray", "(J)[B", (void*)android_os_Parcel_createByteArray}, + {"nativeReadInt", "(J)I", (void*)android_os_Parcel_readInt}, + {"nativeReadLong", "(J)J", (void*)android_os_Parcel_readLong}, + {"nativeReadFloat", "(J)F", (void*)android_os_Parcel_readFloat}, + {"nativeReadDouble", "(J)D", (void*)android_os_Parcel_readDouble}, + {"nativeReadString", "(J)Ljava/lang/String;", (void*)android_os_Parcel_readString}, + {"nativeReadStrongBinder", "(J)Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder}, + {"nativeReadFileDescriptor", "(J)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor}, {"openFileDescriptor", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_openFileDescriptor}, {"dupFileDescriptor", "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_dupFileDescriptor}, {"closeFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_closeFileDescriptor}, {"clearFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_clearFileDescriptor}, - {"nativeCreate", "()I", (void*)android_os_Parcel_create}, - {"nativeFreeBuffer", "(I)V", (void*)android_os_Parcel_freeBuffer}, - {"nativeDestroy", "(I)V", (void*)android_os_Parcel_destroy}, + {"nativeCreate", "()J", (void*)android_os_Parcel_create}, + {"nativeFreeBuffer", "(J)V", (void*)android_os_Parcel_freeBuffer}, + {"nativeDestroy", "(J)V", (void*)android_os_Parcel_destroy}, - {"nativeMarshall", "(I)[B", (void*)android_os_Parcel_marshall}, - {"nativeUnmarshall", "(I[BII)V", (void*)android_os_Parcel_unmarshall}, - {"nativeAppendFrom", "(IIII)V", (void*)android_os_Parcel_appendFrom}, - {"nativeHasFileDescriptors", "(I)Z", (void*)android_os_Parcel_hasFileDescriptors}, - {"nativeWriteInterfaceToken", "(ILjava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken}, - {"nativeEnforceInterface", "(ILjava/lang/String;)V", (void*)android_os_Parcel_enforceInterface}, + {"nativeMarshall", "(J)[B", (void*)android_os_Parcel_marshall}, + {"nativeUnmarshall", "(J[BII)V", (void*)android_os_Parcel_unmarshall}, + {"nativeAppendFrom", "(JJII)V", (void*)android_os_Parcel_appendFrom}, + {"nativeHasFileDescriptors", "(J)Z", (void*)android_os_Parcel_hasFileDescriptors}, + {"nativeWriteInterfaceToken", "(JLjava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken}, + {"nativeEnforceInterface", "(JLjava/lang/String;)V", (void*)android_os_Parcel_enforceInterface}, }; const char* const kParcelPathName = "android/os/Parcel"; @@ -678,7 +678,7 @@ int register_android_os_Parcel(JNIEnv* env) LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Parcel"); gParcelOffsets.clazz = (jclass) env->NewGlobalRef(clazz); - gParcelOffsets.mNativePtr = env->GetFieldID(clazz, "mNativePtr", "I"); + gParcelOffsets.mNativePtr = env->GetFieldID(clazz, "mNativePtr", "J"); gParcelOffsets.obtain = env->GetStaticMethodID(clazz, "obtain", "()Landroid/os/Parcel;"); gParcelOffsets.recycle = env->GetMethodID(clazz, "recycle", "()V"); diff --git a/core/jni/android_os_SystemClock.cpp b/core/jni/android_os_SystemClock.cpp index d20b800..5f4d570 100644 --- a/core/jni/android_os_SystemClock.cpp +++ b/core/jni/android_os_SystemClock.cpp @@ -43,16 +43,77 @@ namespace android { +static int setCurrentTimeMillisAlarmDriver(struct timeval *tv) +{ + struct timespec ts; + int fd; + int res; + + fd = open("/dev/alarm", O_RDWR); + if(fd < 0) { + ALOGV("Unable to open alarm driver: %s\n", strerror(errno)); + return -1; + } + ts.tv_sec = tv->tv_sec; + ts.tv_nsec = tv->tv_usec * 1000; + res = ioctl(fd, ANDROID_ALARM_SET_RTC, &ts); + if (res < 0) + ALOGV("ANDROID_ALARM_SET_RTC ioctl failed: %s\n", strerror(errno)); + close(fd); + return res; +} + +static int setCurrentTimeMillisRtc(struct timeval *tv) +{ + struct rtc_time rtc; + struct tm tm, *gmtime_res; + int fd; + int res; + + fd = open("/dev/rtc0", O_RDWR); + if (fd < 0) { + ALOGV("Unable to open RTC driver: %s\n", strerror(errno)); + return -1; + } + + res = settimeofday(tv, NULL); + if (res < 0) { + ALOGV("settimeofday() failed: %s\n", strerror(errno)); + goto done; + } + + gmtime_res = gmtime_r(&tv->tv_sec, &tm); + if (!gmtime_res) { + ALOGV("gmtime_r() failed: %s\n", strerror(errno)); + res = -1; + goto done; + } + + memset(&rtc, 0, sizeof(rtc)); + rtc.tm_sec = tm.tm_sec; + rtc.tm_min = tm.tm_min; + rtc.tm_hour = tm.tm_hour; + rtc.tm_mday = tm.tm_mday; + rtc.tm_mon = tm.tm_mon; + rtc.tm_year = tm.tm_year; + rtc.tm_wday = tm.tm_wday; + rtc.tm_yday = tm.tm_yday; + rtc.tm_isdst = tm.tm_isdst; + res = ioctl(fd, RTC_SET_TIME, &rtc); + if (res < 0) + ALOGV("RTC_SET_TIME ioctl failed: %s\n", strerror(errno)); +done: + close(fd); + return res; +} + /* * Set the current time. This only works when running as root. */ static int setCurrentTimeMillis(int64_t millis) { struct timeval tv; - struct timespec ts; - int fd; - int res; - int ret = 0; + int ret; if (millis <= 0 || millis / 1000LL >= INT_MAX) { return -1; @@ -63,19 +124,14 @@ static int setCurrentTimeMillis(int64_t millis) ALOGD("Setting time of day to sec=%d\n", (int) tv.tv_sec); - fd = open("/dev/alarm", O_RDWR); - if(fd < 0) { - ALOGW("Unable to open alarm driver: %s\n", strerror(errno)); - return -1; - } - ts.tv_sec = tv.tv_sec; - ts.tv_nsec = tv.tv_usec * 1000; - res = ioctl(fd, ANDROID_ALARM_SET_RTC, &ts); - if(res < 0) { + ret = setCurrentTimeMillisAlarmDriver(&tv); + if (ret < 0) + ret = setCurrentTimeMillisRtc(&tv); + + if(ret < 0) { ALOGW("Unable to set rtc to %ld: %s\n", tv.tv_sec, strerror(errno)); ret = -1; } - close(fd); return ret; } diff --git a/core/jni/android_util_AssetManager.cpp b/core/jni/android_util_AssetManager.cpp index 2c23f9d..8836918 100644 --- a/core/jni/android_util_AssetManager.cpp +++ b/core/jni/android_util_AssetManager.cpp @@ -229,7 +229,8 @@ static jint android_content_AssetManager_openNonAssetNative(JNIEnv* env, jobject } Asset* a = cookie - ? am->openNonAsset((void*)cookie, fileName8.c_str(), (Asset::AccessMode)mode) + ? am->openNonAsset(static_cast<int32_t>(cookie), fileName8.c_str(), + (Asset::AccessMode)mode) : am->openNonAsset(fileName8.c_str(), (Asset::AccessMode)mode); if (a == NULL) { @@ -260,7 +261,7 @@ static jobject android_content_AssetManager_openNonAssetFdNative(JNIEnv* env, jo } Asset* a = cookie - ? am->openNonAsset((void*)cookie, fileName8.c_str(), Asset::ACCESS_RANDOM) + ? am->openNonAsset(static_cast<int32_t>(cookie), fileName8.c_str(), Asset::ACCESS_RANDOM) : am->openNonAsset(fileName8.c_str(), Asset::ACCESS_RANDOM); if (a == NULL) { @@ -435,10 +436,10 @@ static jint android_content_AssetManager_addAssetPath(JNIEnv* env, jobject clazz return 0; } - void* cookie; + int32_t cookie; bool res = am->addAssetPath(String8(path8.c_str()), &cookie); - return (res) ? (jint)cookie : 0; + return (res) ? static_cast<jint>(cookie) : 0; } static jboolean android_content_AssetManager_isUpToDate(JNIEnv* env, jobject clazz) @@ -800,7 +801,7 @@ static jstring android_content_AssetManager_getCookieName(JNIEnv* env, jobject c if (am == NULL) { return NULL; } - String8 name(am->getAssetPath((void*)cookie)); + String8 name(am->getAssetPath(static_cast<int32_t>(cookie))); if (name.length() == 0) { jniThrowException(env, "java/lang/IndexOutOfBoundsException", "Empty cookie name"); return NULL; @@ -1386,7 +1387,7 @@ static jint android_content_AssetManager_openXmlAssetNative(JNIEnv* env, jobject } Asset* a = cookie - ? am->openNonAsset((void*)cookie, fileName8.c_str(), Asset::ACCESS_BUFFER) + ? am->openNonAsset(static_cast<int32_t>(cookie), fileName8.c_str(), Asset::ACCESS_BUFFER) : am->openNonAsset(fileName8.c_str(), Asset::ACCESS_BUFFER); if (a == NULL) { diff --git a/core/jni/android_util_Binder.cpp b/core/jni/android_util_Binder.cpp index 3ac2225..475e926 100644 --- a/core/jni/android_util_Binder.cpp +++ b/core/jni/android_util_Binder.cpp @@ -267,7 +267,7 @@ protected: //data.print(); //printf("\n"); jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact, - code, (int32_t)&data, (int32_t)reply, flags); + code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags); jthrowable excep = env->ExceptionOccurred(); if (excep) { @@ -577,7 +577,7 @@ jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val) if (object != NULL) { LOGDEATH("objectForBinder %p: created new proxy %p !\n", val.get(), object); // The proxy holds a reference to the native object. - env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get()); + env->SetLongField(object, gBinderProxyOffsets.mObject, (jlong)val.get()); val->incStrong((void*)javaObjectForIBinder); // The native object needs to hold a weak reference back to the @@ -590,7 +590,7 @@ jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val) // Also remember the death recipients registered on this proxy sp<DeathRecipientList> drl = new DeathRecipientList; drl->incStrong((void*)javaObjectForIBinder); - env->SetIntField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jint>(drl.get())); + env->SetLongField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jlong>(drl.get())); // Note that a new object reference has been created. android_atomic_inc(&gNumProxyRefs); @@ -606,13 +606,13 @@ sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj) if (env->IsInstanceOf(obj, gBinderOffsets.mClass)) { JavaBBinderHolder* jbh = (JavaBBinderHolder*) - env->GetIntField(obj, gBinderOffsets.mObject); + env->GetLongField(obj, gBinderOffsets.mObject); return jbh != NULL ? jbh->get(env, obj) : NULL; } if (env->IsInstanceOf(obj, gBinderProxyOffsets.mClass)) { return (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); } ALOGW("ibinderForJavaObject: %p is not a Binder object", obj); @@ -764,15 +764,15 @@ static void android_os_Binder_init(JNIEnv* env, jobject obj) } ALOGV("Java Binder %p: acquiring first ref on holder %p", obj, jbh); jbh->incStrong((void*)android_os_Binder_init); - env->SetIntField(obj, gBinderOffsets.mObject, (int)jbh); + env->SetLongField(obj, gBinderOffsets.mObject, (jlong)jbh); } static void android_os_Binder_destroy(JNIEnv* env, jobject obj) { JavaBBinderHolder* jbh = (JavaBBinderHolder*) - env->GetIntField(obj, gBinderOffsets.mObject); + env->GetLongField(obj, gBinderOffsets.mObject); if (jbh != NULL) { - env->SetIntField(obj, gBinderOffsets.mObject, 0); + env->SetLongField(obj, gBinderOffsets.mObject, 0); ALOGV("Java Binder %p: removing ref on holder %p", obj, jbh); jbh->decStrong((void*)android_os_Binder_init); } else { @@ -812,11 +812,11 @@ static int int_register_android_os_Binder(JNIEnv* env) gBinderOffsets.mClass = (jclass) env->NewGlobalRef(clazz); gBinderOffsets.mExecTransact - = env->GetMethodID(clazz, "execTransact", "(IIII)Z"); + = env->GetMethodID(clazz, "execTransact", "(IJJI)Z"); assert(gBinderOffsets.mExecTransact); gBinderOffsets.mObject - = env->GetFieldID(clazz, "mObject", "I"); + = env->GetFieldID(clazz, "mObject", "J"); assert(gBinderOffsets.mObject); return AndroidRuntime::registerNativeMethods( @@ -911,7 +911,7 @@ static int int_register_android_os_BinderInternal(JNIEnv* env) static jboolean android_os_BinderProxy_pingBinder(JNIEnv* env, jobject obj) { IBinder* target = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target == NULL) { return JNI_FALSE; } @@ -921,7 +921,7 @@ static jboolean android_os_BinderProxy_pingBinder(JNIEnv* env, jobject obj) static jstring android_os_BinderProxy_getInterfaceDescriptor(JNIEnv* env, jobject obj) { - IBinder* target = (IBinder*) env->GetIntField(obj, gBinderProxyOffsets.mObject); + IBinder* target = (IBinder*) env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target != NULL) { const String16& desc = target->getInterfaceDescriptor(); return env->NewString(desc.string(), desc.size()); @@ -934,7 +934,7 @@ static jstring android_os_BinderProxy_getInterfaceDescriptor(JNIEnv* env, jobjec static jboolean android_os_BinderProxy_isBinderAlive(JNIEnv* env, jobject obj) { IBinder* target = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target == NULL) { return JNI_FALSE; } @@ -943,13 +943,20 @@ static jboolean android_os_BinderProxy_isBinderAlive(JNIEnv* env, jobject obj) } static int getprocname(pid_t pid, char *buf, size_t len) { - char filename[20]; + char filename[32]; FILE *f; - sprintf(filename, "/proc/%d/cmdline", pid); + snprintf(filename, sizeof(filename), "/proc/%d/cmdline", pid); f = fopen(filename, "r"); - if (!f) { *buf = '\0'; return 1; } - if (!fgets(buf, len, f)) { *buf = '\0'; return 2; } + if (!f) { + *buf = '\0'; + return 1; + } + if (!fgets(buf, len, f)) { + *buf = '\0'; + fclose(f); + return 2; + } fclose(f); return 0; } @@ -1055,7 +1062,7 @@ static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj, } IBinder* target = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target == NULL) { jniThrowException(env, "java/lang/IllegalStateException", "Binder has been finalized!"); return JNI_FALSE; @@ -1102,7 +1109,7 @@ static void android_os_BinderProxy_linkToDeath(JNIEnv* env, jobject obj, } IBinder* target = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target == NULL) { ALOGW("Binder has been finalized when calling linkToDeath() with recip=%p)\n", recipient); assert(false); @@ -1112,7 +1119,7 @@ static void android_os_BinderProxy_linkToDeath(JNIEnv* env, jobject obj, if (!target->localBinder()) { DeathRecipientList* list = (DeathRecipientList*) - env->GetIntField(obj, gBinderProxyOffsets.mOrgue); + env->GetLongField(obj, gBinderProxyOffsets.mOrgue); sp<JavaDeathRecipient> jdr = new JavaDeathRecipient(env, recipient, list); status_t err = target->linkToDeath(jdr, NULL, flags); if (err != NO_ERROR) { @@ -1134,7 +1141,7 @@ static jboolean android_os_BinderProxy_unlinkToDeath(JNIEnv* env, jobject obj, } IBinder* target = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); if (target == NULL) { ALOGW("Binder has been finalized when calling linkToDeath() with recip=%p)\n", recipient); return JNI_FALSE; @@ -1147,7 +1154,7 @@ static jboolean android_os_BinderProxy_unlinkToDeath(JNIEnv* env, jobject obj, // If we find the matching recipient, proceed to unlink using that DeathRecipientList* list = (DeathRecipientList*) - env->GetIntField(obj, gBinderProxyOffsets.mOrgue); + env->GetLongField(obj, gBinderProxyOffsets.mOrgue); sp<JavaDeathRecipient> origJDR = list->find(recipient); LOGDEATH(" unlink found list %p and JDR %p", list, origJDR.get()); if (origJDR != NULL) { @@ -1176,13 +1183,13 @@ static jboolean android_os_BinderProxy_unlinkToDeath(JNIEnv* env, jobject obj, static void android_os_BinderProxy_destroy(JNIEnv* env, jobject obj) { IBinder* b = (IBinder*) - env->GetIntField(obj, gBinderProxyOffsets.mObject); + env->GetLongField(obj, gBinderProxyOffsets.mObject); DeathRecipientList* drl = (DeathRecipientList*) - env->GetIntField(obj, gBinderProxyOffsets.mOrgue); + env->GetLongField(obj, gBinderProxyOffsets.mOrgue); LOGDEATH("Destroying BinderProxy %p: binder=%p drl=%p\n", obj, b, drl); - env->SetIntField(obj, gBinderProxyOffsets.mObject, 0); - env->SetIntField(obj, gBinderProxyOffsets.mOrgue, 0); + env->SetLongField(obj, gBinderProxyOffsets.mObject, 0); + env->SetLongField(obj, gBinderProxyOffsets.mOrgue, 0); drl->decStrong((void*)javaObjectForIBinder); b->decStrong((void*)javaObjectForIBinder); @@ -1224,13 +1231,13 @@ static int int_register_android_os_BinderProxy(JNIEnv* env) assert(gBinderProxyOffsets.mSendDeathNotice); gBinderProxyOffsets.mObject - = env->GetFieldID(clazz, "mObject", "I"); + = env->GetFieldID(clazz, "mObject", "J"); assert(gBinderProxyOffsets.mObject); gBinderProxyOffsets.mSelf = env->GetFieldID(clazz, "mSelf", "Ljava/lang/ref/WeakReference;"); assert(gBinderProxyOffsets.mSelf); gBinderProxyOffsets.mOrgue - = env->GetFieldID(clazz, "mOrgue", "I"); + = env->GetFieldID(clazz, "mOrgue", "J"); assert(gBinderProxyOffsets.mOrgue); clazz = env->FindClass("java/lang/Class"); diff --git a/core/jni/android_util_EventLog.cpp b/core/jni/android_util_EventLog.cpp index 83d8aa2..8a0eaa2 100644 --- a/core/jni/android_util_EventLog.cpp +++ b/core/jni/android_util_EventLog.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007 The Android Open Source Project + * Copyright (C) 2007-2014 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. @@ -21,6 +21,8 @@ #include "jni.h" #include "log/logger.h" +#define UNUSED __attribute__((__unused__)) + // The size of the tag number comes out of the payload size. #define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t)) @@ -44,7 +46,8 @@ static jclass gStringClass; * In class android.util.EventLog: * static native int writeEvent(int tag, int value) */ -static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env, jobject clazz, +static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env UNUSED, + jobject clazz UNUSED, jint tag, jint value) { return android_btWriteLog(tag, EVENT_TYPE_INT, &value, sizeof(value)); @@ -54,7 +57,8 @@ static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env, jobject clazz, * In class android.util.EventLog: * static native int writeEvent(long tag, long value) */ -static jint android_util_EventLog_writeEvent_Long(JNIEnv* env, jobject clazz, +static jint android_util_EventLog_writeEvent_Long(JNIEnv* env UNUSED, + jobject clazz UNUSED, jint tag, jlong value) { return android_btWriteLog(tag, EVENT_TYPE_LONG, &value, sizeof(value)); @@ -64,7 +68,8 @@ static jint android_util_EventLog_writeEvent_Long(JNIEnv* env, jobject clazz, * In class android.util.EventLog: * static native int writeEvent(int tag, String value) */ -static jint android_util_EventLog_writeEvent_String(JNIEnv* env, jobject clazz, +static jint android_util_EventLog_writeEvent_String(JNIEnv* env, + jobject clazz UNUSED, jint tag, jstring value) { uint8_t buf[MAX_EVENT_PAYLOAD]; @@ -142,18 +147,21 @@ static jint android_util_EventLog_writeEvent_Array(JNIEnv* env, jobject clazz, * In class android.util.EventLog: * static native void readEvents(int[] tags, Collection<Event> output) * - * Reads events from the event log, typically /dev/log/events + * Reads events from the event log */ -static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz, +static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz UNUSED, jintArray tags, jobject out) { + if (tags == NULL || out == NULL) { jniThrowNullPointerException(env, NULL); return; } - int fd = open("/dev/" LOGGER_LOG_EVENTS, O_RDONLY | O_NONBLOCK); - if (fd < 0) { + struct logger_list *logger_list = android_logger_list_open( + LOG_ID_EVENTS, O_RDONLY | O_NONBLOCK, 0, 0); + + if (!logger_list) { jniThrowIOException(env, errno); return; } @@ -161,41 +169,26 @@ static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz, jsize tagLength = env->GetArrayLength(tags); jint *tagValues = env->GetIntArrayElements(tags, NULL); - uint8_t buf[LOGGER_ENTRY_MAX_LEN]; - struct timeval timeout = {0, 0}; - fd_set readset; - FD_ZERO(&readset); - - for (;;) { - // Use a short select() to try to avoid problems hanging on read(). - // This means we block for 5ms at the end of the log -- oh well. - timeout.tv_usec = 5000; - FD_SET(fd, &readset); - int r = select(fd + 1, &readset, NULL, NULL, &timeout); - if (r == 0) { - break; // no more events - } else if (r < 0 && errno == EINTR) { - continue; // interrupted by signal, try again - } else if (r < 0) { - jniThrowIOException(env, errno); // Will throw on return - break; - } + while (1) { + log_msg log_msg; + int ret = android_logger_list_read(logger_list, &log_msg); - int len = read(fd, buf, sizeof(buf)); - if (len == 0 || (len < 0 && errno == EAGAIN)) { - break; // no more events - } else if (len < 0 && errno == EINTR) { - continue; // interrupted by signal, try again - } else if (len < 0) { - jniThrowIOException(env, errno); // Will throw on return + if (ret == 0) { break; - } else if ((size_t) len < sizeof(logger_entry) + sizeof(int32_t)) { - jniThrowException(env, "java/io/IOException", "Event too short"); + } + if (ret < 0) { + if (ret == -EINTR) { + continue; + } + if (ret == -EINVAL) { + jniThrowException(env, "java/io/IOException", "Event too short"); + } else if (ret != -EAGAIN) { + jniThrowIOException(env, -ret); // Will throw on return + } break; } - logger_entry* entry = (logger_entry*) buf; - int32_t tag = * (int32_t*) (buf + sizeof(*entry)); + int32_t tag = * (int32_t *) log_msg.msg(); int found = 0; for (int i = 0; !found && i < tagLength; ++i) { @@ -203,16 +196,20 @@ static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz, } if (found) { - jsize len = sizeof(*entry) + entry->len; + jsize len = ret; jbyteArray array = env->NewByteArray(len); - if (array == NULL) break; + if (array == NULL) { + break; + } jbyte *bytes = env->GetByteArrayElements(array, NULL); - memcpy(bytes, buf, len); + memcpy(bytes, log_msg.buf, len); env->ReleaseByteArrayElements(array, bytes, 0); jobject event = env->NewObject(gEventClass, gEventInitID, array); - if (event == NULL) break; + if (event == NULL) { + break; + } env->CallBooleanMethod(out, gCollectionAddID, event); env->DeleteLocalRef(event); @@ -220,7 +217,8 @@ static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz, } } - close(fd); + android_logger_list_close(logger_list); + env->ReleaseIntArrayElements(tags, tagValues, 0); } diff --git a/core/jni/android_util_Process.cpp b/core/jni/android_util_Process.cpp index 8325217..cbed99f 100644 --- a/core/jni/android_util_Process.cpp +++ b/core/jni/android_util_Process.cpp @@ -344,23 +344,6 @@ jint android_os_Process_getThreadPriority(JNIEnv* env, jobject clazz, return pri; } -jboolean android_os_Process_setOomAdj(JNIEnv* env, jobject clazz, - jint pid, jint adj) -{ -#ifdef HAVE_OOM_ADJ - char text[64]; - sprintf(text, "/proc/%d/oom_adj", pid); - int fd = open(text, O_WRONLY); - if (fd >= 0) { - sprintf(text, "%d", adj); - write(fd, text, strlen(text)); - close(fd); - } - return true; -#endif - return false; -} - jboolean android_os_Process_setSwappiness(JNIEnv *env, jobject clazz, jint pid, jboolean is_increased) { @@ -422,7 +405,7 @@ static int pid_compare(const void* v1, const void* v2) return *((const jint*)v1) - *((const jint*)v2); } -static jlong getFreeMemoryImpl(const char* const sums[], const int sumsLen[], int num) +static jlong getFreeMemoryImpl(const char* const sums[], const size_t sumsLen[], size_t num) { int fd = open("/proc/meminfo", O_RDONLY); @@ -441,7 +424,7 @@ static jlong getFreeMemoryImpl(const char* const sums[], const int sumsLen[], in } buffer[len] = 0; - int numFound = 0; + size_t numFound = 0; jlong mem = 0; char* p = buffer; @@ -473,14 +456,14 @@ static jlong getFreeMemoryImpl(const char* const sums[], const int sumsLen[], in static jlong android_os_Process_getFreeMemory(JNIEnv* env, jobject clazz) { static const char* const sums[] = { "MemFree:", "Cached:", NULL }; - static const int sumsLen[] = { strlen("MemFree:"), strlen("Cached:"), 0 }; + static const size_t sumsLen[] = { strlen("MemFree:"), strlen("Cached:"), 0 }; return getFreeMemoryImpl(sums, sumsLen, 2); } static jlong android_os_Process_getTotalMemory(JNIEnv* env, jobject clazz) { static const char* const sums[] = { "MemTotal:", NULL }; - static const int sumsLen[] = { strlen("MemTotal:"), 0 }; + static const size_t sumsLen[] = { strlen("MemTotal:"), 0 }; return getFreeMemoryImpl(sums, sumsLen, 1); } @@ -745,7 +728,7 @@ jboolean android_os_Process_parseProcLineArray(JNIEnv* env, jobject clazz, jsize end = -1; if ((mode&PROC_PARENS) != 0) { - while (buffer[i] != ')' && i < endIndex) { + while (i < endIndex && buffer[i] != ')') { i++; } end = i; @@ -757,7 +740,7 @@ jboolean android_os_Process_parseProcLineArray(JNIEnv* env, jobject clazz, end = i; i++; } - while (buffer[i] != term && i < endIndex) { + while (i < endIndex && buffer[i] != term) { i++; } if (end < 0) { @@ -767,7 +750,7 @@ jboolean android_os_Process_parseProcLineArray(JNIEnv* env, jobject clazz, if (i < endIndex) { i++; if ((mode&PROC_COMBINE) != 0) { - while (buffer[i] == term && i < endIndex) { + while (i < endIndex && buffer[i] == term) { i++; } } @@ -1023,7 +1006,6 @@ static const JNINativeMethod methods[] = { {"setThreadGroup", "(II)V", (void*)android_os_Process_setThreadGroup}, {"setProcessGroup", "(II)V", (void*)android_os_Process_setProcessGroup}, {"getProcessGroup", "(I)I", (void*)android_os_Process_getProcessGroup}, - {"setOomAdj", "(II)Z", (void*)android_os_Process_setOomAdj}, {"setSwappiness", "(IZ)Z", (void*)android_os_Process_setSwappiness}, {"setArgV0", "(Ljava/lang/String;)V", (void*)android_os_Process_setArgV0}, {"setUid", "(I)I", (void*)android_os_Process_setUid}, diff --git a/core/jni/android_view_DisplayEventReceiver.cpp b/core/jni/android_view_DisplayEventReceiver.cpp index 64fb27b..d4cc159 100644 --- a/core/jni/android_view_DisplayEventReceiver.cpp +++ b/core/jni/android_view_DisplayEventReceiver.cpp @@ -87,7 +87,7 @@ status_t NativeDisplayEventReceiver::initialize() { return result; } - int rc = mMessageQueue->getLooper()->addFd(mReceiver.getFd(), 0, ALOOPER_EVENT_INPUT, + int rc = mMessageQueue->getLooper()->addFd(mReceiver.getFd(), 0, Looper::EVENT_INPUT, this, NULL); if (rc < 0) { return UNKNOWN_ERROR; @@ -125,13 +125,13 @@ status_t NativeDisplayEventReceiver::scheduleVsync() { } int NativeDisplayEventReceiver::handleEvent(int receiveFd, int events, void* data) { - if (events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP)) { + if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) { ALOGE("Display event receiver pipe was closed or an error occurred. " "events=0x%x", events); return 0; // remove the callback } - if (!(events & ALOOPER_EVENT_INPUT)) { + if (!(events & Looper::EVENT_INPUT)) { ALOGW("Received spurious callback for unhandled poll event. " "events=0x%x", events); return 1; // keep the callback @@ -207,7 +207,7 @@ void NativeDisplayEventReceiver::dispatchHotplug(nsecs_t timestamp, int32_t id, } -static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverObj, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverObj, jobject messageQueueObj) { sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj); if (messageQueue == NULL) { @@ -226,17 +226,17 @@ static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverObj, } receiver->incStrong(gDisplayEventReceiverClassInfo.clazz); // retain a reference for the object - return reinterpret_cast<jint>(receiver.get()); + return reinterpret_cast<jlong>(receiver.get()); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint receiverPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong receiverPtr) { sp<NativeDisplayEventReceiver> receiver = reinterpret_cast<NativeDisplayEventReceiver*>(receiverPtr); receiver->dispose(); receiver->decStrong(gDisplayEventReceiverClassInfo.clazz); // drop reference held by the object } -static void nativeScheduleVsync(JNIEnv* env, jclass clazz, jint receiverPtr) { +static void nativeScheduleVsync(JNIEnv* env, jclass clazz, jlong receiverPtr) { sp<NativeDisplayEventReceiver> receiver = reinterpret_cast<NativeDisplayEventReceiver*>(receiverPtr); status_t status = receiver->scheduleVsync(); @@ -251,12 +251,12 @@ static void nativeScheduleVsync(JNIEnv* env, jclass clazz, jint receiverPtr) { static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Landroid/view/DisplayEventReceiver;Landroid/os/MessageQueue;)I", + "(Landroid/view/DisplayEventReceiver;Landroid/os/MessageQueue;)J", (void*)nativeInit }, { "nativeDispose", - "(I)V", + "(J)V", (void*)nativeDispose }, - { "nativeScheduleVsync", "(I)V", + { "nativeScheduleVsync", "(J)V", (void*)nativeScheduleVsync } }; diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp index b720e73..d3c40cf 100644 --- a/core/jni/android_view_GLES20Canvas.cpp +++ b/core/jni/android_view_GLES20Canvas.cpp @@ -94,17 +94,17 @@ static struct { // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_flushCaches(JNIEnv* env, jobject clazz, - Caches::FlushMode mode) { + jint mode) { if (Caches::hasInstance()) { - Caches::getInstance().flush(mode); + Caches::getInstance().flush(static_cast<Caches::FlushMode>(mode)); } } -static bool android_view_GLES20Canvas_initCaches(JNIEnv* env, jobject clazz) { +static jboolean android_view_GLES20Canvas_initCaches(JNIEnv* env, jobject clazz) { if (Caches::hasInstance()) { - return Caches::getInstance().init(); + return Caches::getInstance().init() ? JNI_TRUE : JNI_FALSE; } - return false; + return JNI_FALSE; } static void android_view_GLES20Canvas_terminateCaches(JNIEnv* env, jobject clazz) { @@ -132,15 +132,16 @@ static void android_view_GLES20Canvas_initAtlas(JNIEnv* env, jobject clazz, // Constructors // ---------------------------------------------------------------------------- -static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) { +static jlong android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) { RENDERER_LOGD("Create OpenGLRenderer"); OpenGLRenderer* renderer = new OpenGLRenderer(); renderer->initProperties(); - return renderer; + return reinterpret_cast<jlong>(renderer); } static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); RENDERER_LOGD("Destroy OpenGLRenderer"); delete renderer; } @@ -150,23 +151,27 @@ static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_setViewport(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint width, jint height) { + jlong rendererHandle, jint width, jint height) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->setViewport(width, height); } -static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jboolean opaque) { +static jint android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz, + jlong rendererHandle, jboolean opaque) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->prepare(opaque); } -static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom, +static jint android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz, + jlong rendererHandle, jint left, jint top, jint right, jint bottom, jboolean opaque) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->prepareDirty(left, top, right, bottom, opaque); } static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->finish(); } @@ -175,7 +180,8 @@ static jint android_view_GLES20Canvas_getStencilSize(JNIEnv* env, jobject clazz) } static void android_view_GLES20Canvas_setName(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, jstring name) { + jobject clazz, jlong rendererHandle, jstring name) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); if (name != NULL) { const char* textArray = env->GetStringUTFChars(name, NULL); renderer->setName(textArray); @@ -186,12 +192,14 @@ static void android_view_GLES20Canvas_setName(JNIEnv* env, } static void android_view_GLES20Canvas_setCountOverdrawEnabled(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jboolean enabled) { + jlong rendererHandle, jboolean enabled) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->setCountOverdrawEnabled(enabled); } static jfloat android_view_GLES20Canvas_getOverdraw(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->getOverdraw(); } @@ -200,23 +208,30 @@ static jfloat android_view_GLES20Canvas_getOverdraw(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static jint android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, Functor* functor) { + jlong rendererHandle, jlong functorHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + Functor* functor = reinterpret_cast<Functor*>(functorHandle); android::uirenderer::Rect dirty; return renderer->callDrawGLFunction(functor, dirty); } static void android_view_GLES20Canvas_detachFunctor(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, Functor* functor) { + jobject clazz, jlong rendererPtr, jlong functorPtr) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr); + Functor* functor = reinterpret_cast<Functor*>(functorPtr); renderer->detachFunctor(functor); } static void android_view_GLES20Canvas_attachFunctor(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, Functor* functor) { + jobject clazz, jlong rendererHandle, jlong functorHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + Functor* functor = reinterpret_cast<Functor*>(functorHandle); renderer->attachFunctor(functor); } static jint android_view_GLES20Canvas_invokeFunctors(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, jobject dirty) { + jobject clazz, jlong rendererHandle, jobject dirty) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); android::uirenderer::Rect bounds; status_t status = renderer->invokeFunctors(bounds); if (status != DrawGlInfo::kStatusDone && dirty != NULL) { @@ -242,23 +257,27 @@ static jint android_view_GLES20Canvas_getMaxTextureHeight(JNIEnv* env, jobject c // State // ---------------------------------------------------------------------------- -static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, OpenGLRenderer* renderer, +static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, jlong rendererHandle, jint flags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->save(flags); } static jint android_view_GLES20Canvas_getSaveCount(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->getSaveCount(); } static void android_view_GLES20Canvas_restore(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->restore(); } static void android_view_GLES20Canvas_restoreToCount(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint saveCount) { + jlong rendererHandle, jint saveCount) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->restoreToCount(saveCount); } @@ -267,26 +286,32 @@ static void android_view_GLES20Canvas_restoreToCount(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static jint android_view_GLES20Canvas_saveLayer(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - SkPaint* paint, jint saveFlags) { + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jlong paintHandle, jint saveFlags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); return renderer->saveLayer(left, top, right, bottom, paint, saveFlags); } static jint android_view_GLES20Canvas_saveLayerClip(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkPaint* paint, jint saveFlags) { + jlong rendererHandle, jlong paintHandle, jint saveFlags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const android::uirenderer::Rect& bounds(renderer->getClipBounds()); return renderer->saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, saveFlags); } static jint android_view_GLES20Canvas_saveLayerAlpha(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint alpha, jint saveFlags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); return renderer->saveLayerAlpha(left, top, right, bottom, alpha, saveFlags); } static jint android_view_GLES20Canvas_saveLayerAlphaClip(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint alpha, jint saveFlags) { + jlong rendererHandle, jint alpha, jint saveFlags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); const android::uirenderer::Rect& bounds(renderer->getClipBounds()); return renderer->saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom, alpha, saveFlags); @@ -296,41 +321,57 @@ static jint android_view_GLES20Canvas_saveLayerAlphaClip(JNIEnv* env, jobject cl // Clipping // ---------------------------------------------------------------------------- -static bool android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) { - return renderer->quickRejectNoScissor(left, top, right, bottom); +static jboolean android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject clazz, + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + bool result = renderer->quickRejectNoScissor(left, top, right, bottom); + return result ? JNI_TRUE : JNI_FALSE; } -static bool android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - SkRegion::Op op) { - return renderer->clipRect(left, top, right, bottom, op); +static jboolean android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject clazz, + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jint opHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); + bool result; + result = renderer->clipRect(left, top, right, bottom, op); + return result ? JNI_TRUE : JNI_FALSE; } -static bool android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom, - SkRegion::Op op) { - return renderer->clipRect(float(left), float(top), float(right), float(bottom), op); +static jboolean android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject clazz, + jlong rendererHandle, jint left, jint top, jint right, jint bottom, + jint opHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); + bool result = renderer->clipRect(float(left), float(top), float(right), float(bottom), op); + return result ? JNI_TRUE : JNI_FALSE; } -static bool android_view_GLES20Canvas_clipPath(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkPath* path, SkRegion::Op op) { - return renderer->clipPath(path, op); +static jboolean android_view_GLES20Canvas_clipPath(JNIEnv* env, jobject clazz, + jlong rendererHandle, jlong pathHandle, jint opHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); + return renderer->clipPath(path, op) ? JNI_TRUE : JNI_FALSE; } -static bool android_view_GLES20Canvas_clipRegion(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkRegion* region, SkRegion::Op op) { - return renderer->clipRegion(region, op); +static jboolean android_view_GLES20Canvas_clipRegion(JNIEnv* env, jobject clazz, + jlong rendererHandle, jlong regionHandle, jint opHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); + return renderer->clipRegion(region, op) ? JNI_TRUE : JNI_FALSE; } -static bool android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jobject rect) { +static jboolean android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz, + jlong rendererHandle, jobject rect) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); const android::uirenderer::Rect& bounds(renderer->getClipBounds()); env->CallVoidMethod(rect, gRectClassInfo.set, int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom)); - return !bounds.isEmpty(); + return !bounds.isEmpty() ? JNI_TRUE : JNI_FALSE; } // ---------------------------------------------------------------------------- @@ -338,37 +379,47 @@ static bool android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_translate(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat dx, jfloat dy) { + jlong rendererHandle, jfloat dx, jfloat dy) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->translate(dx, dy); } static void android_view_GLES20Canvas_rotate(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat degrees) { + jlong rendererHandle, jfloat degrees) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->rotate(degrees); } static void android_view_GLES20Canvas_scale(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat sx, jfloat sy) { + jlong rendererHandle, jfloat sx, jfloat sy) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->scale(sx, sy); } static void android_view_GLES20Canvas_skew(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat sx, jfloat sy) { + jlong rendererHandle, jfloat sx, jfloat sy) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->skew(sx, sy); } static void android_view_GLES20Canvas_setMatrix(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkMatrix* matrix) { + jlong rendererHandle, jlong matrixHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); renderer->setMatrix(matrix); } static void android_view_GLES20Canvas_getMatrix(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkMatrix* matrix) { + jlong rendererHandle, jlong matrixHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); renderer->getMatrix(matrix); } static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkMatrix* matrix) { + jlong rendererHandle, jlong matrixHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); renderer->concatMatrix(matrix); } @@ -377,8 +428,11 @@ static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, - jfloat left, jfloat top, SkPaint* paint) { + jlong rendererHandle, jlong bitmapHandle, jbyteArray buffer, + jfloat left, jfloat top, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); // This object allows the renderer to allocate a global JNI ref to the buffer object. JavaHeapBitmapRef bitmapRef(env, bitmap, buffer); @@ -386,9 +440,12 @@ static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, - float srcLeft, float srcTop, float srcRight, float srcBottom, - float dstLeft, float dstTop, float dstRight, float dstBottom, SkPaint* paint) { + jlong rendererHandle, jlong bitmapHandle, jbyteArray buffer, + jfloat srcLeft, jfloat srcTop, jfloat srcRight, jfloat srcBottom, + jfloat dstLeft, jfloat dstTop, jfloat dstRight, jfloat dstBottom, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); // This object allows the renderer to allocate a global JNI ref to the buffer object. JavaHeapBitmapRef bitmapRef(env, bitmap, buffer); @@ -397,8 +454,12 @@ static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, - SkMatrix* matrix, SkPaint* paint) { + jlong rendererHandle, jlong bitmapHandle, jbyteArray buffer, + jlong matrixHandle, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); // This object allows the renderer to allocate a global JNI ref to the buffer object. JavaHeapBitmapRef bitmapRef(env, bitmap, buffer); @@ -406,8 +467,10 @@ static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject claz } static void android_view_GLES20Canvas_drawBitmapData(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jintArray colors, jint offset, jint stride, - jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, SkPaint* paint) { + jlong rendererHandle, jintArray colors, jint offset, jint stride, + jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkBitmap* bitmap = new SkBitmap; bitmap->setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, width, height); @@ -431,9 +494,12 @@ static void android_view_GLES20Canvas_drawBitmapData(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawBitmapMesh(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, + jlong rendererHandle, jlong bitmapHandle, jbyteArray buffer, jint meshWidth, jint meshHeight, jfloatArray vertices, jint offset, jintArray colors, - jint colorOffset, SkPaint* paint) { + jint colorOffset, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); // This object allows the renderer to allocate a global JNI ref to the buffer object. JavaHeapBitmapRef bitmapRef(env, bitmap, buffer); @@ -447,8 +513,13 @@ static void android_view_GLES20Canvas_drawBitmapMesh(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, Res_png_9patch* patch, - float left, float top, float right, float bottom, SkPaint* paint) { + jlong rendererHandle, jlong bitmapHandle, jbyteArray buffer, jlong patchHandle, + jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + // This object allows the renderer to allocate a global JNI ref to the buffer object. JavaHeapBitmapRef bitmapRef(env, bitmap, buffer); @@ -456,41 +527,56 @@ static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawColor(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint color, SkXfermode::Mode mode) { + jlong rendererHandle, jint color, SkXfermode::Mode mode) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->drawColor(color, mode); } static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - SkPaint* paint) { + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawRect(left, top, right, bottom, paint); } static void android_view_GLES20Canvas_drawRoundRect(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - jfloat rx, jfloat ry, SkPaint* paint) { + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jfloat rx, jfloat ry, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawRoundRect(left, top, right, bottom, rx, ry, paint); } static void android_view_GLES20Canvas_drawCircle(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat x, jfloat y, jfloat radius, SkPaint* paint) { + jlong rendererHandle, jfloat x, jfloat y, jfloat radius, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawCircle(x, y, radius, paint); } static void android_view_GLES20Canvas_drawOval(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - SkPaint* paint) { + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawOval(left, top, right, bottom, paint); } static void android_view_GLES20Canvas_drawArc(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom, - jfloat startAngle, jfloat sweepAngle, jboolean useCenter, SkPaint* paint) { + jlong rendererHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, + jfloat startAngle, jfloat sweepAngle, jboolean useCenter, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawArc(left, top, right, bottom, startAngle, sweepAngle, useCenter, paint); } static void android_view_GLES20Canvas_drawRegionAsRects(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkRegion* region, SkPaint* paint) { + jlong rendererHandle, jlong regionHandle, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + if (paint->getStyle() != SkPaint::kFill_Style || (paint->isAntiAlias() && !renderer->isCurrentTransformSimple())) { SkRegion::Iterator it(*region); @@ -517,26 +603,35 @@ static void android_view_GLES20Canvas_drawRegionAsRects(JNIEnv* env, jobject cla } static void android_view_GLES20Canvas_drawRects(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloatArray rects, jint count, SkPaint* paint) { + jlong rendererHandle, jfloatArray rects, jint count, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jfloat* storage = env->GetFloatArrayElements(rects, NULL); renderer->drawRects(storage, count, paint); env->ReleaseFloatArrayElements(rects, storage, 0); } static void android_view_GLES20Canvas_drawPoints(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloatArray points, jint offset, jint count, SkPaint* paint) { + jlong rendererHandle, jfloatArray points, jint offset, jint count, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jfloat* storage = env->GetFloatArrayElements(points, NULL); renderer->drawPoints(storage + offset, count, paint); env->ReleaseFloatArrayElements(points, storage, 0); } static void android_view_GLES20Canvas_drawPath(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkPath* path, SkPaint* paint) { + jlong rendererHandle, jlong pathHandle, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); renderer->drawPath(path, paint); } static void android_view_GLES20Canvas_drawLines(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloatArray points, jint offset, jint count, SkPaint* paint) { + jlong rendererHandle, jfloatArray points, jint offset, jint count, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jfloat* storage = env->GetFloatArrayElements(points, NULL); renderer->drawLines(storage + offset, count, paint); env->ReleaseFloatArrayElements(points, storage, 0); @@ -547,24 +642,30 @@ static void android_view_GLES20Canvas_drawLines(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_resetModifiers(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint modifiers) { + jlong rendererHandle, jint modifiers) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); if (modifiers & MODIFIER_SHADOW) renderer->resetShadow(); if (modifiers & MODIFIER_SHADER) renderer->resetShader(); if (modifiers & MODIFIER_COLOR_FILTER) renderer->resetColorFilter(); } static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkiaShader* shader) { + jlong rendererHandle, jlong shaderHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkiaShader* shader = reinterpret_cast<SkiaShader*>(shaderHandle); renderer->setupShader(shader); } static void android_view_GLES20Canvas_setupColorFilter(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, SkiaColorFilter* filter) { + jlong rendererHandle, jlong filterHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkiaColorFilter* filter = reinterpret_cast<SkiaColorFilter*>(filterHandle); renderer->setupColorFilter(filter); } static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jfloat radius, jfloat dx, jfloat dy, jint color) { + jlong rendererHandle, jfloat radius, jfloat dx, jfloat dy, jint color) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->setupShadow(radius, dx, dy, color); } @@ -573,12 +674,14 @@ static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz, // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_setupPaintFilter(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jint clearBits, jint setBits) { + jlong rendererHandle, jint clearBits, jint setBits) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->setupPaintFilter(clearBits, setBits); } static void android_view_GLES20Canvas_resetPaintFilter(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->resetPaintFilter(); } @@ -658,24 +761,31 @@ static void renderTextRun(OpenGLRenderer* renderer, const jchar* text, } static void android_view_GLES20Canvas_drawTextArray(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jcharArray text, jint index, jint count, - jfloat x, jfloat y, jint flags, SkPaint* paint) { + jlong rendererHandle, jcharArray text, jint index, jint count, + jfloat x, jfloat y, jint flags, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); renderText(renderer, textArray + index, count, x, y, flags, paint); env->ReleaseCharArrayElements(text, textArray, JNI_ABORT); } static void android_view_GLES20Canvas_drawText(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jstring text, jint start, jint end, - jfloat x, jfloat y, jint flags, SkPaint* paint) { + jlong rendererHandle, jstring text, jint start, jint end, + jfloat x, jfloat y, jint flags, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); renderText(renderer, textArray + start, end - start, x, y, flags, paint); env->ReleaseStringChars(text, textArray); } static void android_view_GLES20Canvas_drawTextArrayOnPath(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jcharArray text, jint index, jint count, - SkPath* path, jfloat hOffset, jfloat vOffset, jint flags, SkPaint* paint) { + jlong rendererHandle, jcharArray text, jint index, jint count, + jlong pathHandle, jfloat hOffset, jfloat vOffset, jint flags, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); renderTextOnPath(renderer, textArray + index, count, path, hOffset, vOffset, flags, paint); @@ -683,8 +793,11 @@ static void android_view_GLES20Canvas_drawTextArrayOnPath(JNIEnv* env, jobject c } static void android_view_GLES20Canvas_drawTextOnPath(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jstring text, jint start, jint end, - SkPath* path, jfloat hOffset, jfloat vOffset, jint flags, SkPaint* paint) { + jlong rendererHandle, jstring text, jint start, jint end, + jlong pathHandle, jfloat hOffset, jfloat vOffset, jint flags, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); renderTextOnPath(renderer, textArray + start, end - start, path, hOffset, vOffset, flags, paint); @@ -692,9 +805,11 @@ static void android_view_GLES20Canvas_drawTextOnPath(JNIEnv* env, jobject clazz, } static void android_view_GLES20Canvas_drawTextRunArray(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jcharArray text, jint index, jint count, + jlong rendererHandle, jcharArray text, jint index, jint count, jint contextIndex, jint contextCount, jfloat x, jfloat y, jint dirFlags, - SkPaint* paint) { + jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); renderTextRun(renderer, textArray + contextIndex, index - contextIndex, count, contextCount, x, y, dirFlags, paint); @@ -702,9 +817,11 @@ static void android_view_GLES20Canvas_drawTextRunArray(JNIEnv* env, jobject claz } static void android_view_GLES20Canvas_drawTextRun(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jstring text, jint start, jint end, - jint contextStart, int contextEnd, jfloat x, jfloat y, jint dirFlags, - SkPaint* paint) { + jlong rendererHandle, jstring text, jint start, jint end, + jint contextStart, jint contextEnd, jfloat x, jfloat y, jint dirFlags, + jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jint count = end - start; jint contextCount = contextEnd - contextStart; @@ -729,8 +846,10 @@ static void renderPosText(OpenGLRenderer* renderer, const jchar* text, int count } static void android_view_GLES20Canvas_drawPosTextArray(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jcharArray text, jint index, jint count, - jfloatArray pos, SkPaint* paint) { + jlong rendererHandle, jcharArray text, jint index, jint count, + jfloatArray pos, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); jfloat* positions = env->GetFloatArrayElements(pos, NULL); @@ -741,8 +860,10 @@ static void android_view_GLES20Canvas_drawPosTextArray(JNIEnv* env, jobject claz } static void android_view_GLES20Canvas_drawPosText(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, jstring text, jint start, jint end, - jfloatArray pos, SkPaint* paint) { + jlong rendererHandle, jstring text, jint start, jint end, + jfloatArray pos, jlong paintHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jfloat* positions = env->GetFloatArrayElements(pos, NULL); @@ -756,24 +877,31 @@ static void android_view_GLES20Canvas_drawPosText(JNIEnv* env, jobject clazz, // Display lists // ---------------------------------------------------------------------------- -static DisplayList* android_view_GLES20Canvas_getDisplayList(JNIEnv* env, - jobject clazz, DisplayListRenderer* renderer, DisplayList* displayList) { - return renderer->getDisplayList(displayList); +static jlong android_view_GLES20Canvas_getDisplayList(JNIEnv* env, + jobject clazz, jlong rendererHandle, jlong displayListHandle) { + DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererHandle); + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); + DisplayList* list = renderer->getDisplayList(displayList); + return reinterpret_cast<jlong>(list); } -static OpenGLRenderer* android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env, +static jlong android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env, jobject clazz) { - return new DisplayListRenderer; + OpenGLRenderer* renderer = new DisplayListRenderer; + return reinterpret_cast<jlong>(renderer); } static void android_view_GLES20Canvas_resetDisplayListRenderer(JNIEnv* env, - jobject clazz, DisplayListRenderer* renderer) { + jobject clazz, jlong rendererHandle) { + DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererHandle); renderer->reset(); } static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, DisplayList* displayList, + jobject clazz, jlong rendererHandle, jlong displayListHandle, jobject dirty, jint flags) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); android::uirenderer::Rect bounds; status_t status = renderer->drawDisplayList(displayList, bounds, flags); if (status != DrawGlInfo::kStatusDone && dirty != NULL) { @@ -784,7 +912,9 @@ static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env, } static void android_view_GLES20Canvas_outputDisplayList(JNIEnv* env, - jobject clazz, OpenGLRenderer* renderer, DisplayList* displayList) { + jobject clazz, jlong rendererHandle, jlong displayListHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); renderer->outputDisplayList(displayList); } @@ -793,26 +923,29 @@ static void android_view_GLES20Canvas_outputDisplayList(JNIEnv* env, // ---------------------------------------------------------------------------- static void android_view_GLES20Canvas_interrupt(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->interrupt(); } static void android_view_GLES20Canvas_resume(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->resume(); } -static OpenGLRenderer* android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env, - jobject clazz, Layer* layer) { +static jlong android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env, + jobject clazz, jlong layerHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); if (layer) { OpenGLRenderer* renderer = new LayerRenderer(layer); renderer->initProperties(); - return renderer; + return reinterpret_cast<jlong>(renderer); } return NULL; } -static Layer* android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz, +static jlong android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz, jboolean isOpaque, jintArray layerInfo) { Layer* layer = LayerRenderer::createTextureLayer(isOpaque); @@ -822,10 +955,10 @@ static Layer* android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject env->ReleaseIntArrayElements(layerInfo, storage, 0); } - return layer; + return reinterpret_cast<jlong>(layer); } -static Layer* android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz, +static jlong android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz, jint width, jint height, jboolean isOpaque, jintArray layerInfo) { Layer* layer = LayerRenderer::createLayer(width, height, isOpaque); @@ -836,44 +969,51 @@ static Layer* android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz, env->ReleaseIntArrayElements(layerInfo, storage, 0); } - return layer; + return reinterpret_cast<jlong>(layer); } -static bool android_view_GLES20Canvas_resizeLayer(JNIEnv* env, jobject clazz, - Layer* layer, jint width, jint height, jintArray layerInfo) { +static jboolean android_view_GLES20Canvas_resizeLayer(JNIEnv* env, jobject clazz, + jlong layerHandle, jint width, jint height, jintArray layerInfo) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); if (LayerRenderer::resizeLayer(layer, width, height)) { jint* storage = env->GetIntArrayElements(layerInfo, NULL); storage[0] = layer->getWidth(); storage[1] = layer->getHeight(); env->ReleaseIntArrayElements(layerInfo, storage, 0); - return true; + return JNI_TRUE; } - return false; + return JNI_FALSE; } static void android_view_GLES20Canvas_setLayerPaint(JNIEnv* env, jobject clazz, - Layer* layer, SkPaint* paint) { + jlong layerHandle, jlong paintHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); if (layer) { layer->setPaint(paint); } } static void android_view_GLES20Canvas_setLayerColorFilter(JNIEnv* env, jobject clazz, - Layer* layer, SkiaColorFilter* colorFilter) { + jlong layerHandle, jlong colorFilterHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); + SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterHandle); if (layer) { layer->setColorFilter(colorFilter); } } static void android_view_GLES20Canvas_setOpaqueLayer(JNIEnv* env, jobject clazz, - Layer* layer, jboolean isOpaque) { + jlong layerHandle, jboolean isOpaque) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); if (layer) { layer->setBlend(!isOpaque); } } static void android_view_GLES20Canvas_updateTextureLayer(JNIEnv* env, jobject clazz, - Layer* layer, jint width, jint height, jboolean isOpaque, jobject surface) { + jlong layerHandle, jint width, jint height, jboolean isOpaque, jobject surface) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); float transform[16]; sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, surface)); @@ -903,57 +1043,75 @@ static void android_view_GLES20Canvas_updateTextureLayer(JNIEnv* env, jobject cl } static void android_view_GLES20Canvas_updateRenderLayer(JNIEnv* env, jobject clazz, - Layer* layer, OpenGLRenderer* renderer, DisplayList* displayList, + jlong layerHandle, jlong rendererHandle, jlong displayListHandle, jint left, jint top, jint right, jint bottom) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); layer->updateDeferred(renderer, displayList, left, top, right, bottom); } static void android_view_GLES20Canvas_clearLayerTexture(JNIEnv* env, jobject clazz, - Layer* layer) { + jlong layerHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); layer->clearTexture(); } static void android_view_GLES20Canvas_setTextureLayerTransform(JNIEnv* env, jobject clazz, - Layer* layer, SkMatrix* matrix) { + jlong layerHandle, jlong matrixHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); layer->getTransform().load(*matrix); } -static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, Layer* layer) { +static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, jlong layerHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); LayerRenderer::destroyLayer(layer); } static void android_view_GLES20Canvas_destroyLayerDeferred(JNIEnv* env, - jobject clazz, Layer* layer) { + jobject clazz, jlong layerHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); LayerRenderer::destroyLayerDeferred(layer); } static void android_view_GLES20Canvas_drawLayer(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, Layer* layer, jfloat x, jfloat y) { + jlong rendererHandle, jlong layerHandle, jfloat x, jfloat y) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + Layer* layer = reinterpret_cast<Layer*>(layerHandle); renderer->drawLayer(layer, x, y); } static jboolean android_view_GLES20Canvas_copyLayer(JNIEnv* env, jobject clazz, - Layer* layer, SkBitmap* bitmap) { + jlong layerHandle, jlong bitmapHandle) { + Layer* layer = reinterpret_cast<Layer*>(layerHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); return LayerRenderer::copyLayer(layer, bitmap); } static void android_view_GLES20Canvas_pushLayerUpdate(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, Layer* layer) { + jlong rendererHandle, jlong layerHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + Layer* layer = reinterpret_cast<Layer*>(layerHandle); renderer->pushLayerUpdate(layer); } static void android_view_GLES20Canvas_cancelLayerUpdate(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer, Layer* layer) { + jlong rendererHandle, jlong layerHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); + Layer* layer = reinterpret_cast<Layer*>(layerHandle); renderer->cancelLayerUpdate(layer); } static void android_view_GLES20Canvas_clearLayerUpdates(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->clearLayerUpdates(); } static void android_view_GLES20Canvas_flushLayerUpdates(JNIEnv* env, jobject clazz, - OpenGLRenderer* renderer) { + jlong rendererHandle) { + OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererHandle); renderer->flushLayerUpdates(); } @@ -1008,132 +1166,132 @@ static JNINativeMethod gMethods[] = { { "nInitAtlas", "(Landroid/view/GraphicBuffer;[II)V", (void*) android_view_GLES20Canvas_initAtlas }, - { "nCreateRenderer", "()I", (void*) android_view_GLES20Canvas_createRenderer }, - { "nDestroyRenderer", "(I)V", (void*) android_view_GLES20Canvas_destroyRenderer }, - { "nSetViewport", "(III)V", (void*) android_view_GLES20Canvas_setViewport }, - { "nPrepare", "(IZ)I", (void*) android_view_GLES20Canvas_prepare }, - { "nPrepareDirty", "(IIIIIZ)I", (void*) android_view_GLES20Canvas_prepareDirty }, - { "nFinish", "(I)V", (void*) android_view_GLES20Canvas_finish }, - { "nSetName", "(ILjava/lang/String;)V", + { "nCreateRenderer", "()J", (void*) android_view_GLES20Canvas_createRenderer }, + { "nDestroyRenderer", "(J)V", (void*) android_view_GLES20Canvas_destroyRenderer }, + { "nSetViewport", "(JII)V", (void*) android_view_GLES20Canvas_setViewport }, + { "nPrepare", "(JZ)I", (void*) android_view_GLES20Canvas_prepare }, + { "nPrepareDirty", "(JIIIIZ)I", (void*) android_view_GLES20Canvas_prepareDirty }, + { "nFinish", "(J)V", (void*) android_view_GLES20Canvas_finish }, + { "nSetName", "(JLjava/lang/String;)V", (void*) android_view_GLES20Canvas_setName }, - { "nSetCountOverdrawEnabled", "(IZ)V", (void*) android_view_GLES20Canvas_setCountOverdrawEnabled }, - { "nGetOverdraw", "(I)F", (void*) android_view_GLES20Canvas_getOverdraw }, + { "nSetCountOverdrawEnabled", "(JZ)V", (void*) android_view_GLES20Canvas_setCountOverdrawEnabled }, + { "nGetOverdraw", "(J)F", (void*) android_view_GLES20Canvas_getOverdraw }, { "nGetStencilSize", "()I", (void*) android_view_GLES20Canvas_getStencilSize }, - { "nCallDrawGLFunction", "(II)I", (void*) android_view_GLES20Canvas_callDrawGLFunction }, - { "nDetachFunctor", "(II)V", (void*) android_view_GLES20Canvas_detachFunctor }, - { "nAttachFunctor", "(II)V", (void*) android_view_GLES20Canvas_attachFunctor }, - { "nInvokeFunctors", "(ILandroid/graphics/Rect;)I", + { "nCallDrawGLFunction", "(JJ)I", (void*) android_view_GLES20Canvas_callDrawGLFunction }, + { "nDetachFunctor", "(JJ)V", (void*) android_view_GLES20Canvas_detachFunctor }, + { "nAttachFunctor", "(JJ)V", (void*) android_view_GLES20Canvas_attachFunctor }, + { "nInvokeFunctors", "(JLandroid/graphics/Rect;)I", (void*) android_view_GLES20Canvas_invokeFunctors }, - { "nSave", "(II)I", (void*) android_view_GLES20Canvas_save }, - { "nRestore", "(I)V", (void*) android_view_GLES20Canvas_restore }, - { "nRestoreToCount", "(II)V", (void*) android_view_GLES20Canvas_restoreToCount }, - { "nGetSaveCount", "(I)I", (void*) android_view_GLES20Canvas_getSaveCount }, - - { "nSaveLayer", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayer }, - { "nSaveLayer", "(III)I", (void*) android_view_GLES20Canvas_saveLayerClip }, - { "nSaveLayerAlpha", "(IFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha }, - { "nSaveLayerAlpha", "(III)I", (void*) android_view_GLES20Canvas_saveLayerAlphaClip }, - - { "nQuickReject", "(IFFFF)Z", (void*) android_view_GLES20Canvas_quickReject }, - { "nClipRect", "(IFFFFI)Z", (void*) android_view_GLES20Canvas_clipRectF }, - { "nClipRect", "(IIIIII)Z", (void*) android_view_GLES20Canvas_clipRect }, - { "nClipPath", "(III)Z", (void*) android_view_GLES20Canvas_clipPath }, - { "nClipRegion", "(III)Z", (void*) android_view_GLES20Canvas_clipRegion }, - - { "nTranslate", "(IFF)V", (void*) android_view_GLES20Canvas_translate }, - { "nRotate", "(IF)V", (void*) android_view_GLES20Canvas_rotate }, - { "nScale", "(IFF)V", (void*) android_view_GLES20Canvas_scale }, - { "nSkew", "(IFF)V", (void*) android_view_GLES20Canvas_skew }, - - { "nSetMatrix", "(II)V", (void*) android_view_GLES20Canvas_setMatrix }, - { "nGetMatrix", "(II)V", (void*) android_view_GLES20Canvas_getMatrix }, - { "nConcatMatrix", "(II)V", (void*) android_view_GLES20Canvas_concatMatrix }, - - { "nDrawBitmap", "(II[BFFI)V", (void*) android_view_GLES20Canvas_drawBitmap }, - { "nDrawBitmap", "(II[BFFFFFFFFI)V",(void*) android_view_GLES20Canvas_drawBitmapRect }, - { "nDrawBitmap", "(II[BII)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix }, - { "nDrawBitmap", "(I[IIIFFIIZI)V", (void*) android_view_GLES20Canvas_drawBitmapData }, - - { "nDrawBitmapMesh", "(II[BII[FI[III)V",(void*) android_view_GLES20Canvas_drawBitmapMesh }, - - { "nDrawPatch", "(II[BIFFFFI)V", (void*) android_view_GLES20Canvas_drawPatch }, - - { "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor }, - { "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect }, - { "nDrawRects", "(III)V", (void*) android_view_GLES20Canvas_drawRegionAsRects }, - { "nDrawRects", "(I[FII)V", (void*) android_view_GLES20Canvas_drawRects }, - { "nDrawRoundRect", "(IFFFFFFI)V", (void*) android_view_GLES20Canvas_drawRoundRect }, - { "nDrawCircle", "(IFFFI)V", (void*) android_view_GLES20Canvas_drawCircle }, - { "nDrawOval", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawOval }, - { "nDrawArc", "(IFFFFFFZI)V", (void*) android_view_GLES20Canvas_drawArc }, - { "nDrawPoints", "(I[FIII)V", (void*) android_view_GLES20Canvas_drawPoints }, - - { "nDrawPath", "(III)V", (void*) android_view_GLES20Canvas_drawPath }, - { "nDrawLines", "(I[FIII)V", (void*) android_view_GLES20Canvas_drawLines }, - - { "nResetModifiers", "(II)V", (void*) android_view_GLES20Canvas_resetModifiers }, - { "nSetupShader", "(II)V", (void*) android_view_GLES20Canvas_setupShader }, - { "nSetupColorFilter", "(II)V", (void*) android_view_GLES20Canvas_setupColorFilter }, - { "nSetupShadow", "(IFFFI)V", (void*) android_view_GLES20Canvas_setupShadow }, - - { "nSetupPaintFilter", "(III)V", (void*) android_view_GLES20Canvas_setupPaintFilter }, - { "nResetPaintFilter", "(I)V", (void*) android_view_GLES20Canvas_resetPaintFilter }, - - { "nDrawText", "(I[CIIFFII)V", (void*) android_view_GLES20Canvas_drawTextArray }, - { "nDrawText", "(ILjava/lang/String;IIFFII)V", + { "nSave", "(JI)I", (void*) android_view_GLES20Canvas_save }, + { "nRestore", "(J)V", (void*) android_view_GLES20Canvas_restore }, + { "nRestoreToCount", "(JI)V", (void*) android_view_GLES20Canvas_restoreToCount }, + { "nGetSaveCount", "(J)I", (void*) android_view_GLES20Canvas_getSaveCount }, + + { "nSaveLayer", "(JFFFFJI)I", (void*) android_view_GLES20Canvas_saveLayer }, + { "nSaveLayer", "(JJI)I", (void*) android_view_GLES20Canvas_saveLayerClip }, + { "nSaveLayerAlpha", "(JFFFFII)I", (void*) android_view_GLES20Canvas_saveLayerAlpha }, + { "nSaveLayerAlpha", "(JII)I", (void*) android_view_GLES20Canvas_saveLayerAlphaClip }, + + { "nQuickReject", "(JFFFF)Z", (void*) android_view_GLES20Canvas_quickReject }, + { "nClipRect", "(JFFFFI)Z", (void*) android_view_GLES20Canvas_clipRectF }, + { "nClipRect", "(JIIIII)Z", (void*) android_view_GLES20Canvas_clipRect }, + { "nClipPath", "(JJI)Z", (void*) android_view_GLES20Canvas_clipPath }, + { "nClipRegion", "(JJI)Z", (void*) android_view_GLES20Canvas_clipRegion }, + + { "nTranslate", "(JFF)V", (void*) android_view_GLES20Canvas_translate }, + { "nRotate", "(JF)V", (void*) android_view_GLES20Canvas_rotate }, + { "nScale", "(JFF)V", (void*) android_view_GLES20Canvas_scale }, + { "nSkew", "(JFF)V", (void*) android_view_GLES20Canvas_skew }, + + { "nSetMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_setMatrix }, + { "nGetMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_getMatrix }, + { "nConcatMatrix", "(JJ)V", (void*) android_view_GLES20Canvas_concatMatrix }, + + { "nDrawBitmap", "(JJ[BFFJ)V", (void*) android_view_GLES20Canvas_drawBitmap }, + { "nDrawBitmap", "(JJ[BFFFFFFFFJ)V",(void*) android_view_GLES20Canvas_drawBitmapRect }, + { "nDrawBitmap", "(JJ[BJJ)V", (void*) android_view_GLES20Canvas_drawBitmapMatrix }, + { "nDrawBitmap", "(J[IIIFFIIZJ)V", (void*) android_view_GLES20Canvas_drawBitmapData }, + + { "nDrawBitmapMesh", "(JJ[BII[FI[IIJ)V",(void*) android_view_GLES20Canvas_drawBitmapMesh }, + + { "nDrawPatch", "(JJ[BJFFFFJ)V", (void*) android_view_GLES20Canvas_drawPatch }, + + { "nDrawColor", "(JII)V", (void*) android_view_GLES20Canvas_drawColor }, + { "nDrawRect", "(JFFFFJ)V", (void*) android_view_GLES20Canvas_drawRect }, + { "nDrawRects", "(JJJ)V", (void*) android_view_GLES20Canvas_drawRegionAsRects }, + { "nDrawRects", "(J[FIJ)V", (void*) android_view_GLES20Canvas_drawRects }, + { "nDrawRoundRect", "(JFFFFFFJ)V", (void*) android_view_GLES20Canvas_drawRoundRect }, + { "nDrawCircle", "(JFFFJ)V", (void*) android_view_GLES20Canvas_drawCircle }, + { "nDrawOval", "(JFFFFJ)V", (void*) android_view_GLES20Canvas_drawOval }, + { "nDrawArc", "(JFFFFFFZJ)V", (void*) android_view_GLES20Canvas_drawArc }, + { "nDrawPoints", "(J[FIIJ)V", (void*) android_view_GLES20Canvas_drawPoints }, + + { "nDrawPath", "(JJJ)V", (void*) android_view_GLES20Canvas_drawPath }, + { "nDrawLines", "(J[FIIJ)V", (void*) android_view_GLES20Canvas_drawLines }, + + { "nResetModifiers", "(JI)V", (void*) android_view_GLES20Canvas_resetModifiers }, + { "nSetupShader", "(JJ)V", (void*) android_view_GLES20Canvas_setupShader }, + { "nSetupColorFilter", "(JJ)V", (void*) android_view_GLES20Canvas_setupColorFilter }, + { "nSetupShadow", "(JFFFI)V", (void*) android_view_GLES20Canvas_setupShadow }, + + { "nSetupPaintFilter", "(JII)V", (void*) android_view_GLES20Canvas_setupPaintFilter }, + { "nResetPaintFilter", "(J)V", (void*) android_view_GLES20Canvas_resetPaintFilter }, + + { "nDrawText", "(J[CIIFFIJ)V", (void*) android_view_GLES20Canvas_drawTextArray }, + { "nDrawText", "(JLjava/lang/String;IIFFIJ)V", (void*) android_view_GLES20Canvas_drawText }, - { "nDrawTextOnPath", "(I[CIIIFFII)V", (void*) android_view_GLES20Canvas_drawTextArrayOnPath }, - { "nDrawTextOnPath", "(ILjava/lang/String;IIIFFII)V", + { "nDrawTextOnPath", "(J[CIIJFFIJ)V", (void*) android_view_GLES20Canvas_drawTextArrayOnPath }, + { "nDrawTextOnPath", "(JLjava/lang/String;IIJFFIJ)V", (void*) android_view_GLES20Canvas_drawTextOnPath }, - { "nDrawTextRun", "(I[CIIIIFFII)V", (void*) android_view_GLES20Canvas_drawTextRunArray }, - { "nDrawTextRun", "(ILjava/lang/String;IIIIFFII)V", + { "nDrawTextRun", "(J[CIIIIFFIJ)V", (void*) android_view_GLES20Canvas_drawTextRunArray }, + { "nDrawTextRun", "(JLjava/lang/String;IIIIFFIJ)V", (void*) android_view_GLES20Canvas_drawTextRun }, - { "nDrawPosText", "(I[CII[FI)V", (void*) android_view_GLES20Canvas_drawPosTextArray }, - { "nDrawPosText", "(ILjava/lang/String;II[FI)V", + { "nDrawPosText", "(J[CII[FJ)V", (void*) android_view_GLES20Canvas_drawPosTextArray }, + { "nDrawPosText", "(JLjava/lang/String;II[FJ)V", (void*) android_view_GLES20Canvas_drawPosText }, - { "nGetClipBounds", "(ILandroid/graphics/Rect;)Z", + { "nGetClipBounds", "(JLandroid/graphics/Rect;)Z", (void*) android_view_GLES20Canvas_getClipBounds }, - { "nGetDisplayList", "(II)I", (void*) android_view_GLES20Canvas_getDisplayList }, - { "nOutputDisplayList", "(II)V", (void*) android_view_GLES20Canvas_outputDisplayList }, - { "nDrawDisplayList", "(IILandroid/graphics/Rect;I)I", + { "nGetDisplayList", "(JJ)J", (void*) android_view_GLES20Canvas_getDisplayList }, + { "nOutputDisplayList", "(JJ)V", (void*) android_view_GLES20Canvas_outputDisplayList }, + { "nDrawDisplayList", "(JJLandroid/graphics/Rect;I)I", (void*) android_view_GLES20Canvas_drawDisplayList }, - { "nCreateDisplayListRenderer", "()I", (void*) android_view_GLES20Canvas_createDisplayListRenderer }, - { "nResetDisplayListRenderer", "(I)V", (void*) android_view_GLES20Canvas_resetDisplayListRenderer }, + { "nCreateDisplayListRenderer", "()J", (void*) android_view_GLES20Canvas_createDisplayListRenderer }, + { "nResetDisplayListRenderer", "(J)V", (void*) android_view_GLES20Canvas_resetDisplayListRenderer }, - { "nInterrupt", "(I)V", (void*) android_view_GLES20Canvas_interrupt }, - { "nResume", "(I)V", (void*) android_view_GLES20Canvas_resume }, + { "nInterrupt", "(J)V", (void*) android_view_GLES20Canvas_interrupt }, + { "nResume", "(J)V", (void*) android_view_GLES20Canvas_resume }, - { "nCreateLayerRenderer", "(I)I", (void*) android_view_GLES20Canvas_createLayerRenderer }, - { "nCreateLayer", "(IIZ[I)I", (void*) android_view_GLES20Canvas_createLayer }, - { "nResizeLayer", "(III[I)Z" , (void*) android_view_GLES20Canvas_resizeLayer }, - { "nSetLayerPaint", "(II)V", (void*) android_view_GLES20Canvas_setLayerPaint }, - { "nSetLayerColorFilter", "(II)V", (void*) android_view_GLES20Canvas_setLayerColorFilter }, - { "nSetOpaqueLayer", "(IZ)V", (void*) android_view_GLES20Canvas_setOpaqueLayer }, - { "nCreateTextureLayer", "(Z[I)I", (void*) android_view_GLES20Canvas_createTextureLayer }, - { "nUpdateTextureLayer", "(IIIZLandroid/graphics/SurfaceTexture;)V", + { "nCreateLayerRenderer", "(J)J", (void*) android_view_GLES20Canvas_createLayerRenderer }, + { "nCreateLayer", "(IIZ[I)J", (void*) android_view_GLES20Canvas_createLayer }, + { "nResizeLayer", "(JII[I)Z" , (void*) android_view_GLES20Canvas_resizeLayer }, + { "nSetLayerPaint", "(JJ)V", (void*) android_view_GLES20Canvas_setLayerPaint }, + { "nSetLayerColorFilter", "(JJ)V", (void*) android_view_GLES20Canvas_setLayerColorFilter }, + { "nSetOpaqueLayer", "(JZ)V", (void*) android_view_GLES20Canvas_setOpaqueLayer }, + { "nCreateTextureLayer", "(Z[I)J", (void*) android_view_GLES20Canvas_createTextureLayer }, + { "nUpdateTextureLayer", "(JIIZLandroid/graphics/SurfaceTexture;)V", (void*) android_view_GLES20Canvas_updateTextureLayer }, - { "nUpdateRenderLayer", "(IIIIIII)V", (void*) android_view_GLES20Canvas_updateRenderLayer }, - { "nClearLayerTexture", "(I)V", (void*) android_view_GLES20Canvas_clearLayerTexture }, - { "nDestroyLayer", "(I)V", (void*) android_view_GLES20Canvas_destroyLayer }, - { "nDestroyLayerDeferred", "(I)V", (void*) android_view_GLES20Canvas_destroyLayerDeferred }, - { "nDrawLayer", "(IIFF)V", (void*) android_view_GLES20Canvas_drawLayer }, - { "nCopyLayer", "(II)Z", (void*) android_view_GLES20Canvas_copyLayer }, - { "nClearLayerUpdates", "(I)V", (void*) android_view_GLES20Canvas_clearLayerUpdates }, - { "nFlushLayerUpdates", "(I)V", (void*) android_view_GLES20Canvas_flushLayerUpdates }, - { "nPushLayerUpdate", "(II)V", (void*) android_view_GLES20Canvas_pushLayerUpdate }, - { "nCancelLayerUpdate", "(II)V", (void*) android_view_GLES20Canvas_cancelLayerUpdate }, - - { "nSetTextureLayerTransform", "(II)V", (void*) android_view_GLES20Canvas_setTextureLayerTransform }, + { "nUpdateRenderLayer", "(JJJIIII)V", (void*) android_view_GLES20Canvas_updateRenderLayer }, + { "nClearLayerTexture", "(J)V", (void*) android_view_GLES20Canvas_clearLayerTexture }, + { "nDestroyLayer", "(J)V", (void*) android_view_GLES20Canvas_destroyLayer }, + { "nDestroyLayerDeferred", "(J)V", (void*) android_view_GLES20Canvas_destroyLayerDeferred }, + { "nDrawLayer", "(JJFF)V", (void*) android_view_GLES20Canvas_drawLayer }, + { "nCopyLayer", "(JJ)Z", (void*) android_view_GLES20Canvas_copyLayer }, + { "nClearLayerUpdates", "(J)V", (void*) android_view_GLES20Canvas_clearLayerUpdates }, + { "nFlushLayerUpdates", "(J)V", (void*) android_view_GLES20Canvas_flushLayerUpdates }, + { "nPushLayerUpdate", "(JJ)V", (void*) android_view_GLES20Canvas_pushLayerUpdate }, + { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_GLES20Canvas_cancelLayerUpdate }, + + { "nSetTextureLayerTransform", "(JJ)V", (void*) android_view_GLES20Canvas_setTextureLayerTransform }, { "nGetMaximumTextureWidth", "()I", (void*) android_view_GLES20Canvas_getMaxTextureWidth }, { "nGetMaximumTextureHeight", "()I", (void*) android_view_GLES20Canvas_getMaxTextureHeight }, diff --git a/core/jni/android_view_GLES20DisplayList.cpp b/core/jni/android_view_GLES20DisplayList.cpp index 4ce2e24..8e19efd 100644 --- a/core/jni/android_view_GLES20DisplayList.cpp +++ b/core/jni/android_view_GLES20DisplayList.cpp @@ -42,17 +42,20 @@ using namespace uirenderer; // ---------------------------------------------------------------------------- static void android_view_GLES20DisplayList_reset(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->reset(); } static jint android_view_GLES20DisplayList_getDisplayListSize(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getSize(); } static void android_view_GLES20DisplayList_setDisplayListName(JNIEnv* env, - jobject clazz, DisplayList* displayList, jstring name) { + jobject clazz, jlong displayListHandle, jstring name) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); if (name != NULL) { const char* textArray = env->GetStringUTFChars(name, NULL); displayList->setName(textArray); @@ -61,7 +64,8 @@ static void android_view_GLES20DisplayList_setDisplayListName(JNIEnv* env, } static void android_view_GLES20DisplayList_destroyDisplayList(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); DisplayList::destroyDisplayListDeferred(displayList); } @@ -70,74 +74,91 @@ static void android_view_GLES20DisplayList_destroyDisplayList(JNIEnv* env, // ---------------------------------------------------------------------------- static void android_view_GLES20DisplayList_setCaching(JNIEnv* env, - jobject clazz, DisplayList* displayList, jboolean caching) { + jobject clazz, jlong displayListHandle, jboolean caching) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setCaching(caching); } +//serban static void android_view_GLES20DisplayList_setStaticMatrix(JNIEnv* env, - jobject clazz, DisplayList* displayList, SkMatrix* matrix) { + jobject clazz, jlong displayListHandle, jlong matrixHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); displayList->setStaticMatrix(matrix); } static void android_view_GLES20DisplayList_setAnimationMatrix(JNIEnv* env, - jobject clazz, DisplayList* displayList, SkMatrix* matrix) { + jobject clazz, jlong displayListHandle, jlong matrixHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); displayList->setAnimationMatrix(matrix); } static void android_view_GLES20DisplayList_setClipToBounds(JNIEnv* env, - jobject clazz, DisplayList* displayList, jboolean clipToBounds) { + jobject clazz, jlong displayListHandle, jboolean clipToBounds) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setClipToBounds(clipToBounds); } static void android_view_GLES20DisplayList_setAlpha(JNIEnv* env, - jobject clazz, DisplayList* displayList, float alpha) { + jobject clazz, jlong displayListHandle, jfloat alpha) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setAlpha(alpha); } static void android_view_GLES20DisplayList_setHasOverlappingRendering(JNIEnv* env, - jobject clazz, DisplayList* displayList, bool hasOverlappingRendering) { + jobject clazz, jlong displayListHandle, jboolean hasOverlappingRendering) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setHasOverlappingRendering(hasOverlappingRendering); } static void android_view_GLES20DisplayList_setTranslationX(JNIEnv* env, - jobject clazz, DisplayList* displayList, float tx) { + jobject clazz, jlong displayListHandle, jfloat tx) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setTranslationX(tx); } static void android_view_GLES20DisplayList_setTranslationY(JNIEnv* env, - jobject clazz, DisplayList* displayList, float ty) { + jobject clazz, jlong displayListHandle, jfloat ty) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setTranslationY(ty); } static void android_view_GLES20DisplayList_setRotation(JNIEnv* env, - jobject clazz, DisplayList* displayList, float rotation) { + jobject clazz, jlong displayListHandle, jfloat rotation) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setRotation(rotation); } static void android_view_GLES20DisplayList_setRotationX(JNIEnv* env, - jobject clazz, DisplayList* displayList, float rx) { + jobject clazz, jlong displayListHandle, jfloat rx) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setRotationX(rx); } static void android_view_GLES20DisplayList_setRotationY(JNIEnv* env, - jobject clazz, DisplayList* displayList, float ry) { + jobject clazz, jlong displayListHandle, jfloat ry) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setRotationY(ry); } static void android_view_GLES20DisplayList_setScaleX(JNIEnv* env, - jobject clazz, DisplayList* displayList, float sx) { + jobject clazz, jlong displayListHandle, jfloat sx) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setScaleX(sx); } static void android_view_GLES20DisplayList_setScaleY(JNIEnv* env, - jobject clazz, DisplayList* displayList, float sy) { + jobject clazz, jlong displayListHandle, jfloat sy) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setScaleY(sy); } static void android_view_GLES20DisplayList_setTransformationInfo(JNIEnv* env, - jobject clazz, DisplayList* displayList, float alpha, - float translationX, float translationY, float rotation, float rotationX, float rotationY, - float scaleX, float scaleY) { + jobject clazz, jlong displayListHandle, jfloat alpha, + jfloat translationX, jfloat translationY, jfloat rotation, jfloat rotationX, jfloat rotationY, + jfloat scaleX, jfloat scaleY) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setAlpha(alpha); displayList->setTranslationX(translationX); displayList->setTranslationY(translationY); @@ -149,58 +170,70 @@ static void android_view_GLES20DisplayList_setTransformationInfo(JNIEnv* env, } static void android_view_GLES20DisplayList_setPivotX(JNIEnv* env, - jobject clazz, DisplayList* displayList, float px) { + jobject clazz, jlong displayListHandle, jfloat px) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setPivotX(px); } static void android_view_GLES20DisplayList_setPivotY(JNIEnv* env, - jobject clazz, DisplayList* displayList, float py) { + jobject clazz, jlong displayListHandle, jfloat py) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setPivotY(py); } static void android_view_GLES20DisplayList_setCameraDistance(JNIEnv* env, - jobject clazz, DisplayList* displayList, float distance) { + jobject clazz, jlong displayListHandle, jfloat distance) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setCameraDistance(distance); } static void android_view_GLES20DisplayList_setLeft(JNIEnv* env, - jobject clazz, DisplayList* displayList, int left) { + jobject clazz, jlong displayListHandle, jint left) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setLeft(left); } static void android_view_GLES20DisplayList_setTop(JNIEnv* env, - jobject clazz, DisplayList* displayList, int top) { + jobject clazz, jlong displayListHandle, jint top) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setTop(top); } static void android_view_GLES20DisplayList_setRight(JNIEnv* env, - jobject clazz, DisplayList* displayList, int right) { + jobject clazz, jlong displayListHandle, jint right) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setRight(right); } static void android_view_GLES20DisplayList_setBottom(JNIEnv* env, - jobject clazz, DisplayList* displayList, int bottom) { + jobject clazz, jlong displayListHandle, jint bottom) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setBottom(bottom); } static void android_view_GLES20DisplayList_setLeftTopRightBottom(JNIEnv* env, - jobject clazz, DisplayList* displayList, int left, int top, + jobject clazz, jlong displayListHandle, jint left, jint top, int right, int bottom) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->setLeftTopRightBottom(left, top, right, bottom); } static void android_view_GLES20DisplayList_offsetLeftAndRight(JNIEnv* env, - jobject clazz, DisplayList* displayList, float offset) { + jobject clazz, jlong displayListHandle, jfloat offset) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->offsetLeftRight(offset); } static void android_view_GLES20DisplayList_offsetTopAndBottom(JNIEnv* env, - jobject clazz, DisplayList* displayList, float offset) { + jobject clazz, jlong displayListHandle, jfloat offset) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); displayList->offsetTopBottom(offset); } static void android_view_GLES20DisplayList_getMatrix(JNIEnv* env, - jobject clazz, DisplayList* displayList, SkMatrix* matrix) { + jobject clazz, jlong displayListHandle, jlong matrixHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkMatrix* source = displayList->getStaticMatrix(); if (source) { matrix->setConcat(SkMatrix::I(), *source); @@ -210,82 +243,98 @@ static void android_view_GLES20DisplayList_getMatrix(JNIEnv* env, } static jboolean android_view_GLES20DisplayList_hasOverlappingRendering(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->hasOverlappingRendering(); } static jfloat android_view_GLES20DisplayList_getAlpha(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getAlpha(); } static jfloat android_view_GLES20DisplayList_getLeft(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getLeft(); } static jfloat android_view_GLES20DisplayList_getTop(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getTop(); } static jfloat android_view_GLES20DisplayList_getRight(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getRight(); } static jfloat android_view_GLES20DisplayList_getBottom(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getBottom(); } static jfloat android_view_GLES20DisplayList_getCameraDistance(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getCameraDistance(); } static jfloat android_view_GLES20DisplayList_getScaleX(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getScaleX(); } static jfloat android_view_GLES20DisplayList_getScaleY(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getScaleY(); } static jfloat android_view_GLES20DisplayList_getTranslationX(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getTranslationX(); } static jfloat android_view_GLES20DisplayList_getTranslationY(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getTranslationY(); } static jfloat android_view_GLES20DisplayList_getRotation(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getRotation(); } static jfloat android_view_GLES20DisplayList_getRotationX(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getRotationX(); } static jfloat android_view_GLES20DisplayList_getRotationY(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getRotationY(); } static jfloat android_view_GLES20DisplayList_getPivotX(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getPivotX(); } static jfloat android_view_GLES20DisplayList_getPivotY(JNIEnv* env, - jobject clazz, DisplayList* displayList) { + jobject clazz, jlong displayListHandle) { + DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListHandle); return displayList->getPivotY(); } @@ -299,58 +348,58 @@ const char* const kClassPathName = "android/view/GLES20DisplayList"; static JNINativeMethod gMethods[] = { #ifdef USE_OPENGL_RENDERER - { "nDestroyDisplayList", "(I)V", (void*) android_view_GLES20DisplayList_destroyDisplayList }, - { "nGetDisplayListSize", "(I)I", (void*) android_view_GLES20DisplayList_getDisplayListSize }, - { "nSetDisplayListName", "(ILjava/lang/String;)V", + { "nDestroyDisplayList", "(J)V", (void*) android_view_GLES20DisplayList_destroyDisplayList }, + { "nGetDisplayListSize", "(J)I", (void*) android_view_GLES20DisplayList_getDisplayListSize }, + { "nSetDisplayListName", "(JLjava/lang/String;)V", (void*) android_view_GLES20DisplayList_setDisplayListName }, - { "nReset", "(I)V", (void*) android_view_GLES20DisplayList_reset }, - { "nSetCaching", "(IZ)V", (void*) android_view_GLES20DisplayList_setCaching }, - { "nSetStaticMatrix", "(II)V", (void*) android_view_GLES20DisplayList_setStaticMatrix }, - { "nSetAnimationMatrix", "(II)V", (void*) android_view_GLES20DisplayList_setAnimationMatrix }, - { "nSetClipToBounds", "(IZ)V", (void*) android_view_GLES20DisplayList_setClipToBounds }, - { "nSetAlpha", "(IF)V", (void*) android_view_GLES20DisplayList_setAlpha }, - { "nSetHasOverlappingRendering", "(IZ)V", + { "nReset", "(J)V", (void*) android_view_GLES20DisplayList_reset }, + { "nSetCaching", "(JZ)V", (void*) android_view_GLES20DisplayList_setCaching }, + { "nSetStaticMatrix", "(JJ)V", (void*) android_view_GLES20DisplayList_setStaticMatrix }, + { "nSetAnimationMatrix", "(JJ)V", (void*) android_view_GLES20DisplayList_setAnimationMatrix }, + { "nSetClipToBounds", "(JZ)V", (void*) android_view_GLES20DisplayList_setClipToBounds }, + { "nSetAlpha", "(JF)V", (void*) android_view_GLES20DisplayList_setAlpha }, + { "nSetHasOverlappingRendering", "(JZ)V", (void*) android_view_GLES20DisplayList_setHasOverlappingRendering }, - { "nSetTranslationX", "(IF)V", (void*) android_view_GLES20DisplayList_setTranslationX }, - { "nSetTranslationY", "(IF)V", (void*) android_view_GLES20DisplayList_setTranslationY }, - { "nSetRotation", "(IF)V", (void*) android_view_GLES20DisplayList_setRotation }, - { "nSetRotationX", "(IF)V", (void*) android_view_GLES20DisplayList_setRotationX }, - { "nSetRotationY", "(IF)V", (void*) android_view_GLES20DisplayList_setRotationY }, - { "nSetScaleX", "(IF)V", (void*) android_view_GLES20DisplayList_setScaleX }, - { "nSetScaleY", "(IF)V", (void*) android_view_GLES20DisplayList_setScaleY }, - { "nSetTransformationInfo","(IFFFFFFFF)V", + { "nSetTranslationX", "(JF)V", (void*) android_view_GLES20DisplayList_setTranslationX }, + { "nSetTranslationY", "(JF)V", (void*) android_view_GLES20DisplayList_setTranslationY }, + { "nSetRotation", "(JF)V", (void*) android_view_GLES20DisplayList_setRotation }, + { "nSetRotationX", "(JF)V", (void*) android_view_GLES20DisplayList_setRotationX }, + { "nSetRotationY", "(JF)V", (void*) android_view_GLES20DisplayList_setRotationY }, + { "nSetScaleX", "(JF)V", (void*) android_view_GLES20DisplayList_setScaleX }, + { "nSetScaleY", "(JF)V", (void*) android_view_GLES20DisplayList_setScaleY }, + { "nSetTransformationInfo","(JFFFFFFFF)V", (void*) android_view_GLES20DisplayList_setTransformationInfo }, - { "nSetPivotX", "(IF)V", (void*) android_view_GLES20DisplayList_setPivotX }, - { "nSetPivotY", "(IF)V", (void*) android_view_GLES20DisplayList_setPivotY }, - { "nSetCameraDistance", "(IF)V", (void*) android_view_GLES20DisplayList_setCameraDistance }, - { "nSetLeft", "(II)V", (void*) android_view_GLES20DisplayList_setLeft }, - { "nSetTop", "(II)V", (void*) android_view_GLES20DisplayList_setTop }, - { "nSetRight", "(II)V", (void*) android_view_GLES20DisplayList_setRight }, - { "nSetBottom", "(II)V", (void*) android_view_GLES20DisplayList_setBottom }, - { "nSetLeftTopRightBottom","(IIIII)V", + { "nSetPivotX", "(JF)V", (void*) android_view_GLES20DisplayList_setPivotX }, + { "nSetPivotY", "(JF)V", (void*) android_view_GLES20DisplayList_setPivotY }, + { "nSetCameraDistance", "(JF)V", (void*) android_view_GLES20DisplayList_setCameraDistance }, + { "nSetLeft", "(JI)V", (void*) android_view_GLES20DisplayList_setLeft }, + { "nSetTop", "(JI)V", (void*) android_view_GLES20DisplayList_setTop }, + { "nSetRight", "(JI)V", (void*) android_view_GLES20DisplayList_setRight }, + { "nSetBottom", "(JI)V", (void*) android_view_GLES20DisplayList_setBottom }, + { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_GLES20DisplayList_setLeftTopRightBottom }, - { "nOffsetLeftAndRight", "(IF)V", (void*) android_view_GLES20DisplayList_offsetLeftAndRight }, - { "nOffsetTopAndBottom", "(IF)V", (void*) android_view_GLES20DisplayList_offsetTopAndBottom }, - - - { "nGetMatrix", "(II)V", (void*) android_view_GLES20DisplayList_getMatrix }, - { "nHasOverlappingRendering", "(I)Z", (void*) android_view_GLES20DisplayList_hasOverlappingRendering }, - { "nGetAlpha", "(I)F", (void*) android_view_GLES20DisplayList_getAlpha }, - { "nGetLeft", "(I)F", (void*) android_view_GLES20DisplayList_getLeft }, - { "nGetTop", "(I)F", (void*) android_view_GLES20DisplayList_getTop }, - { "nGetRight", "(I)F", (void*) android_view_GLES20DisplayList_getRight }, - { "nGetBottom", "(I)F", (void*) android_view_GLES20DisplayList_getBottom }, - { "nGetCameraDistance", "(I)F", (void*) android_view_GLES20DisplayList_getCameraDistance }, - { "nGetScaleX", "(I)F", (void*) android_view_GLES20DisplayList_getScaleX }, - { "nGetScaleY", "(I)F", (void*) android_view_GLES20DisplayList_getScaleY }, - { "nGetTranslationX", "(I)F", (void*) android_view_GLES20DisplayList_getTranslationX }, - { "nGetTranslationY", "(I)F", (void*) android_view_GLES20DisplayList_getTranslationY }, - { "nGetRotation", "(I)F", (void*) android_view_GLES20DisplayList_getRotation }, - { "nGetRotationX", "(I)F", (void*) android_view_GLES20DisplayList_getRotationX }, - { "nGetRotationY", "(I)F", (void*) android_view_GLES20DisplayList_getRotationY }, - { "nGetPivotX", "(I)F", (void*) android_view_GLES20DisplayList_getPivotX }, - { "nGetPivotY", "(I)F", (void*) android_view_GLES20DisplayList_getPivotY }, + { "nOffsetLeftAndRight", "(JF)V", (void*) android_view_GLES20DisplayList_offsetLeftAndRight }, + { "nOffsetTopAndBottom", "(JF)V", (void*) android_view_GLES20DisplayList_offsetTopAndBottom }, + + + { "nGetMatrix", "(JJ)V", (void*) android_view_GLES20DisplayList_getMatrix }, + { "nHasOverlappingRendering", "(J)Z", (void*) android_view_GLES20DisplayList_hasOverlappingRendering }, + { "nGetAlpha", "(J)F", (void*) android_view_GLES20DisplayList_getAlpha }, + { "nGetLeft", "(J)F", (void*) android_view_GLES20DisplayList_getLeft }, + { "nGetTop", "(J)F", (void*) android_view_GLES20DisplayList_getTop }, + { "nGetRight", "(J)F", (void*) android_view_GLES20DisplayList_getRight }, + { "nGetBottom", "(J)F", (void*) android_view_GLES20DisplayList_getBottom }, + { "nGetCameraDistance", "(J)F", (void*) android_view_GLES20DisplayList_getCameraDistance }, + { "nGetScaleX", "(J)F", (void*) android_view_GLES20DisplayList_getScaleX }, + { "nGetScaleY", "(J)F", (void*) android_view_GLES20DisplayList_getScaleY }, + { "nGetTranslationX", "(J)F", (void*) android_view_GLES20DisplayList_getTranslationX }, + { "nGetTranslationY", "(J)F", (void*) android_view_GLES20DisplayList_getTranslationY }, + { "nGetRotation", "(J)F", (void*) android_view_GLES20DisplayList_getRotation }, + { "nGetRotationX", "(J)F", (void*) android_view_GLES20DisplayList_getRotationX }, + { "nGetRotationY", "(J)F", (void*) android_view_GLES20DisplayList_getRotationY }, + { "nGetPivotX", "(J)F", (void*) android_view_GLES20DisplayList_getPivotX }, + { "nGetPivotY", "(J)F", (void*) android_view_GLES20DisplayList_getPivotY }, #endif }; diff --git a/core/jni/android_view_GraphicBuffer.cpp b/core/jni/android_view_GraphicBuffer.cpp index d68c0b2..2e8dccf 100644 --- a/core/jni/android_view_GraphicBuffer.cpp +++ b/core/jni/android_view_GraphicBuffer.cpp @@ -89,6 +89,12 @@ static struct { #define SET_INT(object, field, value) \ env->SetIntField(object, field, value) +#define GET_LONG(object, field) \ + env->GetLongField(object, field) + +#define SET_LONG(object, field, value) \ + env->SetLongField(object, field, value) + #define INVOKEV(object, method, ...) \ env->CallVoidMethod(object, method, __VA_ARGS__) @@ -108,7 +114,7 @@ public: // GraphicBuffer lifecycle // ---------------------------------------------------------------------------- -static GraphicBufferWrapper* android_view_GraphiceBuffer_create(JNIEnv* env, jobject clazz, +static jlong android_view_GraphiceBuffer_create(JNIEnv* env, jobject clazz, jint width, jint height, jint format, jint usage) { sp<ISurfaceComposer> composer(ComposerService::getComposerService()); @@ -125,11 +131,14 @@ static GraphicBufferWrapper* android_view_GraphiceBuffer_create(JNIEnv* env, job return NULL; } - return new GraphicBufferWrapper(buffer); + GraphicBufferWrapper* wrapper = new GraphicBufferWrapper(buffer); + return reinterpret_cast<jlong>(wrapper); } static void android_view_GraphiceBuffer_destroy(JNIEnv* env, jobject clazz, - GraphicBufferWrapper* wrapper) { + jlong wrapperHandle) { + GraphicBufferWrapper* wrapper = + reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle); delete wrapper; } @@ -140,9 +149,9 @@ static void android_view_GraphiceBuffer_destroy(JNIEnv* env, jobject clazz, static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) { jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer); SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>( - GET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas)); - SET_INT(canvasObj, gCanvasClassInfo.mNativeCanvas, (int) newCanvas); - SET_INT(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int) newCanvas); + GET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas)); + SET_LONG(canvasObj, gCanvasClassInfo.mNativeCanvas, (long) newCanvas); + SET_LONG(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (long) newCanvas); SkSafeUnref(previousCanvas); } @@ -160,10 +169,12 @@ static inline SkBitmap::Config convertPixelFormat(int32_t format) { } static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject, - GraphicBufferWrapper* wrapper, jobject canvas, jobject dirtyRect) { + jlong wrapperHandle, jobject canvas, jobject dirtyRect) { + GraphicBufferWrapper* wrapper = + reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle); if (!wrapper) { - return false; + return JNI_FALSE; } sp<GraphicBuffer> buffer(wrapper->buffer); @@ -181,10 +192,10 @@ static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject, void* bits = NULL; status_t status = buffer->lock(LOCK_CANVAS_USAGE, rect, &bits); - if (status) return false; + if (status) return JNI_FALSE; if (!bits) { buffer->unlock(); - return false; + return JNI_FALSE; } ssize_t bytesCount = buffer->getStride() * bytesPerPixel(buffer->getPixelFormat()); @@ -213,21 +224,23 @@ static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject, int(rect.left), int(rect.top), int(rect.right), int(rect.bottom)); } - return true; + return JNI_TRUE; } static jboolean android_view_GraphicBuffer_unlockCanvasAndPost(JNIEnv* env, jobject, - GraphicBufferWrapper* wrapper, jobject canvas) { + jlong wrapperHandle, jobject canvas) { + GraphicBufferWrapper* wrapper = + reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle); SkCanvas* nativeCanvas = SkNEW(SkCanvas); swapCanvasPtr(env, canvas, nativeCanvas); if (wrapper) { status_t status = wrapper->buffer->unlock(); - return status == 0; + return status == 0 ? JNI_TRUE : JNI_FALSE; } - return false; + return JNI_FALSE; } // ---------------------------------------------------------------------------- @@ -235,21 +248,23 @@ static jboolean android_view_GraphicBuffer_unlockCanvasAndPost(JNIEnv* env, jobj // ---------------------------------------------------------------------------- static void android_view_GraphiceBuffer_write(JNIEnv* env, jobject clazz, - GraphicBufferWrapper* wrapper, jobject dest) { + jlong wrapperHandle, jobject dest) { + GraphicBufferWrapper* wrapper = + reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle); Parcel* parcel = parcelForJavaObject(env, dest); if (parcel) { parcel->write(*wrapper->buffer); } } -static GraphicBufferWrapper* android_view_GraphiceBuffer_read(JNIEnv* env, jobject clazz, +static jlong android_view_GraphiceBuffer_read(JNIEnv* env, jobject clazz, jobject in) { Parcel* parcel = parcelForJavaObject(env, in); if (parcel) { sp<GraphicBuffer> buffer = new GraphicBuffer(); parcel->read(*buffer); - return new GraphicBufferWrapper(buffer); + return reinterpret_cast<jlong>(new GraphicBufferWrapper(buffer)); } return NULL; @@ -261,7 +276,7 @@ static GraphicBufferWrapper* android_view_GraphiceBuffer_read(JNIEnv* env, jobje sp<GraphicBuffer> graphicBufferForJavaObject(JNIEnv* env, jobject obj) { if (obj) { - jint nativeObject = env->GetIntField(obj, gGraphicBufferClassInfo.mNativeObject); + jlong nativeObject = env->GetLongField(obj, gGraphicBufferClassInfo.mNativeObject); GraphicBufferWrapper* wrapper = (GraphicBufferWrapper*) nativeObject; if (wrapper != NULL) { sp<GraphicBuffer> buffer(wrapper->buffer); @@ -290,24 +305,24 @@ sp<GraphicBuffer> graphicBufferForJavaObject(JNIEnv* env, jobject obj) { const char* const kClassPathName = "android/view/GraphicBuffer"; static JNINativeMethod gMethods[] = { - { "nCreateGraphicBuffer", "(IIII)I", (void*) android_view_GraphiceBuffer_create }, - { "nDestroyGraphicBuffer", "(I)V", (void*) android_view_GraphiceBuffer_destroy }, + { "nCreateGraphicBuffer", "(IIII)J", (void*) android_view_GraphiceBuffer_create }, + { "nDestroyGraphicBuffer", "(J)V", (void*) android_view_GraphiceBuffer_destroy }, - { "nWriteGraphicBufferToParcel", "(ILandroid/os/Parcel;)V", + { "nWriteGraphicBufferToParcel", "(JLandroid/os/Parcel;)V", (void*) android_view_GraphiceBuffer_write }, - { "nReadGraphicBufferFromParcel", "(Landroid/os/Parcel;)I", + { "nReadGraphicBufferFromParcel", "(Landroid/os/Parcel;)J", (void*) android_view_GraphiceBuffer_read }, - { "nLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)Z", + { "nLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)Z", (void*) android_view_GraphicBuffer_lockCanvas }, - { "nUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)Z", + { "nUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)Z", (void*) android_view_GraphicBuffer_unlockCanvasAndPost }, }; int register_android_view_GraphicBuffer(JNIEnv* env) { jclass clazz; FIND_CLASS(clazz, "android/view/GraphicBuffer"); - GET_FIELD_ID(gGraphicBufferClassInfo.mNativeObject, clazz, "mNativeObject", "I"); + GET_FIELD_ID(gGraphicBufferClassInfo.mNativeObject, clazz, "mNativeObject", "J"); FIND_CLASS(clazz, "android/graphics/Rect"); GET_METHOD_ID(gRectClassInfo.set, clazz, "set", "(IIII)V"); @@ -319,11 +334,11 @@ int register_android_view_GraphicBuffer(JNIEnv* env) { FIND_CLASS(clazz, "android/graphics/Canvas"); GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;"); - GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I"); + GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J"); GET_FIELD_ID(gCanvasClassInfo.mSurfaceFormat, clazz, "mSurfaceFormat", "I"); FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer"); - GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I"); + GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J"); return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); } diff --git a/core/jni/android_view_InputChannel.cpp b/core/jni/android_view_InputChannel.cpp index ce475e0..d667920 100644 --- a/core/jni/android_view_InputChannel.cpp +++ b/core/jni/android_view_InputChannel.cpp @@ -81,14 +81,14 @@ void NativeInputChannel::invokeAndRemoveDisposeCallback(JNIEnv* env, jobject obj static NativeInputChannel* android_view_InputChannel_getNativeInputChannel(JNIEnv* env, jobject inputChannelObj) { - jint intPtr = env->GetIntField(inputChannelObj, gInputChannelClassInfo.mPtr); - return reinterpret_cast<NativeInputChannel*>(intPtr); + jlong longPtr = env->GetLongField(inputChannelObj, gInputChannelClassInfo.mPtr); + return reinterpret_cast<NativeInputChannel*>(longPtr); } static void android_view_InputChannel_setNativeInputChannel(JNIEnv* env, jobject inputChannelObj, NativeInputChannel* nativeInputChannel) { - env->SetIntField(inputChannelObj, gInputChannelClassInfo.mPtr, - reinterpret_cast<jint>(nativeInputChannel)); + env->SetLongField(inputChannelObj, gInputChannelClassInfo.mPtr, + reinterpret_cast<jlong>(nativeInputChannel)); } sp<InputChannel> android_view_InputChannel_getInputChannel(JNIEnv* env, jobject inputChannelObj) { @@ -296,7 +296,7 @@ int register_android_view_InputChannel(JNIEnv* env) { FIND_CLASS(gInputChannelClassInfo.clazz, "android/view/InputChannel"); GET_FIELD_ID(gInputChannelClassInfo.mPtr, gInputChannelClassInfo.clazz, - "mPtr", "I"); + "mPtr", "J"); GET_METHOD_ID(gInputChannelClassInfo.ctor, gInputChannelClassInfo.clazz, "<init>", "()V"); diff --git a/core/jni/android_view_InputEventReceiver.cpp b/core/jni/android_view_InputEventReceiver.cpp index 92a3e62..f36bf31 100644 --- a/core/jni/android_view_InputEventReceiver.cpp +++ b/core/jni/android_view_InputEventReceiver.cpp @@ -330,7 +330,7 @@ status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env, } -static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, jobject inputChannelObj, jobject messageQueueObj) { sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -356,17 +356,17 @@ static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak, } receiver->incStrong(gInputEventReceiverClassInfo.clazz); // retain a reference for the object - return reinterpret_cast<jint>(receiver.get()); + return reinterpret_cast<jlong>(receiver.get()); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint receiverPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong receiverPtr) { sp<NativeInputEventReceiver> receiver = reinterpret_cast<NativeInputEventReceiver*>(receiverPtr); receiver->dispose(); receiver->decStrong(gInputEventReceiverClassInfo.clazz); // drop reference held by the object } -static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr, +static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jlong receiverPtr, jint seq, jboolean handled) { sp<NativeInputEventReceiver> receiver = reinterpret_cast<NativeInputEventReceiver*>(receiverPtr); @@ -378,7 +378,7 @@ static void nativeFinishInputEvent(JNIEnv* env, jclass clazz, jint receiverPtr, } } -static bool nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jint receiverPtr, +static jboolean nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jlong receiverPtr, jlong frameTimeNanos) { sp<NativeInputEventReceiver> receiver = reinterpret_cast<NativeInputEventReceiver*>(receiverPtr); @@ -389,22 +389,22 @@ static bool nativeConsumeBatchedInputEvents(JNIEnv* env, jclass clazz, jint rece String8 message; message.appendFormat("Failed to consume batched input event. status=%d", status); jniThrowRuntimeException(env, message.string()); - return false; + return JNI_FALSE; } - return consumedBatch; + return consumedBatch ? JNI_TRUE : JNI_FALSE; } static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)I", + "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)J", (void*)nativeInit }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeFinishInputEvent", "(IIZ)V", + { "nativeFinishInputEvent", "(JIZ)V", (void*)nativeFinishInputEvent }, - { "nativeConsumeBatchedInputEvents", "(IJ)Z", + { "nativeConsumeBatchedInputEvents", "(JJ)Z", (void*)nativeConsumeBatchedInputEvents }, }; diff --git a/core/jni/android_view_InputEventSender.cpp b/core/jni/android_view_InputEventSender.cpp index e4b65a1..f156b9a 100644 --- a/core/jni/android_view_InputEventSender.cpp +++ b/core/jni/android_view_InputEventSender.cpp @@ -230,7 +230,7 @@ status_t NativeInputEventSender::receiveFinishedSignals(JNIEnv* env) { } -static jint nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, jobject inputChannelObj, jobject messageQueueObj) { sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -256,17 +256,17 @@ static jint nativeInit(JNIEnv* env, jclass clazz, jobject senderWeak, } sender->incStrong(gInputEventSenderClassInfo.clazz); // retain a reference for the object - return reinterpret_cast<jint>(sender.get()); + return reinterpret_cast<jlong>(sender.get()); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint senderPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong senderPtr) { sp<NativeInputEventSender> sender = reinterpret_cast<NativeInputEventSender*>(senderPtr); sender->dispose(); sender->decStrong(gInputEventSenderClassInfo.clazz); // drop reference held by the object } -static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jint senderPtr, +static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jlong senderPtr, jint seq, jobject eventObj) { sp<NativeInputEventSender> sender = reinterpret_cast<NativeInputEventSender*>(senderPtr); @@ -276,7 +276,7 @@ static jboolean nativeSendKeyEvent(JNIEnv* env, jclass clazz, jint senderPtr, return !status; } -static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jint senderPtr, +static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jlong senderPtr, jint seq, jobject eventObj) { sp<NativeInputEventSender> sender = reinterpret_cast<NativeInputEventSender*>(senderPtr); @@ -289,13 +289,13 @@ static jboolean nativeSendMotionEvent(JNIEnv* env, jclass clazz, jint senderPtr, static JNINativeMethod gMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)I", + "(Ljava/lang/ref/WeakReference;Landroid/view/InputChannel;Landroid/os/MessageQueue;)J", (void*)nativeInit }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeSendKeyEvent", "(IILandroid/view/KeyEvent;)Z", + { "nativeSendKeyEvent", "(JILandroid/view/KeyEvent;)Z", (void*)nativeSendKeyEvent }, - { "nativeSendMotionEvent", "(IILandroid/view/MotionEvent;)Z", + { "nativeSendMotionEvent", "(JILandroid/view/MotionEvent;)Z", (void*)nativeSendMotionEvent }, }; diff --git a/core/jni/android_view_InputQueue.cpp b/core/jni/android_view_InputQueue.cpp index 7532c9d..21b73b1 100644 --- a/core/jni/android_view_InputQueue.cpp +++ b/core/jni/android_view_InputQueue.cpp @@ -151,7 +151,7 @@ void InputQueue::handleMessage(const Message& message) { mFinishedEvents.removeAt(0); } env->CallVoidMethod(inputQueueObj.get(), gInputQueueClassInfo.finishInputEvent, - reinterpret_cast<jint>(event), handled); + reinterpret_cast<jlong>(event), handled); recycleInputEvent(event); } break; @@ -193,7 +193,7 @@ InputQueue* InputQueue::createQueue(jobject inputQueueObj, const sp<Looper>& loo return new InputQueue(inputQueueObj, looper, pipeFds[0], pipeFds[1]); } -static jint nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jMsgQueue) { +static jlong nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jMsgQueue) { sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, jMsgQueue); if (messageQueue == NULL) { jniThrowRuntimeException(env, "MessageQueue is not initialized."); @@ -205,16 +205,16 @@ static jint nativeInit(JNIEnv* env, jobject clazz, jobject queueWeak, jobject jM return 0; } queue->incStrong(&gInputQueueClassInfo); - return reinterpret_cast<jint>(queue.get()); + return reinterpret_cast<jlong>(queue.get()); } -static void nativeDispose(JNIEnv* env, jobject clazz, jint ptr) { +static void nativeDispose(JNIEnv* env, jobject clazz, jlong ptr) { sp<InputQueue> queue = reinterpret_cast<InputQueue*>(ptr); queue->detachLooper(); queue->decStrong(&gInputQueueClassInfo); } -static jint nativeSendKeyEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eventObj, +static jlong nativeSendKeyEvent(JNIEnv* env, jobject clazz, jlong ptr, jobject eventObj, jboolean predispatch) { InputQueue* queue = reinterpret_cast<InputQueue*>(ptr); KeyEvent* event = queue->createKeyEvent(); @@ -230,10 +230,10 @@ static jint nativeSendKeyEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eve } queue->enqueueEvent(event); - return reinterpret_cast<jint>(event); + return reinterpret_cast<jlong>(event); } -static jint nativeSendMotionEvent(JNIEnv* env, jobject clazz, jint ptr, jobject eventObj) { +static jlong nativeSendMotionEvent(JNIEnv* env, jobject clazz, jlong ptr, jobject eventObj) { sp<InputQueue> queue = reinterpret_cast<InputQueue*>(ptr); MotionEvent* originalEvent = android_view_MotionEvent_getNativePtr(env, eventObj); if (!originalEvent) { @@ -243,15 +243,15 @@ static jint nativeSendMotionEvent(JNIEnv* env, jobject clazz, jint ptr, jobject MotionEvent* event = queue->createMotionEvent(); event->copyFrom(originalEvent, true /* keepHistory */); queue->enqueueEvent(event); - return reinterpret_cast<jint>(event); + return reinterpret_cast<jlong>(event); } static const JNINativeMethod g_methods[] = { - { "nativeInit", "(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;)I", + { "nativeInit", "(Ljava/lang/ref/WeakReference;Landroid/os/MessageQueue;)J", (void*) nativeInit }, - { "nativeDispose", "(I)V", (void*) nativeDispose }, - { "nativeSendKeyEvent", "(ILandroid/view/KeyEvent;Z)I", (void*) nativeSendKeyEvent }, - { "nativeSendMotionEvent", "(ILandroid/view/MotionEvent;)I", (void*) nativeSendMotionEvent }, + { "nativeDispose", "(J)V", (void*) nativeDispose }, + { "nativeSendKeyEvent", "(JLandroid/view/KeyEvent;Z)J", (void*) nativeSendKeyEvent }, + { "nativeSendMotionEvent", "(JLandroid/view/MotionEvent;)J", (void*) nativeSendMotionEvent }, }; static const char* const kInputQueuePathName = "android/view/InputQueue"; @@ -272,7 +272,7 @@ int register_android_view_InputQueue(JNIEnv* env) { jclass clazz; FIND_CLASS(clazz, kInputQueuePathName); - GET_METHOD_ID(gInputQueueClassInfo.finishInputEvent, clazz, "finishInputEvent", "(IZ)V"); + GET_METHOD_ID(gInputQueueClassInfo.finishInputEvent, clazz, "finishInputEvent", "(JZ)V"); return AndroidRuntime::registerNativeMethods( env, kInputQueuePathName, diff --git a/core/jni/android_view_KeyCharacterMap.cpp b/core/jni/android_view_KeyCharacterMap.cpp index ffe2dea..62d5129 100644 --- a/core/jni/android_view_KeyCharacterMap.cpp +++ b/core/jni/android_view_KeyCharacterMap.cpp @@ -75,10 +75,10 @@ jobject android_view_KeyCharacterMap_create(JNIEnv* env, int32_t deviceId, } return env->NewObject(gKeyCharacterMapClassInfo.clazz, gKeyCharacterMapClassInfo.ctor, - reinterpret_cast<jint>(map)); + reinterpret_cast<jlong>(map)); } -static jint nativeReadFromParcel(JNIEnv *env, jobject clazz, jobject parcelObj) { +static jlong nativeReadFromParcel(JNIEnv *env, jobject clazz, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); if (!parcel) { return 0; @@ -95,10 +95,10 @@ static jint nativeReadFromParcel(JNIEnv *env, jobject clazz, jobject parcelObj) } NativeKeyCharacterMap* map = new NativeKeyCharacterMap(deviceId, kcm); - return reinterpret_cast<jint>(map); + return reinterpret_cast<jlong>(map); } -static void nativeWriteToParcel(JNIEnv* env, jobject clazz, jint ptr, jobject parcelObj) { +static void nativeWriteToParcel(JNIEnv* env, jobject clazz, jlong ptr, jobject parcelObj) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); Parcel* parcel = parcelForJavaObject(env, parcelObj); if (parcel) { @@ -107,18 +107,18 @@ static void nativeWriteToParcel(JNIEnv* env, jobject clazz, jint ptr, jobject pa } } -static void nativeDispose(JNIEnv *env, jobject clazz, jint ptr) { +static void nativeDispose(JNIEnv *env, jobject clazz, jlong ptr) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); delete map; } -static jchar nativeGetCharacter(JNIEnv *env, jobject clazz, jint ptr, +static jchar nativeGetCharacter(JNIEnv *env, jobject clazz, jlong ptr, jint keyCode, jint metaState) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); return map->getMap()->getCharacter(keyCode, metaState); } -static jboolean nativeGetFallbackAction(JNIEnv *env, jobject clazz, jint ptr, jint keyCode, +static jboolean nativeGetFallbackAction(JNIEnv *env, jobject clazz, jlong ptr, jint keyCode, jint metaState, jobject fallbackActionObj) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); KeyCharacterMap::FallbackAction fallbackAction; @@ -133,12 +133,12 @@ static jboolean nativeGetFallbackAction(JNIEnv *env, jobject clazz, jint ptr, ji return result; } -static jchar nativeGetNumber(JNIEnv *env, jobject clazz, jint ptr, jint keyCode) { +static jchar nativeGetNumber(JNIEnv *env, jobject clazz, jlong ptr, jint keyCode) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); return map->getMap()->getNumber(keyCode); } -static jchar nativeGetMatch(JNIEnv *env, jobject clazz, jint ptr, jint keyCode, +static jchar nativeGetMatch(JNIEnv *env, jobject clazz, jlong ptr, jint keyCode, jcharArray charsArray, jint metaState) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); @@ -154,17 +154,17 @@ static jchar nativeGetMatch(JNIEnv *env, jobject clazz, jint ptr, jint keyCode, return result; } -static jchar nativeGetDisplayLabel(JNIEnv *env, jobject clazz, jint ptr, jint keyCode) { +static jchar nativeGetDisplayLabel(JNIEnv *env, jobject clazz, jlong ptr, jint keyCode) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); return map->getMap()->getDisplayLabel(keyCode); } -static jint nativeGetKeyboardType(JNIEnv *env, jobject clazz, jint ptr) { +static jint nativeGetKeyboardType(JNIEnv *env, jobject clazz, jlong ptr) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); return map->getMap()->getKeyboardType(); } -static jobjectArray nativeGetEvents(JNIEnv *env, jobject clazz, jint ptr, +static jobjectArray nativeGetEvents(JNIEnv *env, jobject clazz, jlong ptr, jcharArray charsArray) { NativeKeyCharacterMap* map = reinterpret_cast<NativeKeyCharacterMap*>(ptr); @@ -199,25 +199,25 @@ static jobjectArray nativeGetEvents(JNIEnv *env, jobject clazz, jint ptr, static JNINativeMethod g_methods[] = { /* name, signature, funcPtr */ - { "nativeReadFromParcel", "(Landroid/os/Parcel;)I", + { "nativeReadFromParcel", "(Landroid/os/Parcel;)J", (void*)nativeReadFromParcel }, - { "nativeWriteToParcel", "(ILandroid/os/Parcel;)V", + { "nativeWriteToParcel", "(JLandroid/os/Parcel;)V", (void*)nativeWriteToParcel }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeGetCharacter", "(III)C", + { "nativeGetCharacter", "(JII)C", (void*)nativeGetCharacter }, - { "nativeGetFallbackAction", "(IIILandroid/view/KeyCharacterMap$FallbackAction;)Z", + { "nativeGetFallbackAction", "(JIILandroid/view/KeyCharacterMap$FallbackAction;)Z", (void*)nativeGetFallbackAction }, - { "nativeGetNumber", "(II)C", + { "nativeGetNumber", "(JI)C", (void*)nativeGetNumber }, - { "nativeGetMatch", "(II[CI)C", + { "nativeGetMatch", "(JI[CI)C", (void*)nativeGetMatch }, - { "nativeGetDisplayLabel", "(II)C", + { "nativeGetDisplayLabel", "(JI)C", (void*)nativeGetDisplayLabel }, - { "nativeGetKeyboardType", "(I)I", + { "nativeGetKeyboardType", "(J)I", (void*)nativeGetKeyboardType }, - { "nativeGetEvents", "(I[C)[Landroid/view/KeyEvent;", + { "nativeGetEvents", "(J[C)[Landroid/view/KeyEvent;", (void*)nativeGetEvents }, }; @@ -239,7 +239,7 @@ int register_android_view_KeyCharacterMap(JNIEnv* env) gKeyCharacterMapClassInfo.clazz = jclass(env->NewGlobalRef(gKeyCharacterMapClassInfo.clazz)); GET_METHOD_ID(gKeyCharacterMapClassInfo.ctor, gKeyCharacterMapClassInfo.clazz, - "<init>", "(I)V"); + "<init>", "(J)V"); FIND_CLASS(gKeyEventClassInfo.clazz, "android/view/KeyEvent"); gKeyEventClassInfo.clazz = jclass(env->NewGlobalRef(gKeyEventClassInfo.clazz)); diff --git a/core/jni/android_view_MotionEvent.cpp b/core/jni/android_view_MotionEvent.cpp index f1b90e1..76e145b 100644 --- a/core/jni/android_view_MotionEvent.cpp +++ b/core/jni/android_view_MotionEvent.cpp @@ -67,13 +67,13 @@ MotionEvent* android_view_MotionEvent_getNativePtr(JNIEnv* env, jobject eventObj return NULL; } return reinterpret_cast<MotionEvent*>( - env->GetIntField(eventObj, gMotionEventClassInfo.mNativePtr)); + env->GetLongField(eventObj, gMotionEventClassInfo.mNativePtr)); } static void android_view_MotionEvent_setNativePtr(JNIEnv* env, jobject eventObj, MotionEvent* event) { - env->SetIntField(eventObj, gMotionEventClassInfo.mNativePtr, - reinterpret_cast<int>(event)); + env->SetLongField(eventObj, gMotionEventClassInfo.mNativePtr, + reinterpret_cast<jlong>(event)); } jobject android_view_MotionEvent_obtainAsCopy(JNIEnv* env, const MotionEvent* event) { @@ -334,8 +334,8 @@ static void pointerPropertiesFromNative(JNIEnv* env, const PointerProperties* po // ---------------------------------------------------------------------------- -static jint android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz, - jint nativePtr, +static jlong android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz, + jlong nativePtr, jint deviceId, jint source, jint action, jint flags, jint edgeFlags, jint metaState, jint buttonState, jfloat xOffset, jfloat yOffset, jfloat xPrecision, jfloat yPrecision, @@ -377,7 +377,7 @@ static jint android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz, xOffset, yOffset, xPrecision, yPrecision, downTimeNanos, eventTimeNanos, pointerCount, pointerProperties, rawPointerCoords); - return reinterpret_cast<jint>(event); + return reinterpret_cast<jlong>(event); Error: if (!nativePtr) { @@ -386,25 +386,25 @@ Error: return 0; } -static jint android_view_MotionEvent_nativeCopy(JNIEnv* env, jclass clazz, - jint destNativePtr, jint sourceNativePtr, jboolean keepHistory) { +static jlong android_view_MotionEvent_nativeCopy(JNIEnv* env, jclass clazz, + jlong destNativePtr, jlong sourceNativePtr, jboolean keepHistory) { MotionEvent* destEvent = reinterpret_cast<MotionEvent*>(destNativePtr); if (!destEvent) { destEvent = new MotionEvent(); } MotionEvent* sourceEvent = reinterpret_cast<MotionEvent*>(sourceNativePtr); destEvent->copyFrom(sourceEvent, keepHistory); - return reinterpret_cast<jint>(destEvent); + return reinterpret_cast<jlong>(destEvent); } static void android_view_MotionEvent_nativeDispose(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); delete event; } static void android_view_MotionEvent_nativeAddBatch(JNIEnv* env, jclass clazz, - jint nativePtr, jlong eventTimeNanos, jobjectArray pointerCoordsObjArray, + jlong nativePtr, jlong eventTimeNanos, jobjectArray pointerCoordsObjArray, jint metaState) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); @@ -430,127 +430,127 @@ static void android_view_MotionEvent_nativeAddBatch(JNIEnv* env, jclass clazz, } static jint android_view_MotionEvent_nativeGetDeviceId(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getDeviceId(); } static jint android_view_MotionEvent_nativeGetSource(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getSource(); } static void android_view_MotionEvent_nativeSetSource(JNIEnv* env, jclass clazz, - jint nativePtr, jint source) { + jlong nativePtr, jint source) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->setSource(source); } static jint android_view_MotionEvent_nativeGetAction(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getAction(); } static void android_view_MotionEvent_nativeSetAction(JNIEnv* env, jclass clazz, - jint nativePtr, jint action) { + jlong nativePtr, jint action) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->setAction(action); } static jboolean android_view_MotionEvent_nativeIsTouchEvent(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->isTouchEvent(); } static jint android_view_MotionEvent_nativeGetFlags(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getFlags(); } static void android_view_MotionEvent_nativeSetFlags(JNIEnv* env, jclass clazz, - jint nativePtr, jint flags) { + jlong nativePtr, jint flags) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->setFlags(flags); } static jint android_view_MotionEvent_nativeGetEdgeFlags(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getEdgeFlags(); } static void android_view_MotionEvent_nativeSetEdgeFlags(JNIEnv* env, jclass clazz, - jint nativePtr, jint edgeFlags) { + jlong nativePtr, jint edgeFlags) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->setEdgeFlags(edgeFlags); } static jint android_view_MotionEvent_nativeGetMetaState(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getMetaState(); } static jint android_view_MotionEvent_nativeGetButtonState(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getButtonState(); } static void android_view_MotionEvent_nativeOffsetLocation(JNIEnv* env, jclass clazz, - jint nativePtr, jfloat deltaX, jfloat deltaY) { + jlong nativePtr, jfloat deltaX, jfloat deltaY) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->offsetLocation(deltaX, deltaY); } static jfloat android_view_MotionEvent_nativeGetXOffset(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getXOffset(); } static jfloat android_view_MotionEvent_nativeGetYOffset(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getYOffset(); } static jfloat android_view_MotionEvent_nativeGetXPrecision(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getXPrecision(); } static jfloat android_view_MotionEvent_nativeGetYPrecision(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getYPrecision(); } static jlong android_view_MotionEvent_nativeGetDownTimeNanos(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return event->getDownTime(); } static void android_view_MotionEvent_nativeSetDownTimeNanos(JNIEnv* env, jclass clazz, - jint nativePtr, jlong downTimeNanos) { + jlong nativePtr, jlong downTimeNanos) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->setDownTime(downTimeNanos); } static jint android_view_MotionEvent_nativeGetPointerCount(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return jint(event->getPointerCount()); } static jint android_view_MotionEvent_nativeGetPointerId(JNIEnv* env, jclass clazz, - jint nativePtr, jint pointerIndex) { + jlong nativePtr, jint pointerIndex) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount)) { @@ -560,7 +560,7 @@ static jint android_view_MotionEvent_nativeGetPointerId(JNIEnv* env, jclass claz } static jint android_view_MotionEvent_nativeGetToolType(JNIEnv* env, jclass clazz, - jint nativePtr, jint pointerIndex) { + jlong nativePtr, jint pointerIndex) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount)) { @@ -570,19 +570,19 @@ static jint android_view_MotionEvent_nativeGetToolType(JNIEnv* env, jclass clazz } static jint android_view_MotionEvent_nativeFindPointerIndex(JNIEnv* env, jclass clazz, - jint nativePtr, jint pointerId) { + jlong nativePtr, jint pointerId) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return jint(event->findPointerIndex(pointerId)); } static jint android_view_MotionEvent_nativeGetHistorySize(JNIEnv* env, jclass clazz, - jint nativePtr) { + jlong nativePtr) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); return jint(event->getHistorySize()); } static jlong android_view_MotionEvent_nativeGetEventTimeNanos(JNIEnv* env, jclass clazz, - jint nativePtr, jint historyPos) { + jlong nativePtr, jint historyPos) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); if (historyPos == HISTORY_CURRENT) { return event->getEventTime(); @@ -596,7 +596,7 @@ static jlong android_view_MotionEvent_nativeGetEventTimeNanos(JNIEnv* env, jclas } static jfloat android_view_MotionEvent_nativeGetRawAxisValue(JNIEnv* env, jclass clazz, - jint nativePtr, jint axis, jint pointerIndex, jint historyPos) { + jlong nativePtr, jint axis, jint pointerIndex, jint historyPos) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount)) { @@ -615,7 +615,7 @@ static jfloat android_view_MotionEvent_nativeGetRawAxisValue(JNIEnv* env, jclass } static jfloat android_view_MotionEvent_nativeGetAxisValue(JNIEnv* env, jclass clazz, - jint nativePtr, jint axis, jint pointerIndex, jint historyPos) { + jlong nativePtr, jint axis, jint pointerIndex, jint historyPos) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount)) { @@ -634,7 +634,7 @@ static jfloat android_view_MotionEvent_nativeGetAxisValue(JNIEnv* env, jclass cl } static void android_view_MotionEvent_nativeGetPointerCoords(JNIEnv* env, jclass clazz, - jint nativePtr, jint pointerIndex, jint historyPos, jobject outPointerCoordsObj) { + jlong nativePtr, jint pointerIndex, jint historyPos, jobject outPointerCoordsObj) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount) @@ -657,7 +657,7 @@ static void android_view_MotionEvent_nativeGetPointerCoords(JNIEnv* env, jclass } static void android_view_MotionEvent_nativeGetPointerProperties(JNIEnv* env, jclass clazz, - jint nativePtr, jint pointerIndex, jobject outPointerPropertiesObj) { + jlong nativePtr, jint pointerIndex, jobject outPointerPropertiesObj) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); size_t pointerCount = event->getPointerCount(); if (!validatePointerIndex(env, pointerIndex, pointerCount) @@ -670,13 +670,13 @@ static void android_view_MotionEvent_nativeGetPointerProperties(JNIEnv* env, jcl } static void android_view_MotionEvent_nativeScale(JNIEnv* env, jclass clazz, - jint nativePtr, jfloat scale) { + jlong nativePtr, jfloat scale) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); event->scale(scale); } static void android_view_MotionEvent_nativeTransform(JNIEnv* env, jclass clazz, - jint nativePtr, jobject matrixObj) { + jlong nativePtr, jobject matrixObj) { SkMatrix* matrix = android_graphics_Matrix_getSkMatrix(env, matrixObj); MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); @@ -693,8 +693,8 @@ static void android_view_MotionEvent_nativeTransform(JNIEnv* env, jclass clazz, event->transform(m); } -static jint android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass clazz, - jint nativePtr, jobject parcelObj) { +static jlong android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass clazz, + jlong nativePtr, jobject parcelObj) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); if (!event) { event = new MotionEvent(); @@ -710,11 +710,11 @@ static jint android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass cl jniThrowRuntimeException(env, "Failed to read MotionEvent parcel."); return 0; } - return reinterpret_cast<jint>(event); + return reinterpret_cast<jlong>(event); } static void android_view_MotionEvent_nativeWriteToParcel(JNIEnv* env, jclass clazz, - jint nativePtr, jobject parcelObj) { + jlong nativePtr, jobject parcelObj) { MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr); Parcel* parcel = parcelForJavaObject(env, parcelObj); @@ -729,116 +729,116 @@ static void android_view_MotionEvent_nativeWriteToParcel(JNIEnv* env, jclass cla static JNINativeMethod gMotionEventMethods[] = { /* name, signature, funcPtr */ { "nativeInitialize", - "(IIIIIIIIFFFFJJI[Landroid/view/MotionEvent$PointerProperties;" - "[Landroid/view/MotionEvent$PointerCoords;)I", + "(JIIIIIIIFFFFJJI[Landroid/view/MotionEvent$PointerProperties;" + "[Landroid/view/MotionEvent$PointerCoords;)J", (void*)android_view_MotionEvent_nativeInitialize }, { "nativeCopy", - "(IIZ)I", + "(JJZ)J", (void*)android_view_MotionEvent_nativeCopy }, { "nativeDispose", - "(I)V", + "(J)V", (void*)android_view_MotionEvent_nativeDispose }, { "nativeAddBatch", - "(IJ[Landroid/view/MotionEvent$PointerCoords;I)V", + "(JJ[Landroid/view/MotionEvent$PointerCoords;I)V", (void*)android_view_MotionEvent_nativeAddBatch }, { "nativeGetDeviceId", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetDeviceId }, { "nativeGetSource", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetSource }, { "nativeSetSource", - "(II)I", + "(JI)I", (void*)android_view_MotionEvent_nativeSetSource }, { "nativeGetAction", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetAction }, { "nativeSetAction", - "(II)V", + "(JI)V", (void*)android_view_MotionEvent_nativeSetAction }, { "nativeIsTouchEvent", - "(I)Z", + "(J)Z", (void*)android_view_MotionEvent_nativeIsTouchEvent }, { "nativeGetFlags", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetFlags }, { "nativeSetFlags", - "(II)V", + "(JI)V", (void*)android_view_MotionEvent_nativeSetFlags }, { "nativeGetEdgeFlags", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetEdgeFlags }, { "nativeSetEdgeFlags", - "(II)V", + "(JI)V", (void*)android_view_MotionEvent_nativeSetEdgeFlags }, { "nativeGetMetaState", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetMetaState }, { "nativeGetButtonState", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetButtonState }, { "nativeOffsetLocation", - "(IFF)V", + "(JFF)V", (void*)android_view_MotionEvent_nativeOffsetLocation }, { "nativeGetXOffset", - "(I)F", + "(J)F", (void*)android_view_MotionEvent_nativeGetXOffset }, { "nativeGetYOffset", - "(I)F", + "(J)F", (void*)android_view_MotionEvent_nativeGetYOffset }, { "nativeGetXPrecision", - "(I)F", + "(J)F", (void*)android_view_MotionEvent_nativeGetXPrecision }, { "nativeGetYPrecision", - "(I)F", + "(J)F", (void*)android_view_MotionEvent_nativeGetYPrecision }, { "nativeGetDownTimeNanos", - "(I)J", + "(J)J", (void*)android_view_MotionEvent_nativeGetDownTimeNanos }, { "nativeSetDownTimeNanos", - "(IJ)V", + "(JJ)V", (void*)android_view_MotionEvent_nativeSetDownTimeNanos }, { "nativeGetPointerCount", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetPointerCount }, { "nativeGetPointerId", - "(II)I", + "(JI)I", (void*)android_view_MotionEvent_nativeGetPointerId }, { "nativeGetToolType", - "(II)I", + "(JI)I", (void*)android_view_MotionEvent_nativeGetToolType }, { "nativeFindPointerIndex", - "(II)I", + "(JI)I", (void*)android_view_MotionEvent_nativeFindPointerIndex }, { "nativeGetHistorySize", - "(I)I", + "(J)I", (void*)android_view_MotionEvent_nativeGetHistorySize }, { "nativeGetEventTimeNanos", - "(II)J", + "(JI)J", (void*)android_view_MotionEvent_nativeGetEventTimeNanos }, { "nativeGetRawAxisValue", - "(IIII)F", + "(JIII)F", (void*)android_view_MotionEvent_nativeGetRawAxisValue }, { "nativeGetAxisValue", - "(IIII)F", + "(JIII)F", (void*)android_view_MotionEvent_nativeGetAxisValue }, { "nativeGetPointerCoords", - "(IIILandroid/view/MotionEvent$PointerCoords;)V", + "(JIILandroid/view/MotionEvent$PointerCoords;)V", (void*)android_view_MotionEvent_nativeGetPointerCoords }, { "nativeGetPointerProperties", - "(IILandroid/view/MotionEvent$PointerProperties;)V", + "(JILandroid/view/MotionEvent$PointerProperties;)V", (void*)android_view_MotionEvent_nativeGetPointerProperties }, { "nativeScale", - "(IF)V", + "(JF)V", (void*)android_view_MotionEvent_nativeScale }, { "nativeTransform", - "(ILandroid/graphics/Matrix;)V", + "(JLandroid/graphics/Matrix;)V", (void*)android_view_MotionEvent_nativeTransform }, { "nativeReadFromParcel", - "(ILandroid/os/Parcel;)I", + "(JLandroid/os/Parcel;)J", (void*)android_view_MotionEvent_nativeReadFromParcel }, { "nativeWriteToParcel", - "(ILandroid/os/Parcel;)V", + "(JLandroid/os/Parcel;)V", (void*)android_view_MotionEvent_nativeWriteToParcel }, }; @@ -871,7 +871,7 @@ int register_android_view_MotionEvent(JNIEnv* env) { GET_METHOD_ID(gMotionEventClassInfo.recycle, gMotionEventClassInfo.clazz, "recycle", "()V"); GET_FIELD_ID(gMotionEventClassInfo.mNativePtr, gMotionEventClassInfo.clazz, - "mNativePtr", "I"); + "mNativePtr", "J"); jclass clazz; FIND_CLASS(clazz, "android/view/MotionEvent$PointerCoords"); diff --git a/core/jni/android_view_Surface.cpp b/core/jni/android_view_Surface.cpp index dd178d8..ab6c1e0 100644 --- a/core/jni/android_view_Surface.cpp +++ b/core/jni/android_view_Surface.cpp @@ -97,7 +97,7 @@ sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) { gSurfaceClassInfo.mLock); if (env->MonitorEnter(lock) == JNI_OK) { sur = reinterpret_cast<Surface *>( - env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeObject)); + env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject)); env->MonitorExit(lock); } return sur; @@ -114,7 +114,8 @@ jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env, return NULL; } - jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz, gSurfaceClassInfo.ctor, surface.get()); + jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz, + gSurfaceClassInfo.ctor, (jlong)surface.get()); if (surfaceObj == NULL) { if (env->ExceptionCheck()) { ALOGE("Could not create instance of Surface from IGraphicBufferProducer."); @@ -135,7 +136,7 @@ static inline bool isSurfaceValid(const sp<Surface>& sur) { // ---------------------------------------------------------------------------- -static jint nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz, +static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz, jobject surfaceTextureObj) { sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj)); if (producer == NULL) { @@ -151,20 +152,20 @@ static jint nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz, } surface->incStrong(&sRefBaseOwner); - return int(surface.get()); + return jlong(surface.get()); } -static void nativeRelease(JNIEnv* env, jclass clazz, jint nativeObject) { +static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); sur->decStrong(&sRefBaseOwner); } -static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jint nativeObject) { +static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE; } -static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jint nativeObject) { +static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); if (!isSurfaceValid(sur)) { doThrowIAE(env); @@ -193,14 +194,14 @@ static inline SkBitmap::Config convertPixelFormat(PixelFormat format) { static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) { jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer); SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>( - env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas)); - env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas); - env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas); + env->GetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas)); + env->SetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas, (jlong)newCanvas); + env->SetLongField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (jlong)newCanvas); SkSafeUnref(previousCanvas); } -static jint nativeLockCanvas(JNIEnv* env, jclass clazz, - jint nativeObject, jobject canvasObj, jobject dirtyRectObj) { +static jlong nativeLockCanvas(JNIEnv* env, jclass clazz, + jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) { sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); if (!isSurfaceValid(surface)) { @@ -264,11 +265,11 @@ static jint nativeLockCanvas(JNIEnv* env, jclass clazz, // because the latter could be replaced while the surface is locked. sp<Surface> lockedSurface(surface); lockedSurface->incStrong(&sRefBaseOwner); - return (int) lockedSurface.get(); + return (jlong) lockedSurface.get(); } static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz, - jint nativeObject, jobject canvasObj) { + jlong nativeObject, jobject canvasObj) { sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); if (!isSurfaceValid(surface)) { return; @@ -287,8 +288,8 @@ static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz, // ---------------------------------------------------------------------------- -static jint nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz, - jint surfaceControlNativeObj) { +static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz, + jlong surfaceControlNativeObj) { /* * This is used by the WindowManagerService just after constructing * a Surface and is necessary for returning the Surface reference to @@ -300,11 +301,11 @@ static jint nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz, if (surface != NULL) { surface->incStrong(&sRefBaseOwner); } - return reinterpret_cast<jint>(surface.get()); + return reinterpret_cast<jlong>(surface.get()); } -static jint nativeReadFromParcel(JNIEnv* env, jclass clazz, - jint nativeObject, jobject parcelObj) { +static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz, + jlong nativeObject, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); if (parcel == NULL) { doThrowNPE(env); @@ -319,7 +320,7 @@ static jint nativeReadFromParcel(JNIEnv* env, jclass clazz, if (self != NULL && (self->getIGraphicBufferProducer()->asBinder() == binder)) { // same IGraphicBufferProducer, return ourselves - return int(self.get()); + return jlong(self.get()); } sp<Surface> sur; @@ -336,11 +337,11 @@ static jint nativeReadFromParcel(JNIEnv* env, jclass clazz, self->decStrong(&sRefBaseOwner); } - return int(sur.get()); + return jlong(sur.get()); } static void nativeWriteToParcel(JNIEnv* env, jclass clazz, - jint nativeObject, jobject parcelObj) { + jlong nativeObject, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); if (parcel == NULL) { doThrowNPE(env); @@ -353,23 +354,23 @@ static void nativeWriteToParcel(JNIEnv* env, jclass clazz, // ---------------------------------------------------------------------------- static JNINativeMethod gSurfaceMethods[] = { - {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)I", + {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J", (void*)nativeCreateFromSurfaceTexture }, - {"nativeRelease", "(I)V", + {"nativeRelease", "(J)V", (void*)nativeRelease }, - {"nativeIsValid", "(I)Z", + {"nativeIsValid", "(J)Z", (void*)nativeIsValid }, - {"nativeIsConsumerRunningBehind", "(I)Z", + {"nativeIsConsumerRunningBehind", "(J)Z", (void*)nativeIsConsumerRunningBehind }, - {"nativeLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)I", + {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J", (void*)nativeLockCanvas }, - {"nativeUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)V", + {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V", (void*)nativeUnlockCanvasAndPost }, - {"nativeCreateFromSurfaceControl", "(I)I", + {"nativeCreateFromSurfaceControl", "(J)J", (void*)nativeCreateFromSurfaceControl }, - {"nativeReadFromParcel", "(ILandroid/os/Parcel;)I", + {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J", (void*)nativeReadFromParcel }, - {"nativeWriteToParcel", "(ILandroid/os/Parcel;)V", + {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V", (void*)nativeWriteToParcel }, }; @@ -381,18 +382,18 @@ int register_android_view_Surface(JNIEnv* env) jclass clazz = env->FindClass("android/view/Surface"); gSurfaceClassInfo.clazz = jclass(env->NewGlobalRef(clazz)); gSurfaceClassInfo.mNativeObject = - env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeObject", "I"); + env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeObject", "J"); gSurfaceClassInfo.mLock = env->GetFieldID(gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;"); - gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(I)V"); + gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "(J)V"); clazz = env->FindClass("android/graphics/Canvas"); gCanvasClassInfo.mFinalizer = env->GetFieldID(clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;"); - gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I"); + gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "J"); gCanvasClassInfo.mSurfaceFormat = env->GetFieldID(clazz, "mSurfaceFormat", "I"); clazz = env->FindClass("android/graphics/Canvas$CanvasFinalizer"); - gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I"); + gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "J"); clazz = env->FindClass("android/graphics/Rect"); gRectClassInfo.left = env->GetFieldID(clazz, "left", "I"); diff --git a/core/jni/android_view_SurfaceControl.cpp b/core/jni/android_view_SurfaceControl.cpp index b8d3c20..ed84a64 100644 --- a/core/jni/android_view_SurfaceControl.cpp +++ b/core/jni/android_view_SurfaceControl.cpp @@ -91,7 +91,7 @@ private: // ---------------------------------------------------------------------------- -static jint nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj, +static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj, jstring nameStr, jint w, jint h, jint format, jint flags) { ScopedUtfChars name(env, nameStr); sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj)); @@ -102,15 +102,15 @@ static jint nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj, return 0; } surface->incStrong((void *)nativeCreate); - return int(surface.get()); + return reinterpret_cast<jlong>(surface.get()); } -static void nativeRelease(JNIEnv* env, jclass clazz, jint nativeObject) { +static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject)); ctrl->decStrong((void *)nativeCreate); } -static void nativeDestroy(JNIEnv* env, jclass clazz, jint nativeObject) { +static void nativeDestroy(JNIEnv* env, jclass clazz, jlong nativeObject) { sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject)); ctrl->clear(); ctrl->decStrong((void *)nativeCreate); @@ -209,7 +209,7 @@ static void nativeSetAnimationTransaction(JNIEnv* env, jclass clazz) { SurfaceComposerClient::setAnimationTransaction(); } -static void nativeSetLayer(JNIEnv* env, jclass clazz, jint nativeObject, jint zorder) { +static void nativeSetLayer(JNIEnv* env, jclass clazz, jlong nativeObject, jint zorder) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setLayer(zorder); if (err < 0 && err != NO_INIT) { @@ -217,7 +217,7 @@ static void nativeSetLayer(JNIEnv* env, jclass clazz, jint nativeObject, jint zo } } -static void nativeSetPosition(JNIEnv* env, jclass clazz, jint nativeObject, jfloat x, jfloat y) { +static void nativeSetPosition(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat x, jfloat y) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setPosition(x, y); if (err < 0 && err != NO_INIT) { @@ -225,7 +225,7 @@ static void nativeSetPosition(JNIEnv* env, jclass clazz, jint nativeObject, jflo } } -static void nativeSetSize(JNIEnv* env, jclass clazz, jint nativeObject, jint w, jint h) { +static void nativeSetSize(JNIEnv* env, jclass clazz, jlong nativeObject, jint w, jint h) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setSize(w, h); if (err < 0 && err != NO_INIT) { @@ -233,7 +233,7 @@ static void nativeSetSize(JNIEnv* env, jclass clazz, jint nativeObject, jint w, } } -static void nativeSetFlags(JNIEnv* env, jclass clazz, jint nativeObject, jint flags, jint mask) { +static void nativeSetFlags(JNIEnv* env, jclass clazz, jlong nativeObject, jint flags, jint mask) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setFlags(flags, mask); if (err < 0 && err != NO_INIT) { @@ -241,7 +241,7 @@ static void nativeSetFlags(JNIEnv* env, jclass clazz, jint nativeObject, jint fl } } -static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jint nativeObject, jobject regionObj) { +static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jlong nativeObject, jobject regionObj) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); SkRegion* region = android_graphics_Region_getSkRegion(env, regionObj); if (!region) { @@ -266,7 +266,7 @@ static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jint nativ } } -static void nativeSetAlpha(JNIEnv* env, jclass clazz, jint nativeObject, jfloat alpha) { +static void nativeSetAlpha(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat alpha) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setAlpha(alpha); if (err < 0 && err != NO_INIT) { @@ -274,7 +274,7 @@ static void nativeSetAlpha(JNIEnv* env, jclass clazz, jint nativeObject, jfloat } } -static void nativeSetMatrix(JNIEnv* env, jclass clazz, jint nativeObject, +static void nativeSetMatrix(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setMatrix(dsdx, dtdx, dsdy, dtdy); @@ -283,7 +283,7 @@ static void nativeSetMatrix(JNIEnv* env, jclass clazz, jint nativeObject, } } -static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jint nativeObject, +static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jlong nativeObject, jint l, jint t, jint r, jint b) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); Rect crop(l, t, r, b); @@ -293,7 +293,7 @@ static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jint nativeObject, } } -static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jint nativeObject, jint layerStack) { +static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jlong nativeObject, jint layerStack) { SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); status_t err = ctrl->setLayerStack(layerStack); if (err < 0 && err != NO_INIT) { @@ -321,7 +321,7 @@ static void nativeDestroyDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) { } static void nativeSetDisplaySurface(JNIEnv* env, jclass clazz, - jobject tokenObj, jint nativeSurfaceObject) { + jobject tokenObj, jlong nativeSurfaceObject) { sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); if (token == NULL) return; sp<IGraphicBufferProducer> bufferProducer; @@ -390,11 +390,11 @@ static void nativeUnblankDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) { // ---------------------------------------------------------------------------- static JNINativeMethod sSurfaceControlMethods[] = { - {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)I", + {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)J", (void*)nativeCreate }, - {"nativeRelease", "(I)V", + {"nativeRelease", "(J)V", (void*)nativeRelease }, - {"nativeDestroy", "(I)V", + {"nativeDestroy", "(J)V", (void*)nativeDestroy }, {"nativeScreenshot", "(Landroid/os/IBinder;IIIIZ)Landroid/graphics/Bitmap;", (void*)nativeScreenshotBitmap }, @@ -406,23 +406,23 @@ static JNINativeMethod sSurfaceControlMethods[] = { (void*)nativeCloseTransaction }, {"nativeSetAnimationTransaction", "()V", (void*)nativeSetAnimationTransaction }, - {"nativeSetLayer", "(II)V", + {"nativeSetLayer", "(JI)V", (void*)nativeSetLayer }, - {"nativeSetPosition", "(IFF)V", + {"nativeSetPosition", "(JFF)V", (void*)nativeSetPosition }, - {"nativeSetSize", "(III)V", + {"nativeSetSize", "(JII)V", (void*)nativeSetSize }, - {"nativeSetTransparentRegionHint", "(ILandroid/graphics/Region;)V", + {"nativeSetTransparentRegionHint", "(JLandroid/graphics/Region;)V", (void*)nativeSetTransparentRegionHint }, - {"nativeSetAlpha", "(IF)V", + {"nativeSetAlpha", "(JF)V", (void*)nativeSetAlpha }, - {"nativeSetMatrix", "(IFFFF)V", + {"nativeSetMatrix", "(JFFFF)V", (void*)nativeSetMatrix }, - {"nativeSetFlags", "(III)V", + {"nativeSetFlags", "(JII)V", (void*)nativeSetFlags }, - {"nativeSetWindowCrop", "(IIIII)V", + {"nativeSetWindowCrop", "(JIIII)V", (void*)nativeSetWindowCrop }, - {"nativeSetLayerStack", "(II)V", + {"nativeSetLayerStack", "(JI)V", (void*)nativeSetLayerStack }, {"nativeGetBuiltInDisplay", "(I)Landroid/os/IBinder;", (void*)nativeGetBuiltInDisplay }, @@ -430,7 +430,7 @@ static JNINativeMethod sSurfaceControlMethods[] = { (void*)nativeCreateDisplay }, {"nativeDestroyDisplay", "(Landroid/os/IBinder;)V", (void*)nativeDestroyDisplay }, - {"nativeSetDisplaySurface", "(Landroid/os/IBinder;I)V", + {"nativeSetDisplaySurface", "(Landroid/os/IBinder;J)V", (void*)nativeSetDisplaySurface }, {"nativeSetDisplayLayerStack", "(Landroid/os/IBinder;I)V", (void*)nativeSetDisplayLayerStack }, diff --git a/core/jni/android_view_TextureView.cpp b/core/jni/android_view_TextureView.cpp index 7a4a20a..77ede33 100644 --- a/core/jni/android_view_TextureView.cpp +++ b/core/jni/android_view_TextureView.cpp @@ -60,9 +60,15 @@ static struct { #define GET_INT(object, field) \ env->GetIntField(object, field) +#define GET_LONG(object, field) \ + env->GetLongField(object, field) + #define SET_INT(object, field, value) \ env->SetIntField(object, field, value) +#define SET_LONG(object, field, value) \ + env->SetLongField(object, field, value) + #define INVOKEV(object, method, ...) \ env->CallVoidMethod(object, method, __VA_ARGS__) @@ -104,35 +110,35 @@ static void android_view_TextureView_createNativeWindow(JNIEnv* env, jobject tex sp<ANativeWindow> window = new Surface(producer, true); window->incStrong((void*)android_view_TextureView_createNativeWindow); - SET_INT(textureView, gTextureViewClassInfo.nativeWindow, jint(window.get())); + SET_LONG(textureView, gTextureViewClassInfo.nativeWindow, jlong(window.get())); } static void android_view_TextureView_destroyNativeWindow(JNIEnv* env, jobject textureView) { ANativeWindow* nativeWindow = (ANativeWindow*) - GET_INT(textureView, gTextureViewClassInfo.nativeWindow); + GET_LONG(textureView, gTextureViewClassInfo.nativeWindow); if (nativeWindow) { sp<ANativeWindow> window(nativeWindow); window->decStrong((void*)android_view_TextureView_createNativeWindow); - SET_INT(textureView, gTextureViewClassInfo.nativeWindow, 0); + SET_LONG(textureView, gTextureViewClassInfo.nativeWindow, 0); } } static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) { jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer); SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>( - env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas)); - env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas); - env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas); + env->GetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas)); + env->SetLongField(canvasObj, gCanvasClassInfo.mNativeCanvas, (jlong)newCanvas); + env->SetLongField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (jlong)newCanvas); SkSafeUnref(previousCanvas); } static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject, - jint nativeWindow, jobject canvas, jobject dirtyRect) { + jlong nativeWindow, jobject canvas, jobject dirtyRect) { if (!nativeWindow) { - return false; + return JNI_FALSE; } ANativeWindow_Buffer buffer; @@ -149,7 +155,7 @@ static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject, sp<ANativeWindow> window((ANativeWindow*) nativeWindow); int32_t status = native_window_lock(window.get(), &buffer, &rect); - if (status) return false; + if (status) return JNI_FALSE; ssize_t bytesCount = buffer.stride * bytesPerPixel(buffer.format); @@ -180,11 +186,11 @@ static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject, int(rect.left), int(rect.top), int(rect.right), int(rect.bottom)); } - return true; + return JNI_TRUE; } static void android_view_TextureView_unlockCanvasAndPost(JNIEnv* env, jobject, - jint nativeWindow, jobject canvas) { + jlong nativeWindow, jobject canvas) { SkCanvas* nativeCanvas = SkNEW(SkCanvas); swapCanvasPtr(env, canvas, nativeCanvas); @@ -207,9 +213,9 @@ static JNINativeMethod gMethods[] = { { "nDestroyNativeWindow", "()V", (void*) android_view_TextureView_destroyNativeWindow }, - { "nLockCanvas", "(ILandroid/graphics/Canvas;Landroid/graphics/Rect;)Z", + { "nLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)Z", (void*) android_view_TextureView_lockCanvas }, - { "nUnlockCanvasAndPost", "(ILandroid/graphics/Canvas;)V", + { "nUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V", (void*) android_view_TextureView_unlockCanvasAndPost }, }; @@ -237,14 +243,14 @@ int register_android_view_TextureView(JNIEnv* env) { FIND_CLASS(clazz, "android/graphics/Canvas"); GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;"); - GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I"); + GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J"); GET_FIELD_ID(gCanvasClassInfo.mSurfaceFormat, clazz, "mSurfaceFormat", "I"); FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer"); - GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "I"); + GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J"); FIND_CLASS(clazz, "android/view/TextureView"); - GET_FIELD_ID(gTextureViewClassInfo.nativeWindow, clazz, "mNativeWindow", "I"); + GET_FIELD_ID(gTextureViewClassInfo.nativeWindow, clazz, "mNativeWindow", "J"); return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); } diff --git a/core/jni/android_view_VelocityTracker.cpp b/core/jni/android_view_VelocityTracker.cpp index 90ba2ba..1e36932 100644 --- a/core/jni/android_view_VelocityTracker.cpp +++ b/core/jni/android_view_VelocityTracker.cpp @@ -138,26 +138,26 @@ bool VelocityTrackerState::getEstimator(int32_t id, VelocityTracker::Estimator* // --- JNI Methods --- -static jint android_view_VelocityTracker_nativeInitialize(JNIEnv* env, jclass clazz, +static jlong android_view_VelocityTracker_nativeInitialize(JNIEnv* env, jclass clazz, jstring strategyStr) { if (strategyStr) { ScopedUtfChars strategy(env, strategyStr); - return reinterpret_cast<jint>(new VelocityTrackerState(strategy.c_str())); + return reinterpret_cast<jlong>(new VelocityTrackerState(strategy.c_str())); } - return reinterpret_cast<jint>(new VelocityTrackerState(NULL)); + return reinterpret_cast<jlong>(new VelocityTrackerState(NULL)); } -static void android_view_VelocityTracker_nativeDispose(JNIEnv* env, jclass clazz, jint ptr) { +static void android_view_VelocityTracker_nativeDispose(JNIEnv* env, jclass clazz, jlong ptr) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); delete state; } -static void android_view_VelocityTracker_nativeClear(JNIEnv* env, jclass clazz, jint ptr) { +static void android_view_VelocityTracker_nativeClear(JNIEnv* env, jclass clazz, jlong ptr) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); state->clear(); } -static void android_view_VelocityTracker_nativeAddMovement(JNIEnv* env, jclass clazz, jint ptr, +static void android_view_VelocityTracker_nativeAddMovement(JNIEnv* env, jclass clazz, jlong ptr, jobject eventObj) { const MotionEvent* event = android_view_MotionEvent_getNativePtr(env, eventObj); if (!event) { @@ -170,13 +170,13 @@ static void android_view_VelocityTracker_nativeAddMovement(JNIEnv* env, jclass c } static void android_view_VelocityTracker_nativeComputeCurrentVelocity(JNIEnv* env, jclass clazz, - jint ptr, jint units, jfloat maxVelocity) { + jlong ptr, jint units, jfloat maxVelocity) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); state->computeCurrentVelocity(units, maxVelocity); } static jfloat android_view_VelocityTracker_nativeGetXVelocity(JNIEnv* env, jclass clazz, - jint ptr, jint id) { + jlong ptr, jint id) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); float vx; state->getVelocity(id, &vx, NULL); @@ -184,7 +184,7 @@ static jfloat android_view_VelocityTracker_nativeGetXVelocity(JNIEnv* env, jclas } static jfloat android_view_VelocityTracker_nativeGetYVelocity(JNIEnv* env, jclass clazz, - jint ptr, jint id) { + jlong ptr, jint id) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); float vy; state->getVelocity(id, NULL, &vy); @@ -192,7 +192,7 @@ static jfloat android_view_VelocityTracker_nativeGetYVelocity(JNIEnv* env, jclas } static jboolean android_view_VelocityTracker_nativeGetEstimator(JNIEnv* env, jclass clazz, - jint ptr, jint id, jobject outEstimatorObj) { + jlong ptr, jint id, jobject outEstimatorObj) { VelocityTrackerState* state = reinterpret_cast<VelocityTrackerState*>(ptr); VelocityTracker::Estimator estimator; bool result = state->getEstimator(id, &estimator); @@ -217,28 +217,28 @@ static jboolean android_view_VelocityTracker_nativeGetEstimator(JNIEnv* env, jcl static JNINativeMethod gVelocityTrackerMethods[] = { /* name, signature, funcPtr */ { "nativeInitialize", - "(Ljava/lang/String;)I", + "(Ljava/lang/String;)J", (void*)android_view_VelocityTracker_nativeInitialize }, { "nativeDispose", - "(I)V", + "(J)V", (void*)android_view_VelocityTracker_nativeDispose }, { "nativeClear", - "(I)V", + "(J)V", (void*)android_view_VelocityTracker_nativeClear }, { "nativeAddMovement", - "(ILandroid/view/MotionEvent;)V", + "(JLandroid/view/MotionEvent;)V", (void*)android_view_VelocityTracker_nativeAddMovement }, { "nativeComputeCurrentVelocity", - "(IIF)V", + "(JIF)V", (void*)android_view_VelocityTracker_nativeComputeCurrentVelocity }, { "nativeGetXVelocity", - "(II)F", + "(JI)F", (void*)android_view_VelocityTracker_nativeGetXVelocity }, { "nativeGetYVelocity", - "(II)F", + "(JI)F", (void*)android_view_VelocityTracker_nativeGetYVelocity }, { "nativeGetEstimator", - "(IILandroid/view/VelocityTracker$Estimator;)Z", + "(JILandroid/view/VelocityTracker$Estimator;)Z", (void*)android_view_VelocityTracker_nativeGetEstimator }, }; diff --git a/core/jni/com_android_internal_content_NativeLibraryHelper.cpp b/core/jni/com_android_internal_content_NativeLibraryHelper.cpp index bf5accd..a860918 100644 --- a/core/jni/com_android_internal_content_NativeLibraryHelper.cpp +++ b/core/jni/com_android_internal_content_NativeLibraryHelper.cpp @@ -21,7 +21,9 @@ #include <utils/Log.h> #include <androidfw/ZipFileRO.h> +#include <androidfw/ZipUtils.h> #include <ScopedUtfChars.h> +#include <UniquePtr.h> #include <zlib.h> @@ -143,7 +145,7 @@ isFileDifferent(const char* filePath, size_t fileSize, time_t modifiedTime, } static install_status_t -sumFiles(JNIEnv* env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName) +sumFiles(JNIEnv*, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char*) { size_t* total = (size_t*) arg; size_t uncompLen; @@ -178,7 +180,7 @@ copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntr return INSTALL_FAILED_INVALID_APK; } else { struct tm t; - ZipFileRO::zipTimeToTimespec(when, &t); + ZipUtils::zipTimeToTimespec(when, &t); modTime = mktime(&t); } @@ -200,7 +202,7 @@ copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntr } // Only copy out the native file if it's different. - struct stat st; + struct stat64 st; if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) { return INSTALL_SUCCEEDED; } @@ -273,26 +275,25 @@ iterateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, js ScopedUtfChars cpuAbi(env, javaCpuAbi); ScopedUtfChars cpuAbi2(env, javaCpuAbi2); - ZipFileRO zipFile; - - if (zipFile.open(filePath.c_str()) != NO_ERROR) { + UniquePtr<ZipFileRO> zipFile(ZipFileRO::open(filePath.c_str())); + if (zipFile.get() == NULL) { ALOGI("Couldn't open APK %s\n", filePath.c_str()); return INSTALL_FAILED_INVALID_APK; } - const int N = zipFile.getNumEntries(); - char fileName[PATH_MAX]; bool hasPrimaryAbi = false; - for (int i = 0; i < N; i++) { - const ZipEntryRO entry = zipFile.findEntryByIndex(i); - if (entry == NULL) { - continue; - } + void* cookie = NULL; + if (!zipFile->startIteration(&cookie)) { + ALOGI("Couldn't iterate over APK%s\n", filePath.c_str()); + return INSTALL_FAILED_INVALID_APK; + } + ZipEntryRO entry = NULL; + while ((entry = zipFile->nextEntry(cookie)) != NULL) { // Make sure this entry has a filename. - if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) { + if (zipFile->getEntryFileName(entry, fileName, sizeof(fileName))) { continue; } @@ -346,15 +347,18 @@ iterateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, js && isFilenameSafe(lastSlash + 1)) || !strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) { - install_status_t ret = callFunc(env, callArg, &zipFile, entry, lastSlash + 1); + install_status_t ret = callFunc(env, callArg, zipFile.get(), entry, lastSlash + 1); if (ret != INSTALL_SUCCEEDED) { ALOGV("Failure for entry %s", lastSlash + 1); + zipFile->endIteration(cookie); return ret; } } } + zipFile->endIteration(cookie); + return INSTALL_SUCCEEDED; } diff --git a/core/jni/com_android_internal_net_NetworkStatsFactory.cpp b/core/jni/com_android_internal_net_NetworkStatsFactory.cpp index ec19f0a..0b9ad9b 100644 --- a/core/jni/com_android_internal_net_NetworkStatsFactory.cpp +++ b/core/jni/com_android_internal_net_NetworkStatsFactory.cpp @@ -80,7 +80,7 @@ static int readNetworkStatsDetail(JNIEnv* env, jclass clazz, jobject stats, stats_line s; int64_t rawTag; if (sscanf(buffer, "%d %31s 0x%llx %u %u %llu %llu %llu %llu", &s.idx, - &s.iface, &rawTag, &s.uid, &s.set, &s.rxBytes, &s.rxPackets, + s.iface, &rawTag, &s.uid, &s.set, &s.rxBytes, &s.rxPackets, &s.txBytes, &s.txPackets) == 9) { if (s.idx != lastIdx + 1) { ALOGE("inconsistent idx=%d after lastIdx=%d", s.idx, lastIdx); diff --git a/core/jni/com_android_internal_os_ZygoteInit.cpp b/core/jni/com_android_internal_os_ZygoteInit.cpp index 44452f0..2233ee3 100644 --- a/core/jni/com_android_internal_os_ZygoteInit.cpp +++ b/core/jni/com_android_internal_os_ZygoteInit.cpp @@ -159,29 +159,6 @@ static void com_android_internal_os_ZygoteInit_setCloseOnExec (JNIEnv *env, } } -static jlong com_android_internal_os_ZygoteInit_capgetPermitted (JNIEnv *env, - jobject clazz, jint pid) -{ - struct __user_cap_header_struct capheader; - struct __user_cap_data_struct capdata; - int err; - - memset (&capheader, 0, sizeof(capheader)); - memset (&capdata, 0, sizeof(capdata)); - - capheader.version = _LINUX_CAPABILITY_VERSION; - capheader.pid = pid; - - err = capget (&capheader, &capdata); - - if (err < 0) { - jniThrowIOException(env, errno); - return 0; - } - - return (jlong) capdata.permitted; -} - static jint com_android_internal_os_ZygoteInit_selectReadable ( JNIEnv *env, jobject clazz, jobjectArray fds) { @@ -274,8 +251,6 @@ static JNINativeMethod gMethods[] = { (void *) com_android_internal_os_ZygoteInit_reopenStdio}, { "setCloseOnExec", "(Ljava/io/FileDescriptor;Z)V", (void *) com_android_internal_os_ZygoteInit_setCloseOnExec}, - { "capgetPermitted", "(I)J", - (void *) com_android_internal_os_ZygoteInit_capgetPermitted }, { "selectReadable", "([Ljava/io/FileDescriptor;)I", (void *) com_android_internal_os_ZygoteInit_selectReadable }, { "createFileDescriptor", "(I)Ljava/io/FileDescriptor;", diff --git a/core/jni/com_google_android_gles_jni_EGLImpl.cpp b/core/jni/com_google_android_gles_jni_EGLImpl.cpp index 50b3302..a0982bd 100644 --- a/core/jni/com_google_android_gles_jni_EGLImpl.cpp +++ b/core/jni/com_google_android_gles_jni_EGLImpl.cpp @@ -82,7 +82,7 @@ static void nativeClassInit(JNIEnv *_env, jclass eglImplClass) gSurface_NativePixelRefFieldID = _env->GetFieldID(surface_class, "mNativePixelRef", "I"); jclass bitmap_class = _env->FindClass("android/graphics/Bitmap"); - gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I"); + gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "J"); } static const jint gNull_attrib_base[] = {EGL_NONE}; @@ -276,7 +276,7 @@ static void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_ jint* base = 0; SkBitmap const * nativeBitmap = - (SkBitmap const *)_env->GetIntField(native_pixmap, + (SkBitmap const *)_env->GetLongField(native_pixmap, gBitmap_NativeBitmapFieldID); SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0; if (ref == NULL) { diff --git a/core/jni/com_google_android_gles_jni_GLImpl.cpp b/core/jni/com_google_android_gles_jni_GLImpl.cpp index b0c26c5..b3b0049 100644 --- a/core/jni/com_google_android_gles_jni_GLImpl.cpp +++ b/core/jni/com_google_android_gles_jni_GLImpl.cpp @@ -183,7 +183,7 @@ getDirectBufferPointer(JNIEnv *_env, jobject buffer) { if (array) { releasePointer(_env, array, buf, 0); } - buf = buf + offset; + buf = (char*)buf + offset; } else { jniThrowException(_env, "java/lang/IllegalArgumentException", "Must use a native order direct Buffer"); |