react-native-skia 3.0.3 → 3.0.5

package/android/CMakeLists.txt

@@ -60,8 +60,6 @@ add_library(
 
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidCanvasProvider.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"
 
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JSICache.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiPromises.cpp"

package/android/build.gradle

@@ -147,7 +147,7 @@ logger.warn("react-native-skia: buildDir: ${buildDir}")
 logger.warn("react-native-skia: node_modules: ${nodeModules}")
 
 android {
-    namespace "com.reactnative.skia"
+    namespace = "com.reactnative.skia"
 
     compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
     buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
@@ -155,10 +155,10 @@ android {
     // Used to override the NDK path/version on internal CI or by allowing
     // users to customize the NDK path/version from their root project.
     if (rootProject.hasProperty("ndkPath")) {
-        ndkPath rootProject.ext.ndkPath
+        ndkPath = rootProject.ext.ndkPath
     }
     if (rootProject.hasProperty("ndkVersion")) {
-        ndkVersion rootProject.ext.ndkVersion
+        ndkVersion = rootProject.ext.ndkVersion
     }
 
     defaultConfig {
@@ -181,8 +181,15 @@ android {
             }
         }
     }
+    // The Java sources use switch expressions (Java 14+). React Native's Gradle
+    // plugin aligns every module on 17 from the app's plugin block, but a host
+    // that opts out of that alignment must still compile this library.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
     lintOptions {
-        abortOnError false
+        abortOnError = false
     }
 
     publishing {
@@ -214,12 +221,12 @@ android {
     }
 
     buildFeatures {
-        prefab true
-        prefabPublishing true
+        prefab = true
+        prefabPublishing = true
     }
     prefab {
         rnskia {
-            headers "${project.buildDir}/headers/rnskia/"
+            headers = "${project.buildDir}/headers/rnskia/"
         }
     }
 }
@@ -238,6 +245,7 @@ repositories {
 dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
+    testImplementation 'junit:junit:4.13.2'
 }
 
 // Package all the cpp code in a flattened directory structure

package/android/cpp/jni/JniPlatformContext.cpp

@@ -73,30 +73,6 @@ TSelf JniPlatformContext::initHybrid(jni::alias_ref<jhybridobject> jThis,
   return makeCxxInstance(jThis, pixelDensity);
 }
 
-jni::global_ref<jobject>
-JniPlatformContext::createVideo(const std::string &url) {
-  jni::Environment::ensureCurrentThreadIsAttached();
-
-  jni::ThreadScope ts; // Manages JNI thread attachment/detachment
-
-  // Get the JNI environment
-  JNIEnv *env = facebook::jni::Environment::current();
-
-  // Convert std::string to jstring
-  jstring jUrl = env->NewStringUTF(url.c_str());
-
-  static auto method =
-      javaPart_->getClass()->getMethod<jobject(jstring)>("createVideo");
-
-  // Call the method and receive a local reference to the video object
-  auto videoObject = method(javaPart_.get(), jUrl);
-  env->DeleteLocalRef(jUrl);
-
-  // Clean up the jstring local reference
-  auto result = jni::make_global(videoObject);
-  return result;
-}
-
 sk_sp<SkImage> JniPlatformContext::takeScreenshotFromViewTag(size_t tag) {
   // Call the java method for creating a view screenshot as a bitmap:
   auto env = jni::Environment::current();

package/android/cpp/jni/include/JniPlatformContext.h

@@ -44,8 +44,6 @@ public:
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag);
 
-  jni::global_ref<jobject> createVideo(const std::string &url);
-
 private:
   friend HybridBase;
   jni::global_ref<JniPlatformContext::javaobject> javaPart_;

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -1,10 +1,5 @@
 #pragma once
 
-#if __ANDROID_API__ >= 26
-#include <android/hardware_buffer.h>
-#endif
-#include <algorithm>
-#include <cstdint>
 #include <exception>
 #include <functional>
 #include <memory>
@@ -12,9 +7,7 @@
 
 #include "RNDawnContext.h"
 
-#include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
-#include "RNSkAndroidVideo.h"
 #include "RNSkPlatformContext.h"
 
 #pragma clang diagnostic push
@@ -54,139 +47,6 @@ public:
                                                     useP3ColorSpace);
   }
 
-  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
-    return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-  }
-
-  std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
-    auto jniVideo = _jniPlatformContext->createVideo(url);
-    return std::make_shared<RNSkAndroidVideo>(jniVideo);
-  }
-
-  void releaseNativeBuffer(uint64_t pointer) override {
-#if __ANDROID_API__ >= 26
-    auto *buffer = reinterpret_cast<AHardwareBuffer *>(pointer);
-    AHardwareBuffer_release(buffer);
-#endif
-  }
-
-  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
-#if __ANDROID_API__ >= 26
-    // A Graphite GPU texture can't be read with readPixels(nullptr); read it
-    // back to a raster image first or the buffer ends up uninitialized/black.
-    if (image && image->isTextureBacked()) {
-      image = DawnContext::getInstance().MakeRasterImage(image);
-    }
-    auto bytesPerPixel = image->imageInfo().bytesPerPixel();
-    int bytesPerRow = image->width() * bytesPerPixel;
-    auto buf = SkData::MakeUninitialized(image->width() * image->height() *
-                                         bytesPerPixel);
-    SkImageInfo info =
-        SkImageInfo::Make(image->width(), image->height(), image->colorType(),
-                          image->alphaType());
-    image->readPixels(nullptr, info, const_cast<void *>(buf->data()),
-                      bytesPerRow, 0, 0);
-    const void *pixelData = buf->data();
-
-    // Define the buffer description
-    AHardwareBuffer_Desc desc = {};
-    // TODO: use image info here
-    desc.width = image->width();
-    desc.height = image->height();
-    desc.layers = 1; // Single image layer
-    desc.format = GetBufferFormatFromSkColorType(
-        image->colorType()); // Assuming the image
-                             // is in this format
-    desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-                 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-                 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
-                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-    desc.stride = bytesPerRow; // Stride in pixels, not in bytes
-
-    // Allocate the buffer
-    AHardwareBuffer *buffer = nullptr;
-    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
-      // Handle allocation failure
-      return 0;
-    }
-
-    // Map the buffer to gain access to its memory
-    void *mappedBuffer = nullptr;
-    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1,
-                         nullptr, &mappedBuffer);
-    if (mappedBuffer == nullptr) {
-      // Handle mapping failure
-      AHardwareBuffer_release(buffer);
-      return 0;
-    }
-
-    // Copy the image data to the buffer
-    memcpy(mappedBuffer, pixelData, desc.height * bytesPerRow);
-
-    // Unmap the buffer
-    AHardwareBuffer_unlock(buffer, nullptr);
-
-    // Return the buffer pointer as a uint64_t. It's the caller's responsibility
-    // to manage this buffer.
-    return reinterpret_cast<uint64_t>(buffer);
-#else
-    return 0;
-#endif
-  }
-
-  uint64_t makeTestNativeBuffer(int width, int height) override {
-#if __ANDROID_API__ >= 26
-    // Allocate an RGBA8 AHardwareBuffer and fill it with a procedural test
-    // pattern (RGB gradient + diagonal stripes), entirely on the CPU. We read
-    // the buffer's actual row stride after locking (the allocator may pad it),
-    // so the upload is correct regardless of width alignment.
-    AHardwareBuffer_Desc desc = {};
-    desc.width = static_cast<uint32_t>(width);
-    desc.height = static_cast<uint32_t>(height);
-    desc.layers = 1;
-    desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
-    desc.usage = AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY |
-                 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY |
-                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-
-    AHardwareBuffer *buffer = nullptr;
-    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
-      return 0;
-    }
-
-    AHardwareBuffer_Desc allocated = {};
-    AHardwareBuffer_describe(buffer, &allocated);
-    const size_t rowBytes = static_cast<size_t>(allocated.stride) * 4;
-
-    void *mappedBuffer = nullptr;
-    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY, -1,
-                         nullptr, &mappedBuffer);
-    if (mappedBuffer == nullptr) {
-      AHardwareBuffer_release(buffer);
-      return 0;
-    }
-
-    auto *base = static_cast<uint8_t *>(mappedBuffer);
-    for (int y = 0; y < height; ++y) {
-      uint8_t *row = base + y * rowBytes;
-      for (int x = 0; x < width; ++x) {
-        uint8_t r = static_cast<uint8_t>((x * 255) / std::max(width - 1, 1));
-        uint8_t g = static_cast<uint8_t>((y * 255) / std::max(height - 1, 1));
-        uint8_t b = static_cast<uint8_t>(((x + y) & 0x20) ? 220 : 30);
-        row[x * 4 + 0] = r; // RGBA byte order
-        row[x * 4 + 1] = g;
-        row[x * 4 + 2] = b;
-        row[x * 4 + 3] = 0xFF;
-      }
-    }
-
-    AHardwareBuffer_unlock(buffer, nullptr);
-    return reinterpret_cast<uint64_t>(buffer);
-#else
-    return 0;
-#endif
-  }
-
   sk_sp<SkFontMgr> createFontMgr() override {
     return SkFontMgr_New_Android(nullptr, SkFontScanner_Make_FreeType());
   }

package/android/src/main/java/com/reactnative/skia/BackingViewKind.java

@@ -0,0 +1,24 @@
+package com.reactnative.skia;
+
+import androidx.annotation.Nullable;
+
+/** The Android view a SkiaView draws into, see SkiaView.updateView(). */
+enum BackingViewKind {
+    SURFACE_VIEW,
+    TEXTURE_VIEW;
+
+    /**
+     * The kind the androidSurfaceType prop asks for, or null for "auto", which
+     * leaves the choice to the opaque prop.
+     */
+    @Nullable
+    static BackingViewKind fromSurfaceType(@Nullable String surfaceType) {
+        if ("SurfaceView".equals(surfaceType)) {
+            return SURFACE_VIEW;
+        }
+        if ("TextureView".equals(surfaceType)) {
+            return TEXTURE_VIEW;
+        }
+        return null;
+    }
+}

package/android/src/main/java/com/reactnative/skia/FrameScheduler.java

@@ -0,0 +1,104 @@
+package com.reactnative.skia;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Decides when a SkiaView presents the recordings queued for it: a SurfaceView
+ * on the next vsync, a TextureView behind the draw its window has pending, so
+ * that the window has taken the previous frame by then. Keeps at most one
+ * frame callback and one posted present outstanding. Main thread.
+ */
+final class FrameScheduler {
+    /** What the scheduler asks of the view. */
+    interface Host {
+        /** Calls onFrame() on the next Choreographer frame. */
+        void postFrameCallback();
+
+        /** Calls onPosted() from the main looper, behind any draw the window has pending. */
+        void postBehindPendingDraw();
+
+        /** Presents the queued recordings, returning whether any are left. */
+        boolean presentFrame();
+    }
+
+    private final Host mHost;
+    private boolean mFrameCallbackPosted = false;
+    private boolean mPresentPosted = false;
+
+    FrameScheduler(Host host) {
+        mHost = host;
+    }
+
+    /** A recording was submitted. Without a backing view there is no surface to present on yet. */
+    void requestFrame(@Nullable BackingViewKind kind) {
+        if (kind == null) {
+            return;
+        }
+        // A frame callback still outstanding (a retry, see presentOrRetry) presents
+        // the new recording along with the leftovers on that vsync.
+        if (mFrameCallbackPosted) {
+            return;
+        }
+        if (presentsOnVsync(kind)) {
+            postFrameCallback();
+        } else {
+            postBehindPendingDraw();
+        }
+    }
+
+    /** The Choreographer frame asked for with Host.postFrameCallback(). */
+    void onFrame(@Nullable BackingViewKind kind) {
+        mFrameCallbackPosted = false;
+        if (kind == null) {
+            return;
+        }
+        if (presentsOnVsync(kind)) {
+            presentOrRetry();
+        } else {
+            postBehindPendingDraw();
+        }
+    }
+
+    /** The message posted with Host.postBehindPendingDraw(). */
+    void onPosted() {
+        mPresentPosted = false;
+        presentOrRetry();
+    }
+
+    /** The view left its window, and the host removed both callbacks. */
+    void cancel() {
+        mFrameCallbackPosted = false;
+        mPresentPosted = false;
+    }
+
+    // The compositor takes a SurfaceView's buffer at the vsync. A TextureView's frame
+    // shows when its window draws, and its buffer queue replaces a frame not drawn yet.
+    private static boolean presentsOnVsync(BackingViewKind kind) {
+        return switch (kind) {
+            case SURFACE_VIEW -> true;
+            case TEXTURE_VIEW -> false;
+        };
+    }
+
+    // Recordings left over (the present failed, or more were submitted meanwhile)
+    // are tried again on the next vsync, never straight away.
+    private void presentOrRetry() {
+        if (mHost.presentFrame()) {
+            postFrameCallback();
+        }
+    }
+
+    private void postFrameCallback() {
+        if (!mFrameCallbackPosted) {
+            mFrameCallbackPosted = true;
+            mHost.postFrameCallback();
+        }
+    }
+
+    private void postBehindPendingDraw() {
+        if (!mPresentPosted) {
+            mPresentPosted = true;
+            mHost.postBehindPendingDraw();
+        }
+    }
+}

package/android/src/main/java/com/reactnative/skia/PlatformContext.java

@@ -32,11 +32,6 @@ public class PlatformContext {
         mHybridData = initHybrid(reactContext.getResources().getDisplayMetrics().density);
     }
 
-    @DoNotStrip
-    public Object createVideo(String url) {
-        return new RNSkVideo(mContext, url);
-    }
-
     private byte[] getStreamAsBytes(InputStream is) throws IOException {
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
         int nRead;

package/android/src/main/java/com/reactnative/skia/SkiaView.java

@@ -8,6 +8,8 @@ import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.View;
 
+import androidx.annotation.Nullable;
+
 import com.facebook.jni.HybridData;
 import com.facebook.jni.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactContext;
@@ -17,14 +19,10 @@ import com.facebook.react.views.view.ReactViewGroup;
 /**
  * The Android view behind <Canvas>, <SkiaPictureView> and <SkiaGraphiteView>.
  * It is backed by a SurfaceView or a TextureView (see updateView()) that the
- * native side draws into with Graphite, presenting the queued recordings on
- * the Choreographer.
+ * native side draws into with Graphite, presenting the queued recordings when
+ * the backing view can show them (see FrameScheduler).
  */
 public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreographer.FrameCallback {
-    // Backing view kinds, see updateView().
-    private static final int KIND_SURFACE_VIEW = 0;
-    private static final int KIND_TEXTURE_VIEW = 1;
-
     private static final String TAG = "SkiaView";
 
     @DoNotStrip
@@ -32,18 +30,36 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
 
     private View mView;
 
-    // Props, applied together in updateView().
+    // Props, applied together in updateView(). A null kind is "auto".
     private boolean mOpaque = false;
-    private String mSurfaceType = "auto";
+    @Nullable
+    private BackingViewKind mRequestedKind = null;
     private boolean mZOrderOnTop = false;
     private boolean mHighBitDepth = false;
 
-    // What the current backing view was created with.
-    private int mAppliedKind = -1;
+    // What the current backing view was created with; no kind before the first one.
+    @Nullable
+    private BackingViewKind mAppliedKind = null;
     private boolean mAppliedZOrderOnTop;
     private boolean mAppliedHighBitDepth;
 
-    private boolean mFramePending = false;
+    private final Runnable mPostedPresent = this::onPostedPresent;
+    private final FrameScheduler mFrameScheduler = new FrameScheduler(new FrameScheduler.Host() {
+        @Override
+        public void postFrameCallback() {
+            Choreographer.getInstance().postFrameCallback(SkiaView.this);
+        }
+
+        @Override
+        public void postBehindPendingDraw() {
+            post(mPostedPresent);
+        }
+
+        @Override
+        public boolean presentFrame() {
+            return SkiaView.this.presentFrame();
+        }
+    });
 
     public SkiaView(Context context) {
         super(context);
@@ -65,8 +81,8 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
         mOpaque = value;
     }
 
-    public void setSurfaceType(String value) {
-        mSurfaceType = value == null ? "auto" : value;
+    public void setSurfaceType(@Nullable String value) {
+        mRequestedKind = BackingViewKind.fromSurfaceType(value);
     }
 
     public void setZOrderOnTop(boolean value) {
@@ -79,25 +95,22 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
 
     // Resolve the backing view from the props. "auto" picks SurfaceView for an
     // opaque canvas and TextureView for a non-opaque one.
-    private int resolveKind() {
-        if ("SurfaceView".equals(mSurfaceType)) {
-            return KIND_SURFACE_VIEW;
+    private BackingViewKind resolveKind() {
+        if (mRequestedKind != null) {
+            return mRequestedKind;
         }
-        if ("TextureView".equals(mSurfaceType)) {
-            return KIND_TEXTURE_VIEW;
-        }
-        return mOpaque ? KIND_SURFACE_VIEW : KIND_TEXTURE_VIEW;
+        return mOpaque ? BackingViewKind.SURFACE_VIEW : BackingViewKind.TEXTURE_VIEW;
     }
 
     // The 10-bit buffer format only has 2 bits of alpha, which would visibly
     // break translucency, and the extra precision would be lost in the 8-bit
     // composition pass of a TextureView anyway. So the flag only applies to an
     // opaque SurfaceView.
-    private boolean resolveHighBitDepth(int kind) {
+    private boolean resolveHighBitDepth(BackingViewKind kind) {
         if (!mHighBitDepth) {
             return false;
         }
-        if (kind != KIND_SURFACE_VIEW || !mOpaque) {
+        if (kind != BackingViewKind.SURFACE_VIEW || !mOpaque) {
             Log.w(TAG, "highBitDepth requires an opaque SurfaceView on Android, falling back to the 8-bit format");
             return false;
         }
@@ -109,8 +122,8 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
     // it attaches (zOrderOnTop, the buffer format), replaces the child; opacity
     // is applied in place.
     void updateView() {
-        int kind = resolveKind();
-        boolean zOrderOnTop = kind == KIND_SURFACE_VIEW && mZOrderOnTop;
+        BackingViewKind kind = resolveKind();
+        boolean zOrderOnTop = kind == BackingViewKind.SURFACE_VIEW && mZOrderOnTop;
         boolean highBitDepth = resolveHighBitDepth(kind);
         if (mView == null
                 || kind != mAppliedKind
@@ -122,9 +135,10 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
             mAppliedKind = kind;
             mAppliedZOrderOnTop = zOrderOnTop;
             mAppliedHighBitDepth = highBitDepth;
-            mView = kind == KIND_SURFACE_VIEW
-                    ? new SkiaSurfaceView(getContext(), this, zOrderOnTop, mOpaque)
-                    : new SkiaTextureView(getContext(), this, mOpaque);
+            mView = switch (kind) {
+                case SURFACE_VIEW -> new SkiaSurfaceView(getContext(), this, zOrderOnTop, mOpaque);
+                case TEXTURE_VIEW -> new SkiaTextureView(getContext(), this, mOpaque);
+            };
             addView(mView);
             // React Native sizes native children explicitly through onLayout, so
             // the requestLayout triggered by addView is ignored; size the new
@@ -132,10 +146,11 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
             if (getWidth() > 0 || getHeight() > 0) {
                 mView.layout(0, 0, getWidth(), getHeight());
             }
-        } else if (kind == KIND_SURFACE_VIEW) {
-            ((SkiaSurfaceView) mView).setOpaque(mOpaque);
         } else {
-            ((SkiaTextureView) mView).setOpaque(mOpaque);
+            switch (kind) {
+                case SURFACE_VIEW -> ((SkiaSurfaceView) mView).setOpaque(mOpaque);
+                case TEXTURE_VIEW -> ((SkiaTextureView) mView).setOpaque(mOpaque);
+            }
         }
     }
 
@@ -157,31 +172,27 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
 
     // Frames --------------------------------------------------------------
 
-    /**
-     * Presents the queued recordings on the next vsync. Main thread; called
-     * from native when a recording is submitted.
-     */
+    /** A recording was submitted. Main thread; called from native. */
     @DoNotStrip
     public void scheduleFrame() {
-        if (!mFramePending) {
-            mFramePending = true;
-            Choreographer.getInstance().postFrameCallback(this);
-        }
+        mFrameScheduler.requestFrame(mAppliedKind);
     }
 
     @Override
     public void doFrame(long frameTimeNanos) {
-        mFramePending = false;
-        if (presentFrame()) {
-            scheduleFrame();
-        }
+        mFrameScheduler.onFrame(mAppliedKind);
+    }
+
+    private void onPostedPresent() {
+        mFrameScheduler.onPosted();
     }
 
     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
         Choreographer.getInstance().removeFrameCallback(this);
-        mFramePending = false;
+        removeCallbacks(mPostedPresent);
+        mFrameScheduler.cancel();
     }
 
     @Override
@@ -242,6 +253,6 @@ public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreograph
 
     private native void unregisterView();
 
-    /** Choreographer tick: returns whether more recordings are waiting. */
+    /** Presents the queued recordings, returning whether any are left. */
     private native boolean presentFrame();
 }