Fix invalid bindings (#638)

skiko/src/commonMain/kotlin/org/jetbrains/skia/Bitmap.kt

@@ -204,7 +204,7 @@ class Bitmap internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerH
      *
      * @return  size in bytes of image buffer
      */
-    fun computeByteSize(): NativePointer {
+    fun computeByteSize(): Int {
         return try {
             Stats.onNativeCall()
             _nComputeByteSize(_ptr)
@@ -1083,7 +1083,7 @@ private external fun _nGetRowBytes(ptr: NativePointer): Int
 private external fun _nSetAlphaType(ptr: NativePointer, alphaType: Int): Boolean
 
 @ExternalSymbolName("org_jetbrains_skia_Bitmap__1nComputeByteSize")
-private external fun _nComputeByteSize(ptr: NativePointer): NativePointer
+private external fun _nComputeByteSize(ptr: NativePointer): Int
 
 @ExternalSymbolName("org_jetbrains_skia_Bitmap__1nIsImmutable")
 private external fun _nIsImmutable(ptr: NativePointer): Boolean

skiko/src/commonMain/kotlin/org/jetbrains/skia/BreakIterator.kt

 package org.jetbrains.skia
 
-import org.jetbrains.skia.impl.InteropPointer
+import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.InteropScope
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
-import org.jetbrains.skia.impl.Managed
 import org.jetbrains.skia.impl.Native.Companion.NullPointer
-import org.jetbrains.skia.impl.NativePointer
-import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.interopScope
 import org.jetbrains.skia.impl.reachabilityBarrier
+import org.jetbrains.skia.impl.withResult
 
 /**
  *
@@ -496,7 +494,10 @@ class BreakIterator internal constructor(ptr: NativePointer) : Managed(ptr, _Fin
     val ruleStatuses: IntArray
         get() = try {
             Stats.onNativeCall()
-            _nGetRuleStatuses(_ptr)
+            val arrayLen = _nGetRuleStatusesLen(_ptr)
+            withResult(IntArray(arrayLen)) { result ->
+                _nGetRuleStatuses(_ptr, result, arrayLen)
+            }
         } finally {
             reachabilityBarrier(this)
         }
@@ -579,8 +580,11 @@ private external fun _nIsBoundary(ptr: NativePointer, offset: Int): Boolean
 @ExternalSymbolName("org_jetbrains_skia_BreakIterator__1nGetRuleStatus")
 private external fun _nGetRuleStatus(ptr: NativePointer): Int
 
+@ExternalSymbolName("org_jetbrains_skia_BreakIterator__1nGetRuleStatusesLen")
+private external fun _nGetRuleStatusesLen(ptr: NativePointer): Int
+
 @ExternalSymbolName("org_jetbrains_skia_BreakIterator__1nGetRuleStatuses")
-private external fun _nGetRuleStatuses(ptr: NativePointer): IntArray
+private external fun _nGetRuleStatuses(ptr: NativePointer, result: InteropPointer, len: Int)
 
 @ExternalSymbolName("org_jetbrains_skia_BreakIterator__1nSetText")
-private external fun _nSetText(ptr: NativePointer, textStr: InteropPointer, len: Int, errorCode: InteropPointer): NativePointer
+private external fun _nSetText(ptr: NativePointer, textStr: InteropPointer, len: Int, errorCode: InteropPointer): NativePointer
\ No newline at end of file

skiko/src/commonMain/kotlin/org/jetbrains/skia/Codec.kt

@@ -57,7 +57,7 @@ class Codec internal constructor(ptr: NativePointer) : Managed(ptr, _FinalizerHo
     val size: IPoint
         get() = try {
             Stats.onNativeCall()
-            toIPoint(_nGetSize(_ptr))
+            IPoint(_nGetSizeWidth(_ptr), _nGetSizeHeight(_ptr))
         } finally {
             reachabilityBarrier(this)
         }
@@ -372,8 +372,11 @@ private external fun Codec_nReadPixels(ptr: NativePointer, bitmapPtr: NativePoin
 @ExternalSymbolName("org_jetbrains_skia_Codec__1nMakeFromData")
 private external fun _nMakeFromData(dataPtr: NativePointer): NativePointer
 
-@ExternalSymbolName("org_jetbrains_skia_Codec__1nGetSize")
-private external fun _nGetSize(ptr: NativePointer): Long
+@ExternalSymbolName("org_jetbrains_skia_Codec__1nGetSizeWidth")
+private external fun _nGetSizeWidth(ptr: NativePointer): Int
+
+@ExternalSymbolName("org_jetbrains_skia_Codec__1nGetSizeHeight")
+private external fun _nGetSizeHeight(ptr: NativePointer): Int
 
 @ExternalSymbolName("org_jetbrains_skia_Codec__1nGetEncodedOrigin")
 private external fun _nGetEncodedOrigin(ptr: NativePointer): Int

skiko/src/commonMain/kotlin/org/jetbrains/skia/paragraph/TypefaceFontProvider.kt

@@ -45,4 +45,4 @@ class TypefaceFontProvider : FontMgr(TypefaceFontProvider_nMake()) {
 private external fun TypefaceFontProvider_nMake(): NativePointer
 
 @ExternalSymbolName("org_jetbrains_skia_paragraph_TypefaceFontProvider__1nRegisterTypeface")
-private external fun _nRegisterTypeface(ptr: NativePointer, typefacePtr: NativePointer, alias: InteropPointer): NativePointer
+private external fun _nRegisterTypeface(ptr: NativePointer, typefacePtr: NativePointer, alias: InteropPointer)

skiko/src/commonTest/kotlin/org/jetbrains/skia/BitmapTest.kt

@@ -40,6 +40,8 @@ class BitmapTest {
         assertFalse(bitmap.isNull)
         assertTrue(bitmap.isReadyToDraw)
 
+        assertEquals(84, bitmap.computeByteSize())
+
         bitmap.generationId
     }
 

skiko/src/commonTest/kotlin/org/jetbrains/skia/BreakIteratorTests.kt

@@ -66,4 +66,13 @@ class BreakIteratorTests {
 
         assertContentEquals(listOf(167, 287), boundary.asSequence().toList())
     }
+
+    @Test
+    fun breakRuleStatusesTest() {
+        val boundary = BreakIterator.makeWordInstance()
+        boundary.setText("Hello world!")
+        boundary.next()
+        assertEquals(boundary.ruleStatus, 200)
+        assertContentEquals(listOf(200), boundary.ruleStatuses.toList())
+    }
 }
\ No newline at end of file

skiko/src/commonTest/kotlin/org/jetbrains/skia/CodecTest.kt

@@ -15,6 +15,8 @@ class CodecTest {
         assertEquals(1, codec.frameCount)
         assertEquals(8, codec.imageInfo.width)
         assertEquals(8, codec.imageInfo.height)
+        assertEquals(8, codec.size.x)
+        assertEquals(8, codec.size.y)
         assertEquals(EncodedImageFormat.PNG, codec.encodedImageFormat)
 
         val pixels = codec.readPixels()
@@ -27,6 +29,8 @@ class CodecTest {
         assertEquals(5, codec.frameCount)
         assertEquals(8, codec.imageInfo.width)
         assertEquals(8, codec.imageInfo.height)
+        assertEquals(8, codec.size.x)
+        assertEquals(8, codec.size.y)
         assertEquals(EncodedImageFormat.GIF, codec.encodedImageFormat)
 
         val palette = intArrayOf(Color.BLACK, Color.RED, Color.GREEN, Color.BLUE, Color.WHITE)

skiko/src/jvmMain/cpp/common/BreakIterator.cc

@@ -95,18 +95,25 @@ extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skia_BreakIteratorKt__1nGet
     return ubrk_getRuleStatus(instance);
 }
 
-extern "C" JNIEXPORT jintArray JNICALL Java_org_jetbrains_skia_BreakIteratorKt__1nGetRuleStatuses
+extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skia_BreakIteratorKt__1nGetRuleStatusesLen
   (JNIEnv* env, jclass jclass, jlong ptr) {
     UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
     UErrorCode status = U_ZERO_ERROR;
     int32_t len = ubrk_getRuleStatusVec(instance, nullptr, 0, &status);
-    if (U_FAILURE(status))
+    if (status != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(status))
       env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
-    std::vector<jint> vec(len);
-    ubrk_getRuleStatusVec(instance, reinterpret_cast<int32_t*>(vec.data()), len, &status);
+    return len;
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_BreakIteratorKt__1nGetRuleStatuses
+  (JNIEnv* env, jclass jclass, jlong ptr, jintArray result, jint len) {
+    UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
+    UErrorCode status = U_ZERO_ERROR;
+    std::vector<jint> statuses(len);
+    ubrk_getRuleStatusVec(instance, reinterpret_cast<int32_t*>(statuses.data()), len, &status);
     if (U_FAILURE(status))
       env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
-    return javaIntArray(env, vec);
+    env->SetIntArrayRegion(result, 0, len, statuses.data());
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_BreakIteratorKt__1nSetText

skiko/src/jvmMain/cpp/common/Codec.cc

@@ -27,10 +27,16 @@ extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skia_CodecKt_Codec_1nGetIma
     skija::ImageInfo::writeImageInfoForInterop(env, imageInfo, imageInfoResult, colorSpaceResultPtr);
 }
 
-extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_CodecKt__1nGetSize
+extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skia_CodecKt__1nGetSizeWidth
   (JNIEnv* env, jclass jclass, jlong ptr) {
     SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
-    return packISize(instance->dimensions());
+    return instance->dimensions().fWidth;
+}
+
+extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skia_CodecKt__1nGetSizeHeight
+  (JNIEnv* env, jclass jclass, jlong ptr) {
+    SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
+    return instance->dimensions().fHeight;
 }
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_CodecKt__1nGetEncodedOrigin

skiko/src/nativeJsMain/cpp/BreakIterator.cc

@@ -98,23 +98,22 @@ SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nGetRuleStatus
 }
 
 
-
-#if 0
-SKIKO_EXPORT KInt* org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
+SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nGetRuleStatusesLen
   (KNativePointer ptr) {
     UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(ptr);
     UErrorCode status = U_ZERO_ERROR;
     int32_t len = ubrk_getRuleStatusVec(instance, nullptr, 0, &status);
-    if (U_FAILURE(status))
-      env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
-    std::vector<KInt> vec(len);
-    ubrk_getRuleStatusVec(instance, reinterpret_cast<int32_t*>(vec.data()), len, &status);
-    if (U_FAILURE(status))
-      env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
-    return javaIntArray(env, vec);
+    SKIKO_ASSERT(status == U_BUFFER_OVERFLOW_ERROR || !U_FAILURE(status), "Failed to get rule statuses");
+    return len;
 }
-#endif
 
+SKIKO_EXPORT void org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
+  (KNativePointer ptr, KInteropPointer result, KInt len) {
+    UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(ptr);
+    UErrorCode status = U_ZERO_ERROR;
+    ubrk_getRuleStatusVec(instance, reinterpret_cast<int32_t*>(result), len, &status);
+    SKIKO_ASSERT(!U_FAILURE(status), "Failed to get rule statuses");
+}
 
 SKIKO_EXPORT KNativePointer org_jetbrains_skia_BreakIterator__1nSetText
   (KNativePointer ptr, KChar* textArr, KInt len, KInt* errorCode) {
@@ -125,4 +124,4 @@ SKIKO_EXPORT KNativePointer org_jetbrains_skia_BreakIterator__1nSetText
     ubrk_setText(instance, text->data(), len, &status);
     errorCode[0] = status;
     return reinterpret_cast<KNativePointer>(text);
-}
+}
\ No newline at end of file

skiko/src/nativeJsMain/cpp/Codec.cc

@@ -26,10 +26,16 @@ SKIKO_EXPORT void org_jetbrains_skia_Codec__1nGetImageInfo
     skija::ImageInfo::writeImageInfoForInterop(imageInfo, imageInfoResult, colorSpacePtrsArray);
 }
 
-SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetSize
+SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetSizeWidth
   (KNativePointer ptr) {
     SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
-    return packISize(instance->dimensions());
+    return instance->dimensions().fWidth;
+}
+
+SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetSizeHeight
+  (KNativePointer ptr) {
+    SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
+    return instance->dimensions().fHeight;
 }
 
 SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetEncodedOrigin
@@ -99,4 +105,4 @@ SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetRepetitionCount
   (KNativePointer ptr) {
     SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
     return instance->getRepetitionCount();
-}
+}
\ No newline at end of file