@shopify/react-native-skia 2.9.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/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

package/cpp/api/JsiSkApi.h

@@ -4,7 +4,7 @@
 
 #include "rnskia/RNSkPlatformContext.h"
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
@@ -67,11 +67,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 +79,258 @@ 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(Recorder) {
+    return JsiRecorder::createCtor(getContext())(runtime, thisValue, arguments,
+                                                 count);
+  }
+
+  JSI_HOST_FUNCTION(hasDevice) {
 #ifdef SK_GRAPHITE
-          return jsi::Value(true);
+    return jsi::Value(true);
 #else
-      return jsi::Value(false);
+    return jsi::Value(false);
 #endif
-        });
+  }
 
-    installFunction(
-        "getDevice", JSI_HOST_FUNCTION_LAMBDA {
+  JSI_HOST_FUNCTION(getDevice) {
 #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);
+    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.");
+    throw jsi::JSError(runtime,
+                       "getDevice() is only available with the Graphite "
+                       "backend. Rebuild with SK_GRAPHITE enabled.");
 #endif
-        });
   }
+
+  // Factory properties: like the legacy HostObject implementation, each
+  // property access returns a fresh JS wrapper around the shared factory
+  // instance.
+  JSI_PROPERTY_GET(SVG) { return makeJsiObject(runtime, _svgFactory); }
+  JSI_PROPERTY_GET(Image) { return makeJsiObject(runtime, _imageFactory); }
+  JSI_PROPERTY_GET(AnimatedImage) {
+    return makeJsiObject(runtime, _animatedImageFactory);
+  }
+  JSI_PROPERTY_GET(Typeface) {
+    return makeJsiObject(runtime, _typefaceFactory);
+  }
+  JSI_PROPERTY_GET(Data) { return makeJsiObject(runtime, _dataFactory); }
+  JSI_PROPERTY_GET(ImageFilter) {
+    return makeJsiObject(runtime, _imageFilterFactory);
+  }
+  JSI_PROPERTY_GET(PathEffect) {
+    return makeJsiObject(runtime, _pathEffectFactory);
+  }
+  JSI_PROPERTY_GET(Path) { return makeJsiObject(runtime, _pathFactory); }
+  JSI_PROPERTY_GET(PathBuilder) {
+    return makeJsiObject(runtime, _pathBuilderFactory);
+  }
+  JSI_PROPERTY_GET(ColorFilter) {
+    return makeJsiObject(runtime, _colorFilterFactory);
+  }
+  JSI_PROPERTY_GET(MaskFilter) {
+    return makeJsiObject(runtime, _maskFilterFactory);
+  }
+  JSI_PROPERTY_GET(RuntimeEffect) {
+    return makeJsiObject(runtime, _runtimeEffectFactory);
+  }
+  JSI_PROPERTY_GET(Shader) { return makeJsiObject(runtime, _shaderFactory); }
+  JSI_PROPERTY_GET(TextBlob) {
+    return makeJsiObject(runtime, _textBlobFactory);
+  }
+  JSI_PROPERTY_GET(Surface) { return makeJsiObject(runtime, _surfaceFactory); }
+  JSI_PROPERTY_GET(Picture) { return makeJsiObject(runtime, _pictureFactory); }
+  JSI_PROPERTY_GET(FontMgr) { return makeJsiObject(runtime, _fontMgrFactory); }
+  JSI_PROPERTY_GET(Skottie) { return makeJsiObject(runtime, _skottieFactory); }
+  JSI_PROPERTY_GET(TypefaceFontProvider) {
+    return makeJsiObject(runtime, _typefaceFontProviderFactory);
+  }
+  JSI_PROPERTY_GET(ParagraphBuilder) {
+    return makeJsiObject(runtime, _paragraphBuilderFactory);
+  }
+  JSI_PROPERTY_GET(NativeBuffer) {
+    return makeJsiObject(runtime, _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, "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);
+    installHostMethod(runtime, prototype, "hasDevice", &JsiSkApi::hasDevice);
+    installHostMethod(runtime, prototype, "getDevice", &JsiSkApi::getDevice);
+    installHostGetter(runtime, prototype, "SVG", &JsiSkApi::get_SVG);
+    installHostGetter(runtime, prototype, "Image", &JsiSkApi::get_Image);
+    installHostGetter(runtime, prototype, "AnimatedImage",
+                      &JsiSkApi::get_AnimatedImage);
+    installHostGetter(runtime, prototype, "Typeface", &JsiSkApi::get_Typeface);
+    installHostGetter(runtime, prototype, "Data", &JsiSkApi::get_Data);
+    installHostGetter(runtime, prototype, "ImageFilter",
+                      &JsiSkApi::get_ImageFilter);
+    installHostGetter(runtime, prototype, "PathEffect",
+                      &JsiSkApi::get_PathEffect);
+    installHostGetter(runtime, prototype, "Path", &JsiSkApi::get_Path);
+    installHostGetter(runtime, prototype, "PathBuilder",
+                      &JsiSkApi::get_PathBuilder);
+    installHostGetter(runtime, prototype, "ColorFilter",
+                      &JsiSkApi::get_ColorFilter);
+    installHostGetter(runtime, prototype, "MaskFilter",
+                      &JsiSkApi::get_MaskFilter);
+    installHostGetter(runtime, prototype, "RuntimeEffect",
+                      &JsiSkApi::get_RuntimeEffect);
+    installHostGetter(runtime, prototype, "Shader", &JsiSkApi::get_Shader);
+    installHostGetter(runtime, prototype, "TextBlob", &JsiSkApi::get_TextBlob);
+    installHostGetter(runtime, prototype, "Surface", &JsiSkApi::get_Surface);
+    installHostGetter(runtime, prototype, "Picture", &JsiSkApi::get_Picture);
+    installHostGetter(runtime, prototype, "FontMgr", &JsiSkApi::get_FontMgr);
+    installHostGetter(runtime, prototype, "Skottie", &JsiSkApi::get_Skottie);
+    installHostGetter(runtime, prototype, "TypefaceFontProvider",
+                      &JsiSkApi::get_TypefaceFontProvider);
+    installHostGetter(runtime, prototype, "ParagraphBuilder",
+                      &JsiSkApi::get_ParagraphBuilder);
+    installHostGetter(runtime, prototype, "NativeBuffer",
+                      &JsiSkApi::get_NativeBuffer);
+  }
+
+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