@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

package/android/CMakeLists.txt

@@ -99,10 +99,10 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"
 
-        "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiHostObject.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeLifecycleMonitor.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeAwareCache.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiPromises.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/Promise.cpp"
 
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkManager.cpp"
 
@@ -115,10 +115,7 @@ add_library(
 )
 
 if(SK_GRAPHITE)
-    # WebGPU JSI infrastructure (jsi2)
     target_sources(${PACKAGE_NAME} PRIVATE
-        "${PROJECT_SOURCE_DIR}/../cpp/jsi2/Promise.cpp"
-
         # WebGPU async system
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/AsyncTaskHandle.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/RuntimeContext.cpp"
@@ -181,7 +178,6 @@ target_include_directories(
 
         # WebGPU bindings
         ../cpp
-        ../cpp/jsi2
         ../cpp/rnwgpu
         ../cpp/rnwgpu/api
         ../cpp/rnwgpu/api/descriptors

package/android/cpp/jni/JniWebGPUView.cpp

@@ -2,9 +2,35 @@
 #include <jni.h>
 
 #ifdef SK_GRAPHITE
+#include <memory>
+#include <utility>
+
+#include <ReactCommon/CallInvoker.h>
+
 #include "rnskia/RNDawnContext.h"
 #include "rnwgpu/SurfaceRegistry.h"
+#include "rnwgpu/async/RuntimeContext.h"
 #include "webgpu/webgpu_cpp.h"
+
+namespace {
+// Applies a surface attach latched by the platform UI thread (see
+// SurfaceInfo::applyPendingAttach) from the JS thread. Surface attaches are
+// normally adopted at the next frame boundary by whichever thread renders;
+// this flush covers contexts that are not actively rendering (static
+// content), so the last offscreen frame still makes it on screen. Mirrors
+// react-native-webgpu's RNWebGPUManager::flushPendingSurfaceTransition.
+void flushPendingSurfaceTransition(std::shared_ptr<rnwgpu::SurfaceInfo> info) {
+  if (info == nullptr) {
+    return;
+  }
+  auto invoker = rnwgpu::async::RuntimeContext::mainCallInvoker();
+  if (invoker == nullptr) {
+    return;
+  }
+  invoker->invokeAsync(
+      [info = std::move(info)] { info->applyPendingAttach(); });
+}
+} // namespace
 #endif
 
 extern "C" JNIEXPORT void JNICALL
@@ -12,7 +38,12 @@ Java_com_shopify_reactnative_skia_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
     jfloat height) {
 #ifdef SK_GRAPHITE
+  // ANativeWindow_fromSurface acquires a reference; SurfaceInfo releases it
+  // (via the releaser below) once it is done with the window.
   auto window = ANativeWindow_fromSurface(env, jSurface);
+  if (window == nullptr) {
+    return;
+  }
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto &dawnContext = RNSkia::DawnContext::getInstance();
   auto gpu = dawnContext.getWGPUInstance();
@@ -24,10 +55,17 @@ Java_com_shopify_reactnative_skia_WebGPUView_onSurfaceCreate(
   surfaceDescriptor.nextInChain = &androidSurfaceDesc;
   auto surface = gpu.CreateSurface(&surfaceDescriptor);
 
-  registry
-      .getSurfaceInfoOrCreate(contextId, gpu, static_cast<int>(width),
-                              static_cast<int>(height))
-      ->switchToOnscreen(window, surface);
+  // Find-or-create + attach runs atomically under the registry lock so a
+  // concurrent destroyContext cannot orphan this surface.
+  auto info = registry.attachSurface(
+      contextId, gpu, static_cast<int>(width), static_cast<int>(height), window,
+      surface, [](void *nativeSurface) {
+        ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
+      });
+  // The attach is adopted at the next frame boundary by the rendering thread;
+  // schedule a flush so contexts that are not currently rendering still pick
+  // it up (and present their last offscreen frame).
+  flushPendingSurfaceTransition(info);
 #endif
 }
 
@@ -57,11 +95,18 @@ Java_com_shopify_reactnative_skia_WebGPUView_switchToOffscreenSurface(
 }
 
 extern "C" JNIEXPORT void JNICALL
-Java_com_shopify_reactnative_skia_WebGPUView_onSurfaceDestroy(JNIEnv *env,
-                                                              jobject thiz,
-                                                              jint contextId) {
+Java_com_shopify_reactnative_skia_WebGPUView_onViewDestroyed(JNIEnv *env,
+                                                             jobject thiz,
+                                                             jint contextId) {
 #ifdef SK_GRAPHITE
+  // The view dies with its Canvas (contextIds are never reused), so view
+  // teardown retires the registry entry. The JS-side cleanup
+  // (RNWebGPU.destroyContext) only handles entries that never had a native
+  // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->detachSurface();
+  }
   registry.removeSurfaceInfo(contextId);
 #endif
 }

package/android/src/main/java/com/shopify/reactnative/skia/WebGPUSurfaceView.java

@@ -21,7 +21,9 @@ public class WebGPUSurfaceView extends SurfaceView implements SurfaceHolder.Call
   @Override
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();
-    mApi.surfaceDestroyed();
+    // surfaceDestroyed() normally fires during detach as well; going offscreen
+    // is idempotent, so this is just a safety net for paths where it does not.
+    mApi.surfaceOffscreen();
   }
 
   @Override

package/android/src/main/java/com/shopify/reactnative/skia/WebGPUTextureView.java

@@ -11,6 +11,7 @@ import androidx.annotation.NonNull;
 public class WebGPUTextureView extends TextureView implements TextureView.SurfaceTextureListener {
 
   WebGPUViewAPI mApi;
+  private Surface mSurface;
 
   public WebGPUTextureView(Context context, WebGPUViewAPI api) {
     super(context);
@@ -21,19 +22,24 @@ public class WebGPUTextureView extends TextureView implements TextureView.Surfac
 
   @Override
   public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
-    Surface surface = new Surface(surfaceTexture);
-    mApi.surfaceCreated(surface);
+    mSurface = new Surface(surfaceTexture);
+    mApi.surfaceCreated(mSurface);
   }
 
   @Override
   public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
-    Surface surface = new Surface(surfaceTexture);
-    mApi.surfaceChanged(surface);
+    mApi.surfaceChanged(mSurface);
   }
 
   @Override
   public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
-    mApi.surfaceDestroyed();
+    // Detach first (synchronous through JNI) so the native side has dropped
+    // its window reference before we release ours.
+    mApi.surfaceOffscreen();
+    if (mSurface != null) {
+      mSurface.release();
+      mSurface = null;
+    }
     return true;
   }
 

package/android/src/main/java/com/shopify/reactnative/skia/WebGPUView.java

@@ -61,16 +61,19 @@ public class WebGPUView extends ReactViewGroup implements WebGPUViewAPI {
     onSurfaceChanged(surface, mContextId, width, height);
   }
 
-  @Override
-  public void surfaceDestroyed() {
-    onSurfaceDestroy(mContextId);
-  }
-
   @Override
   public void surfaceOffscreen() {
     switchToOffscreenSurface(mContextId);
   }
 
+  /**
+   * Called from WebGPUViewManager.onDropViewInstance when React removes this
+   * view: the view dies with its Canvas, so it retires the registry entry.
+   */
+  public void destroy() {
+    onViewDestroyed(mContextId);
+  }
+
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
@@ -88,8 +91,8 @@ public class WebGPUView extends ReactViewGroup implements WebGPUViewAPI {
   );
 
   @DoNotStrip
-  private native void onSurfaceDestroy(int contextId);
+  private native void switchToOffscreenSurface(int contextId);
 
   @DoNotStrip
-  private native void switchToOffscreenSurface(int contextId);
+  private native void onViewDestroyed(int contextId);
 }

package/android/src/main/java/com/shopify/reactnative/skia/WebGPUViewAPI.java

@@ -2,13 +2,18 @@ package com.shopify.reactnative.skia;
 
 import android.view.Surface;
 
+/**
+ * Surface lifecycle events a WebGPU child view reports. The registry entry
+ * itself is owned by the JS Canvas component (created lazily, removed via
+ * RNWebGPU.destroyContext on unmount); views only attach and detach surfaces.
+ * A detached context keeps rendering into an offscreen texture whose content
+ * is blitted onto the next attached surface.
+ */
 public interface WebGPUViewAPI {
 
   void surfaceCreated(Surface surface);
 
   void surfaceChanged(Surface surface);
 
-  void surfaceDestroyed();
-
   void surfaceOffscreen();
 }

package/android/src/main/java/com/shopify/reactnative/skia/WebGPUViewManager.java

@@ -53,6 +53,6 @@ public class WebGPUViewManager extends ReactViewManager implements SkiaWebGPUVie
   @Override
   public void onDropViewInstance(@NonNull ReactViewGroup view) {
     super.onDropViewInstance(view);
-    ((WebGPUView) view).surfaceDestroyed();
+    ((WebGPUView) view).destroy();
   }
 }

package/apple/WebGPUMetalView.mm

@@ -5,8 +5,30 @@
 #import "webgpu/webgpu_cpp.h"
 #import <QuartzCore/CAMetalLayer.h>
 
+#import <ReactCommon/CallInvoker.h>
+
 #import "rnskia/RNDawnContext.h"
 #import "rnwgpu/SurfaceRegistry.h"
+#import "rnwgpu/async/RuntimeContext.h"
+
+namespace {
+// Applies a surface attach latched by the platform UI thread (see
+// SurfaceInfo::applyPendingAttach) from the JS thread. Surface attaches are
+// normally adopted at the next frame boundary by whichever thread renders;
+// this flush covers contexts that are not actively rendering (static
+// content), so the last offscreen frame still makes it on screen. Mirrors
+// react-native-webgpu's RNWebGPUManager::flushPendingSurfaceTransition.
+void flushPendingSurfaceTransition(std::shared_ptr<rnwgpu::SurfaceInfo> info) {
+  if (info == nullptr) {
+    return;
+  }
+  auto invoker = rnwgpu::async::RuntimeContext::mainCallInvoker();
+  if (invoker == nullptr) {
+    return;
+  }
+  invoker->invokeAsync([info = std::move(info)] { info->applyPendingAttach(); });
+}
+} // namespace
 
 @implementation WebGPUMetalView {
   BOOL _isConfigured;
@@ -29,7 +51,11 @@
 
 - (void)configure {
   auto size = self.frame.size;
-  void *nativeSurface = (__bridge void *)self.layer;
+  // Retain the layer for as long as SurfaceInfo holds the pointer: the
+  // latched attach (and the flush lambda that adopts it) can outlive this
+  // view, e.g. across a dev reload where the registry is cleared before
+  // dealloc runs. Balanced by the releaser below.
+  void *nativeSurface = (void *)CFBridgingRetain(self.layer);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto &dawnContext = RNSkia::DawnContext::getInstance();
   auto gpu = dawnContext.getWGPUInstance();
@@ -41,10 +67,21 @@
   surfaceDescriptor.nextInChain = &metalSurfaceDesc;
   auto surface = gpu.CreateSurface(&surfaceDescriptor);
 
-  registry
-      .getSurfaceInfoOrCreate([_contextId intValue], gpu, size.width,
-                              size.height)
-      ->switchToOnscreen(nativeSurface, surface);
+  // Find-or-create + attach runs atomically under the registry lock so a
+  // concurrent destroyContext cannot orphan this surface.
+  auto info = registry.attachSurface(
+      [_contextId intValue], gpu, size.width, size.height, nativeSurface,
+      surface, [](void *layer) {
+        // The releaser can run on the rendering thread; CALayer teardown
+        // belongs on the main thread.
+        dispatch_async(dispatch_get_main_queue(), ^{
+          CFBridgingRelease(layer);
+        });
+      });
+  // The attach is adopted at the next frame boundary by the rendering thread;
+  // schedule a flush so contexts that are not currently rendering still pick
+  // it up (and present their last offscreen frame).
+  flushPendingSurfaceTransition(info);
 }
 
 - (void)update {
@@ -57,8 +94,14 @@
 }
 
 - (void)dealloc {
+  // The view dies with its Canvas (contextIds are never reused), so view
+  // teardown retires the registry entry. The JS-side cleanup
+  // (RNWebGPU.destroyContext) only handles entries that never had a native
+  // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-  // Remove the surface info from the registry
+  if (auto info = registry.getSurfaceInfo([_contextId intValue])) {
+    info->detachSurface();
+  }
   registry.removeSurfaceInfo([_contextId intValue]);
 }
 

package/cpp/api/JsiNativeBuffer.h

@@ -6,6 +6,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkImage.h"
+#include "JsiSkNativeObjects.h"
 
 namespace RNSkia {
 
@@ -15,8 +16,11 @@ namespace jsi = facebook::jsi;
  Implementation of the ParagraphBuilderFactory for making ParagraphBuilder JSI
  object
  */
-class JsiNativeBufferFactory : public JsiSkHostObject {
+class JsiNativeBufferFactory
+    : public JsiSkNativeObject<JsiNativeBufferFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "NativeBufferFactory";
+
   JSI_HOST_FUNCTION(MakeFromImage) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
     image->makeNonTextureImage();
@@ -40,18 +44,19 @@ public:
     return jsi::Value::undefined();
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiNativeBufferFactory, Release),
-                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeFromImage),
-                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeTestBuffer))
-
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override {
-    return "JsiNativeBufferFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Release",
+                      &JsiNativeBufferFactory::Release);
+    installHostMethod(runtime, prototype, "MakeFromImage",
+                      &JsiNativeBufferFactory::MakeFromImage);
+    installHostMethod(runtime, prototype, "MakeTestBuffer",
+                      &JsiNativeBufferFactory::MakeTestBuffer);
   }
 
+  size_t getMemoryPressure() override { return 1024; }
+
   explicit JsiNativeBufferFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiNativeBufferFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkAnimatedImage.h

@@ -7,7 +7,7 @@
 #include <string>
 #include <utility>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "api/third_party/base64.h"
 
 #pragma clang diagnostic push
@@ -29,15 +29,16 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkAnimatedImage
-    : public JsiSkWrappingSkPtrHostObject<SkAnimatedImage> {
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkAnimatedImage,
+                                            SkAnimatedImage> {
 public:
+  static constexpr const char *CLASS_NAME = "AnimatedImage";
+
   // TODO-API: Properties?
   JSI_HOST_FUNCTION(getCurrentFrame) {
     auto image = getObject()->getCurrentFrame();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
   JSI_HOST_FUNCTION(getFrameCount) {
@@ -52,21 +53,24 @@ public:
     return static_cast<int>(getObject()->decodeNextFrame());
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkAnimatedImage, AnimatedImage)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkAnimatedImage, dispose),
-                       JSI_EXPORT_FUNC(JsiSkAnimatedImage, getFrameCount),
-                       JSI_EXPORT_FUNC(JsiSkAnimatedImage, getCurrentFrame),
-                       JSI_EXPORT_FUNC(JsiSkAnimatedImage,
-                                       currentFrameDuration),
-                       JSI_EXPORT_FUNC(JsiSkAnimatedImage, decodeNextFrame))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "getFrameCount",
+                      &JsiSkAnimatedImage::getFrameCount);
+    installHostMethod(runtime, prototype, "getCurrentFrame",
+                      &JsiSkAnimatedImage::getCurrentFrame);
+    installHostMethod(runtime, prototype, "currentFrameDuration",
+                      &JsiSkAnimatedImage::currentFrameDuration);
+    installHostMethod(runtime, prototype, "decodeNextFrame",
+                      &JsiSkAnimatedImage::decodeNextFrame);
+  }
 
   JsiSkAnimatedImage(std::shared_ptr<RNSkPlatformContext> context,
                      const sk_sp<SkAnimatedImage> image)
-      : JsiSkWrappingSkPtrHostObject<SkAnimatedImage>(std::move(context),
-                                                      std::move(image)) {}
+      : JsiSkWrappingSkPtrNativeObject<JsiSkAnimatedImage, SkAnimatedImage>(
+            std::move(context), std::move(image)) {}
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     auto animation = getObject();
     if (!animation) {
       return 0;
@@ -131,8 +135,6 @@ public:
 
     return estimated;
   }
-
-  std::string getObjectType() const override { return "JsiSkAnimatedImage"; }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkAnimatedImageFactory.h

@@ -5,17 +5,20 @@
 
 #include <jsi/jsi.h>
 
-#include "jsi/JsiPromises.h"
 #include "JsiSkAnimatedImage.h"
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
+#include "jsi/JsiPromises.h"
 
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkAnimatedImageFactory : public JsiSkHostObject {
+class JsiSkAnimatedImageFactory
+    : public JsiSkNativeObject<JsiSkAnimatedImageFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "AnimatedImageFactory";
+
   JSI_HOST_FUNCTION(MakeAnimatedImageFromEncoded) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
     auto codec = SkAndroidCodec::MakeFromData(data);
@@ -23,24 +26,20 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkAnimatedImage>(getContext(), std::move(image));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkAnimatedImage>(
+                                      getContext(), std::move(image)));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override {
-    return "JsiSkAnimatedImageFactory";
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeAnimatedImageFromEncoded",
+                      &JsiSkAnimatedImageFactory::MakeAnimatedImageFromEncoded);
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkAnimatedImageFactory,
-                                       MakeAnimatedImageFromEncoded))
-
   explicit JsiSkAnimatedImageFactory(
       std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkAnimatedImageFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia