@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/api/JsiSkApi.h

@@ -4,12 +4,10 @@
 
 #include "rnskia/RNSkPlatformContext.h"
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#include "rnwgpu/api/GPUDevice.h"
-#include "rnwgpu/async/RuntimeContext.h"
 #endif
 
 #include "JsiNativeBuffer.h"
@@ -67,11 +65,11 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkApi : public JsiSkHostObject {
+class JsiSkApi : public JsiSkNativeObject<JsiSkApi> {
 public:
-  size_t getMemoryPressure() const override { return 8192; }
+  static constexpr const char *CLASS_NAME = "Api";
 
-  std::string getObjectType() const override { return "JsiSkApi"; }
+  size_t getMemoryPressure() override { return 8192; }
 
   /**
    * Constructs the Skia Api object that can be installed into a runtime
@@ -79,104 +77,264 @@ public:
    * @param context Platform context
    */
   explicit JsiSkApi(const std::shared_ptr<RNSkPlatformContext> &context)
-      : JsiSkHostObject(context) {
+      : JsiSkNativeObject<JsiSkApi>(context),
+        _svgFactory(std::make_shared<JsiSkSVGFactory>(context)),
+        _imageFactory(std::make_shared<JsiSkImageFactory>(context)),
+        _animatedImageFactory(
+            std::make_shared<JsiSkAnimatedImageFactory>(context)),
+        _typefaceFactory(std::make_shared<JsiSkTypefaceFactory>(context)),
+        _dataFactory(std::make_shared<JsiSkDataFactory>(context)),
+        _imageFilterFactory(std::make_shared<JsiSkImageFilterFactory>(context)),
+        _pathEffectFactory(std::make_shared<JsiSkPathEffectFactory>(context)),
+        _pathFactory(std::make_shared<JsiSkPathFactory>(context)),
+        _pathBuilderFactory(std::make_shared<JsiSkPathBuilderFactory>(context)),
+        _colorFilterFactory(std::make_shared<JsiSkColorFilterFactory>(context)),
+        _maskFilterFactory(std::make_shared<JsiSkMaskFilterFactory>(context)),
+        _runtimeEffectFactory(
+            std::make_shared<JsiSkRuntimeEffectFactory>(context)),
+        _shaderFactory(std::make_shared<JsiSkShaderFactory>(context)),
+        _textBlobFactory(std::make_shared<JsiSkTextBlobFactory>(context)),
+        _surfaceFactory(std::make_shared<JsiSkSurfaceFactory>(context)),
+        _pictureFactory(std::make_shared<JsiSkPictureFactory>(context)),
+        _fontMgrFactory(std::make_shared<JsiSkFontMgrFactory>(context)),
+        _skottieFactory(std::make_shared<JsiSkottieFactory>(context)),
+        _typefaceFontProviderFactory(
+            std::make_shared<JsiSkTypefaceFontProviderFactory>(context)),
+        _paragraphBuilderFactory(
+            std::make_shared<JsiSkParagraphBuilderFactory>(context)),
+        _nativeBufferFactory(
+            std::make_shared<JsiNativeBufferFactory>(context)) {
     // We create the system font manager eagerly since it has proven to be too
     // slow to do it on demand
     JsiSkFontMgrFactory::getFontMgr(getContext());
-    installFunction("Video", JsiVideo::createCtor(context));
-    installFunction("Context", JsiSkiaContext::createCtor(context));
-    installFunction("Font", JsiSkFont::createCtor(context));
-    installFunction("Paint", JsiSkPaint::createCtor(context));
-    installFunction("RSXform", JsiSkRSXform::createCtor(context));
-    installFunction("RSXformFromRadians",
-                    JsiSkRSXform::createCtorFromRadians(context));
-    installFunction("Matrix", JsiSkMatrix::createCtor(context));
-    installFunction("XYWHRect", JsiSkRect::createCtor(context));
-    installFunction("RRectXY", JsiSkRRect::createCtor(context));
-    installFunction("Point", JsiSkPoint::createCtor(context));
-    installFunction("RuntimeShaderBuilder",
-                    JsiSkRuntimeShaderBuilder::createCtor(context));
-    installFunction("ContourMeasureIter",
-                    JsiSkContourMeasureIter::createCtor(context));
-    installFunction("MakeVertices", JsiSkVertices::createCtor(context));
-    installFunction("PictureRecorder",
-                    JsiSkPictureRecorder::createCtor(context));
-    installFunction("Color", JsiSkColor::createCtor());
-
-    installReadonlyProperty("SVG", std::make_shared<JsiSkSVGFactory>(context));
-    installReadonlyProperty("Image",
-                            std::make_shared<JsiSkImageFactory>(context));
-    installReadonlyProperty(
-        "AnimatedImage", std::make_shared<JsiSkAnimatedImageFactory>(context));
-    installReadonlyProperty("Typeface",
-                            std::make_shared<JsiSkTypefaceFactory>(context));
-    installReadonlyProperty("Data",
-                            std::make_shared<JsiSkDataFactory>(context));
-    installReadonlyProperty("ImageFilter",
-                            std::make_shared<JsiSkImageFilterFactory>(context));
-    installReadonlyProperty("PathEffect",
-                            std::make_shared<JsiSkPathEffectFactory>(context));
-    installReadonlyProperty("Path",
-                            std::make_shared<JsiSkPathFactory>(context));
-    installReadonlyProperty("PathBuilder",
-                            std::make_shared<JsiSkPathBuilderFactory>(context));
-    installReadonlyProperty("ColorFilter",
-                            std::make_shared<JsiSkColorFilterFactory>(context));
-    installReadonlyProperty("MaskFilter",
-                            std::make_shared<JsiSkMaskFilterFactory>(context));
-    installReadonlyProperty(
-        "RuntimeEffect", std::make_shared<JsiSkRuntimeEffectFactory>(context));
-    installReadonlyProperty("Shader",
-                            std::make_shared<JsiSkShaderFactory>(context));
-    installReadonlyProperty("TextBlob",
-                            std::make_shared<JsiSkTextBlobFactory>(context));
-    installReadonlyProperty("Surface",
-                            std::make_shared<JsiSkSurfaceFactory>(context));
-    installReadonlyProperty("Picture",
-                            std::make_shared<JsiSkPictureFactory>(context));
-    installReadonlyProperty("FontMgr",
-                            std::make_shared<JsiSkFontMgrFactory>(context));
-    installReadonlyProperty("Skottie",
-                            std::make_shared<JsiSkottieFactory>(context));
-    installReadonlyProperty(
-        "TypefaceFontProvider",
-        std::make_shared<JsiSkTypefaceFontProviderFactory>(context));
-
-    installReadonlyProperty(
-        "ParagraphBuilder",
-        std::make_shared<JsiSkParagraphBuilderFactory>(context));
-
-    installReadonlyProperty("NativeBuffer",
-                            std::make_shared<JsiNativeBufferFactory>(context));
-
-    installFunction("Recorder", JsiRecorder::createCtor(context));
+  }
 
-    installFunction(
-        "hasDevice", JSI_HOST_FUNCTION_LAMBDA {
+  // Constructor functions: each delegates to the class's createCtor host
+  // function using the platform context resolved from native state, so the
+  // prototype stays context-free and can be installed on any runtime.
+  JSI_HOST_FUNCTION(Video) {
+    return JsiVideo::createCtor(getContext())(runtime, thisValue, arguments,
+                                              count);
+  }
+  JSI_HOST_FUNCTION(Context) {
+    return JsiSkiaContext::createCtor(getContext())(runtime, thisValue,
+                                                    arguments, count);
+  }
+  JSI_HOST_FUNCTION(Font) {
+    return JsiSkFont::createCtor(getContext())(runtime, thisValue, arguments,
+                                               count);
+  }
+  JSI_HOST_FUNCTION(Paint) {
+    return JsiSkPaint::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(RSXform) {
+    return JsiSkRSXform::createCtor(getContext())(runtime, thisValue, arguments,
+                                                  count);
+  }
+  JSI_HOST_FUNCTION(RSXformFromRadians) {
+    return JsiSkRSXform::createCtorFromRadians(getContext())(runtime, thisValue,
+                                                             arguments, count);
+  }
+  JSI_HOST_FUNCTION(Matrix) {
+    return JsiSkMatrix::createCtor(getContext())(runtime, thisValue, arguments,
+                                                 count);
+  }
+  JSI_HOST_FUNCTION(XYWHRect) {
+    return JsiSkRect::createCtor(getContext())(runtime, thisValue, arguments,
+                                               count);
+  }
+  JSI_HOST_FUNCTION(RRectXY) {
+    return JsiSkRRect::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(Point) {
+    return JsiSkPoint::createCtor(getContext())(runtime, thisValue, arguments,
+                                                count);
+  }
+  JSI_HOST_FUNCTION(RuntimeShaderBuilder) {
+    return JsiSkRuntimeShaderBuilder::createCtor(getContext())(
+        runtime, thisValue, arguments, count);
+  }
+  JSI_HOST_FUNCTION(ContourMeasureIter) {
+    return JsiSkContourMeasureIter::createCtor(getContext())(runtime, thisValue,
+                                                             arguments, count);
+  }
+  JSI_HOST_FUNCTION(MakeVertices) {
+    return JsiSkVertices::createCtor(getContext())(runtime, thisValue,
+                                                   arguments, count);
+  }
+  JSI_HOST_FUNCTION(PictureRecorder) {
+    return JsiSkPictureRecorder::createCtor(getContext())(runtime, thisValue,
+                                                          arguments, count);
+  }
+  JSI_HOST_FUNCTION(Color) {
+    return JsiSkColor::createCtor()(runtime, thisValue, arguments, count);
+  }
+  JSI_HOST_FUNCTION(getNativeDevice) {
 #ifdef SK_GRAPHITE
-          return jsi::Value(true);
+    // Raw WGPUDevice pointer of the Graphite device, as a BigInt. Consumed by
+    // react-native-webgpu's importDevice(), which AddRefs it; the pointer
+    // stays owned by DawnContext and is valid for the process lifetime.
+    auto &dawnContext = DawnContext::getInstance();
+    return jsi::BigInt::fromUint64(
+        runtime,
+        reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
 #else
-      return jsi::Value(false);
+    throw jsi::JSError(runtime,
+                       "getNativeDevice() is only available with the Graphite "
+                       "backend. Rebuild with SK_GRAPHITE enabled.");
 #endif
-        });
+  }
 
-    installFunction(
-        "getDevice", JSI_HOST_FUNCTION_LAMBDA {
-#ifdef SK_GRAPHITE
-          auto &dawnContext = DawnContext::getInstance();
-          // Per-runtime context: async ops on this device resolve on the calling
-          // runtime's own thread (via its ProcessEvents pump).
-          auto context = rnwgpu::async::RuntimeContext::getOrCreate(
-              runtime, dawnContext.getWGPUInstance());
-          auto device = std::make_shared<rnwgpu::GPUDevice>(
-              dawnContext.getWGPUDevice(), context, "Skia Device");
-          return rnwgpu::GPUDevice::create(runtime, device);
-#else
-      throw jsi::JSError(runtime,
-                         "getDevice() is only available with the Graphite "
-                         "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
-        });
+  JSI_HOST_FUNCTION(Recorder) {
+    return JsiRecorder::createCtor(getContext())(runtime, thisValue, arguments,
+                                                 count);
+  }
+
+  // Factory properties: like the legacy HostObject implementation, each
+  // property access returns a fresh JS wrapper around the shared factory
+  // instance.
+  std::shared_ptr<JsiSkSVGFactory> getSVGFactory() { return _svgFactory; }
+  std::shared_ptr<JsiSkImageFactory> getImageFactory() {
+    return _imageFactory;
+  }
+  std::shared_ptr<JsiSkAnimatedImageFactory> getAnimatedImageFactory() {
+    return _animatedImageFactory;
+  }
+  std::shared_ptr<JsiSkTypefaceFactory> getTypefaceFactory() {
+    return _typefaceFactory;
+  }
+  std::shared_ptr<JsiSkDataFactory> getDataFactory() { return _dataFactory; }
+  std::shared_ptr<JsiSkImageFilterFactory> getImageFilterFactory() {
+    return _imageFilterFactory;
+  }
+  std::shared_ptr<JsiSkPathEffectFactory> getPathEffectFactory() {
+    return _pathEffectFactory;
+  }
+  std::shared_ptr<JsiSkPathFactory> getPathFactory() { return _pathFactory; }
+  std::shared_ptr<JsiSkPathBuilderFactory> getPathBuilderFactory() {
+    return _pathBuilderFactory;
+  }
+  std::shared_ptr<JsiSkColorFilterFactory> getColorFilterFactory() {
+    return _colorFilterFactory;
+  }
+  std::shared_ptr<JsiSkMaskFilterFactory> getMaskFilterFactory() {
+    return _maskFilterFactory;
+  }
+  std::shared_ptr<JsiSkRuntimeEffectFactory> getRuntimeEffectFactory() {
+    return _runtimeEffectFactory;
+  }
+  std::shared_ptr<JsiSkShaderFactory> getShaderFactory() {
+    return _shaderFactory;
   }
+  std::shared_ptr<JsiSkTextBlobFactory> getTextBlobFactory() {
+    return _textBlobFactory;
+  }
+  std::shared_ptr<JsiSkSurfaceFactory> getSurfaceFactory() {
+    return _surfaceFactory;
+  }
+  std::shared_ptr<JsiSkPictureFactory> getPictureFactory() {
+    return _pictureFactory;
+  }
+  std::shared_ptr<JsiSkFontMgrFactory> getFontMgrFactory() {
+    return _fontMgrFactory;
+  }
+  std::shared_ptr<JsiSkottieFactory> getSkottieFactory() {
+    return _skottieFactory;
+  }
+  std::shared_ptr<JsiSkTypefaceFontProviderFactory>
+  getTypefaceFontProviderFactory() {
+    return _typefaceFontProviderFactory;
+  }
+  std::shared_ptr<JsiSkParagraphBuilderFactory> getParagraphBuilderFactory() {
+    return _paragraphBuilderFactory;
+  }
+  std::shared_ptr<JsiNativeBufferFactory> getNativeBufferFactory() {
+    return _nativeBufferFactory;
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Video", &JsiSkApi::Video);
+    installHostMethod(runtime, prototype, "Context", &JsiSkApi::Context);
+    installHostMethod(runtime, prototype, "getNativeDevice",
+                      &JsiSkApi::getNativeDevice);
+    installHostMethod(runtime, prototype, "Font", &JsiSkApi::Font);
+    installHostMethod(runtime, prototype, "Paint", &JsiSkApi::Paint);
+    installHostMethod(runtime, prototype, "RSXform", &JsiSkApi::RSXform);
+    installHostMethod(runtime, prototype, "RSXformFromRadians",
+                      &JsiSkApi::RSXformFromRadians);
+    installHostMethod(runtime, prototype, "Matrix", &JsiSkApi::Matrix);
+    installHostMethod(runtime, prototype, "XYWHRect", &JsiSkApi::XYWHRect);
+    installHostMethod(runtime, prototype, "RRectXY", &JsiSkApi::RRectXY);
+    installHostMethod(runtime, prototype, "Point", &JsiSkApi::Point);
+    installHostMethod(runtime, prototype, "RuntimeShaderBuilder",
+                      &JsiSkApi::RuntimeShaderBuilder);
+    installHostMethod(runtime, prototype, "ContourMeasureIter",
+                      &JsiSkApi::ContourMeasureIter);
+    installHostMethod(runtime, prototype, "MakeVertices",
+                      &JsiSkApi::MakeVertices);
+    installHostMethod(runtime, prototype, "PictureRecorder",
+                      &JsiSkApi::PictureRecorder);
+    installHostMethod(runtime, prototype, "Color", &JsiSkApi::Color);
+    installHostMethod(runtime, prototype, "Recorder", &JsiSkApi::Recorder);
+    installGetter(runtime, prototype, "SVG", &JsiSkApi::getSVGFactory);
+    installGetter(runtime, prototype, "Image", &JsiSkApi::getImageFactory);
+    installGetter(runtime, prototype, "AnimatedImage",
+                  &JsiSkApi::getAnimatedImageFactory);
+    installGetter(runtime, prototype, "Typeface",
+                  &JsiSkApi::getTypefaceFactory);
+    installGetter(runtime, prototype, "Data", &JsiSkApi::getDataFactory);
+    installGetter(runtime, prototype, "ImageFilter",
+                  &JsiSkApi::getImageFilterFactory);
+    installGetter(runtime, prototype, "PathEffect",
+                  &JsiSkApi::getPathEffectFactory);
+    installGetter(runtime, prototype, "Path", &JsiSkApi::getPathFactory);
+    installGetter(runtime, prototype, "PathBuilder",
+                  &JsiSkApi::getPathBuilderFactory);
+    installGetter(runtime, prototype, "ColorFilter",
+                  &JsiSkApi::getColorFilterFactory);
+    installGetter(runtime, prototype, "MaskFilter",
+                  &JsiSkApi::getMaskFilterFactory);
+    installGetter(runtime, prototype, "RuntimeEffect",
+                  &JsiSkApi::getRuntimeEffectFactory);
+    installGetter(runtime, prototype, "Shader", &JsiSkApi::getShaderFactory);
+    installGetter(runtime, prototype, "TextBlob",
+                  &JsiSkApi::getTextBlobFactory);
+    installGetter(runtime, prototype, "Surface", &JsiSkApi::getSurfaceFactory);
+    installGetter(runtime, prototype, "Picture", &JsiSkApi::getPictureFactory);
+    installGetter(runtime, prototype, "FontMgr", &JsiSkApi::getFontMgrFactory);
+    installGetter(runtime, prototype, "Skottie", &JsiSkApi::getSkottieFactory);
+    installGetter(runtime, prototype, "TypefaceFontProvider",
+                  &JsiSkApi::getTypefaceFontProviderFactory);
+    installGetter(runtime, prototype, "ParagraphBuilder",
+                  &JsiSkApi::getParagraphBuilderFactory);
+    installGetter(runtime, prototype, "NativeBuffer",
+                  &JsiSkApi::getNativeBufferFactory);
+  }
+
+private:
+  std::shared_ptr<JsiSkSVGFactory> _svgFactory;
+  std::shared_ptr<JsiSkImageFactory> _imageFactory;
+  std::shared_ptr<JsiSkAnimatedImageFactory> _animatedImageFactory;
+  std::shared_ptr<JsiSkTypefaceFactory> _typefaceFactory;
+  std::shared_ptr<JsiSkDataFactory> _dataFactory;
+  std::shared_ptr<JsiSkImageFilterFactory> _imageFilterFactory;
+  std::shared_ptr<JsiSkPathEffectFactory> _pathEffectFactory;
+  std::shared_ptr<JsiSkPathFactory> _pathFactory;
+  std::shared_ptr<JsiSkPathBuilderFactory> _pathBuilderFactory;
+  std::shared_ptr<JsiSkColorFilterFactory> _colorFilterFactory;
+  std::shared_ptr<JsiSkMaskFilterFactory> _maskFilterFactory;
+  std::shared_ptr<JsiSkRuntimeEffectFactory> _runtimeEffectFactory;
+  std::shared_ptr<JsiSkShaderFactory> _shaderFactory;
+  std::shared_ptr<JsiSkTextBlobFactory> _textBlobFactory;
+  std::shared_ptr<JsiSkSurfaceFactory> _surfaceFactory;
+  std::shared_ptr<JsiSkPictureFactory> _pictureFactory;
+  std::shared_ptr<JsiSkFontMgrFactory> _fontMgrFactory;
+  std::shared_ptr<JsiSkottieFactory> _skottieFactory;
+  std::shared_ptr<JsiSkTypefaceFontProviderFactory>
+      _typefaceFontProviderFactory;
+  std::shared_ptr<JsiSkParagraphBuilderFactory> _paragraphBuilderFactory;
+  std::shared_ptr<JsiNativeBufferFactory> _nativeBufferFactory;
 };
 } // namespace RNSkia