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

package/android/CMakeLists.txt

@@ -70,6 +70,7 @@ if(SK_GRAPHITE)
     set(BACKEND_SOURCES
     #TODO: is this source needed to be added?
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNDawnWindowContext.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNDawnInterop.cpp"
     )
 else()
     add_definitions(-DSK_GL -DSK_GANESH)
@@ -114,39 +115,6 @@ add_library(
         ${BACKEND_SOURCES}
 )
 
-if(SK_GRAPHITE)
-    target_sources(${PACKAGE_NAME} PRIVATE
-        # WebGPU async system
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/AsyncTaskHandle.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/RuntimeContext.cpp"
-
-        # WebGPU API
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPU.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUAdapter.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUBindGroup.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUBuffer.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUCanvasContext.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUCommandEncoder.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUComputePassEncoder.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUComputePipeline.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUDevice.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUDeviceLostInfo.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUExternalTexture.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUQuerySet.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUQueue.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderBundleEncoder.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPassEncoder.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPipeline.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUShaderModule.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedFence.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSupportedLimits.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUTexture.cpp"
-
-        # WebGPU Canvas JNI bindings
-        "${PROJECT_SOURCE_DIR}/cpp/jni/JniWebGPUView.cpp"
-    )
-endif()
 
 
 target_include_directories(
@@ -176,12 +144,8 @@ target_include_directories(
         ../cpp/rnskia/values
         ../cpp/utils
 
-        # WebGPU bindings
+        # Shared JSI infrastructure (cpp/jsi) via prefix-qualified includes
         ../cpp
-        ../cpp/rnwgpu
-        ../cpp/rnwgpu/api
-        ../cpp/rnwgpu/api/descriptors
-        ../cpp/rnwgpu/async
 
         ${libfbjni_include_DIRS}
 )
@@ -214,8 +178,10 @@ add_library(jsonreader STATIC IMPORTED)
 set_property(TARGET jsonreader PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libjsonreader.a")
 
 if(SK_GRAPHITE)
-    add_library(dawn_combined STATIC IMPORTED)
-    set_property(TARGET dawn_combined PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_combined.a")
+    # Dawn is a shared library, the same artifact react-native-webgpu links, so
+    # an app that installs both packages loads exactly one Dawn copy.
+    add_library(webgpu_dawn SHARED IMPORTED)
+    set_property(TARGET webgpu_dawn PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libwebgpu_dawn.so")
 endif()
 
 find_library(
@@ -390,7 +356,7 @@ endif()
 if(SK_GRAPHITE)
     target_link_libraries(${PACKAGE_NAME}
         ${COMMON_LIBS}
-        dawn_combined
+        webgpu_dawn
     )
 else()
     target_link_libraries(${PACKAGE_NAME}

package/android/build.gradle

@@ -88,6 +88,39 @@ def skiaLibsPath = useGraphite
         : "${resolveNodePackage('react-native-skia-graphite-android', projectDir)}/libs")
     : "${resolveNodePackage('react-native-skia-android', projectDir)}/libs"
 
+// Both packages must link the exact same Dawn artifact: compare this
+// Graphite build's Dawn release tag (libs/.dawn-version) with the tag
+// react-native-webgpu declares in its package.json `dawn` field.
+if (useGraphite) {
+    def dawnMarker = file("${projectDir}/../libs/.dawn-version")
+    def webgpuDir = null
+    try {
+        webgpuDir = resolveNodePackage('react-native-webgpu', projectDir)
+    } catch (Exception ignored) {
+        // react-native-webgpu not installed: nothing to check
+    }
+    if (dawnMarker.exists() && webgpuDir != null) {
+        def skiaDawn = dawnMarker.text.trim()
+        def webgpuJson = new groovy.json.JsonSlurper().parse(file("${webgpuDir}/package.json"))
+        if (webgpuJson.dawn == null) {
+            throw new GradleException(
+                "react-native-skia: the installed react-native-webgpu " +
+                "(${webgpuJson.version}) does not declare a `dawn` field in its " +
+                "package.json, so it predates shared-Dawn support and cannot be " +
+                "paired with this Graphite build (which links ${skiaDawn}). " +
+                "Upgrade react-native-webgpu.")
+        }
+        def webgpuDawn = "dawn-" + webgpuJson.dawn.toString().replace('/', '-')
+        if (skiaDawn != webgpuDawn) {
+            throw new GradleException(
+                "react-native-skia: Dawn version mismatch. This Graphite build links " +
+                "${skiaDawn} but react-native-webgpu links ${webgpuDawn}. " +
+                "Align the two packages so the app contains exactly one Dawn.")
+        }
+        logger.warn("react-native-skia: Dawn versions match (${skiaDawn})")
+    }
+}
+
 logger.warn("react-native-skia: SK_GRAPHITE: ${useGraphite}")
 logger.warn("react-native-skia: Skia libs: ${skiaLibsPath}")
 logger.warn("react-native-skia: node_modules/ found at: ${nodeModules}")

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

@@ -43,8 +43,7 @@ public class RNSkiaPackage extends TurboReactPackage {
     @Override
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
         return Arrays.<ViewManager>asList(
-            new SkiaPictureViewManager(),
-            new WebGPUViewManager()
+            new SkiaPictureViewManager()
         );
     }
 

package/cpp/api/JsiNativeBuffer.h

@@ -21,36 +21,30 @@ class JsiNativeBufferFactory
 public:
   static constexpr const char *CLASS_NAME = "NativeBufferFactory";
 
-  JSI_HOST_FUNCTION(MakeFromImage) {
-    auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+  // Native buffer pointers travel as BigInts, which the void* converter
+  // produces/consumes.
+  void *MakeFromImage(sk_sp<SkImage> image) {
     image->makeNonTextureImage();
     uint64_t pointer = getContext()->makeNativeBuffer(image);
-    return jsi::BigInt::fromUint64(runtime, pointer);
+    return reinterpret_cast<void *>(pointer);
   }
 
-  JSI_HOST_FUNCTION(MakeTestBuffer) {
-    auto width = static_cast<int>(arguments[0].asNumber());
-    auto height = static_cast<int>(arguments[1].asNumber());
+  void *MakeTestBuffer(int width, int height) {
     uint64_t pointer = getContext()->makeTestNativeBuffer(width, height);
-    return jsi::BigInt::fromUint64(runtime, pointer);
+    return reinterpret_cast<void *>(pointer);
   }
 
-  JSI_HOST_FUNCTION(Release) {
-
-    jsi::BigInt pointer = arguments[0].asBigInt(runtime);
-    const uintptr_t nativeBufferPointer = pointer.asUint64(runtime);
-
-    getContext()->releaseNativeBuffer(nativeBufferPointer);
-    return jsi::Value::undefined();
+  void Release(void *pointer) {
+    getContext()->releaseNativeBuffer(reinterpret_cast<uintptr_t>(pointer));
   }
 
   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);
+    installMethod(runtime, prototype, "Release",
+                  &JsiNativeBufferFactory::Release);
+    installMethod(runtime, prototype, "MakeFromImage",
+                  &JsiNativeBufferFactory::MakeFromImage);
+    installMethod(runtime, prototype, "MakeTestBuffer",
+                  &JsiNativeBufferFactory::MakeTestBuffer);
   }
 
   size_t getMemoryPressure() override { return 1024; }

package/cpp/api/JsiSkAnimatedImage.h

@@ -35,34 +35,31 @@ public:
   static constexpr const char *CLASS_NAME = "AnimatedImage";
 
   // TODO-API: Properties?
-  JSI_HOST_FUNCTION(getCurrentFrame) {
+  std::shared_ptr<JsiSkImage> getCurrentFrame() {
     auto image = getObject()->getCurrentFrame();
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(getFrameCount) {
-    return static_cast<int>(getObject()->getFrameCount());
-  }
+  int getFrameCount() { return static_cast<int>(getObject()->getFrameCount()); }
 
-  JSI_HOST_FUNCTION(currentFrameDuration) {
+  int currentFrameDuration() {
     return static_cast<int>(getObject()->currentFrameDuration());
   }
 
-  JSI_HOST_FUNCTION(decodeNextFrame) {
+  int decodeNextFrame() {
     return static_cast<int>(getObject()->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);
+    installMethod(runtime, prototype, "getFrameCount",
+                  &JsiSkAnimatedImage::getFrameCount);
+    installMethod(runtime, prototype, "getCurrentFrame",
+                  &JsiSkAnimatedImage::getCurrentFrame);
+    installMethod(runtime, prototype, "currentFrameDuration",
+                  &JsiSkAnimatedImage::currentFrameDuration);
+    installMethod(runtime, prototype, "decodeNextFrame",
+                  &JsiSkAnimatedImage::decodeNextFrame);
   }
 
   JsiSkAnimatedImage(std::shared_ptr<RNSkPlatformContext> context,

package/cpp/api/JsiSkAnimatedImageFactory.h

@@ -2,10 +2,12 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkAnimatedImage.h"
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
 #include "JsiSkNativeObjects.h"
 #include "jsi/JsiPromises.h"
@@ -19,22 +21,22 @@ class JsiSkAnimatedImageFactory
 public:
   static constexpr const char *CLASS_NAME = "AnimatedImageFactory";
 
-  JSI_HOST_FUNCTION(MakeAnimatedImageFromEncoded) {
-    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkAnimatedImage>>
+  MakeAnimatedImageFromEncoded(sk_sp<SkData> data) {
     auto codec = SkAndroidCodec::MakeFromData(data);
     auto image = SkAnimatedImage::Make(std::move(codec));
     if (image == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkAnimatedImage>(
-                                      getContext(), std::move(image)));
+    return std::make_shared<JsiSkAnimatedImage>(getContext(),
+                                                std::move(image));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeAnimatedImageFromEncoded",
-                      &JsiSkAnimatedImageFactory::MakeAnimatedImageFromEncoded);
+    installMethod(runtime, prototype, "MakeAnimatedImageFromEncoded",
+                  &JsiSkAnimatedImageFactory::MakeAnimatedImageFromEncoded);
   }
 
   explicit JsiSkAnimatedImageFactory(

package/cpp/api/JsiSkApi.h

@@ -8,8 +8,6 @@
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#include "rnwgpu/api/GPUDevice.h"
-#include "rnwgpu/async/RuntimeContext.h"
 #endif
 
 #include "JsiNativeBuffer.h"
@@ -173,88 +171,94 @@ public:
   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);
-#else
-    return jsi::Value(false);
-#endif
-  }
-
-  JSI_HOST_FUNCTION(getDevice) {
+  JSI_HOST_FUNCTION(getNativeDevice) {
 #ifdef SK_GRAPHITE
+    // 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();
-    // 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);
+    return jsi::BigInt::fromUint64(
+        runtime,
+        reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
 #else
     throw jsi::JSError(runtime,
-                       "getDevice() is only available with the Graphite "
+                       "getNativeDevice() 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.
-  JSI_PROPERTY_GET(SVG) { return makeJsiObject(runtime, _svgFactory); }
-  JSI_PROPERTY_GET(Image) { return makeJsiObject(runtime, _imageFactory); }
-  JSI_PROPERTY_GET(AnimatedImage) {
-    return makeJsiObject(runtime, _animatedImageFactory);
+  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;
   }
-  JSI_PROPERTY_GET(Typeface) {
-    return makeJsiObject(runtime, _typefaceFactory);
+  std::shared_ptr<JsiSkDataFactory> getDataFactory() { return _dataFactory; }
+  std::shared_ptr<JsiSkImageFilterFactory> getImageFilterFactory() {
+    return _imageFilterFactory;
   }
-  JSI_PROPERTY_GET(Data) { return makeJsiObject(runtime, _dataFactory); }
-  JSI_PROPERTY_GET(ImageFilter) {
-    return makeJsiObject(runtime, _imageFilterFactory);
+  std::shared_ptr<JsiSkPathEffectFactory> getPathEffectFactory() {
+    return _pathEffectFactory;
   }
-  JSI_PROPERTY_GET(PathEffect) {
-    return makeJsiObject(runtime, _pathEffectFactory);
+  std::shared_ptr<JsiSkPathFactory> getPathFactory() { return _pathFactory; }
+  std::shared_ptr<JsiSkPathBuilderFactory> getPathBuilderFactory() {
+    return _pathBuilderFactory;
   }
-  JSI_PROPERTY_GET(Path) { return makeJsiObject(runtime, _pathFactory); }
-  JSI_PROPERTY_GET(PathBuilder) {
-    return makeJsiObject(runtime, _pathBuilderFactory);
+  std::shared_ptr<JsiSkColorFilterFactory> getColorFilterFactory() {
+    return _colorFilterFactory;
   }
-  JSI_PROPERTY_GET(ColorFilter) {
-    return makeJsiObject(runtime, _colorFilterFactory);
+  std::shared_ptr<JsiSkMaskFilterFactory> getMaskFilterFactory() {
+    return _maskFilterFactory;
   }
-  JSI_PROPERTY_GET(MaskFilter) {
-    return makeJsiObject(runtime, _maskFilterFactory);
+  std::shared_ptr<JsiSkRuntimeEffectFactory> getRuntimeEffectFactory() {
+    return _runtimeEffectFactory;
   }
-  JSI_PROPERTY_GET(RuntimeEffect) {
-    return makeJsiObject(runtime, _runtimeEffectFactory);
+  std::shared_ptr<JsiSkShaderFactory> getShaderFactory() {
+    return _shaderFactory;
   }
-  JSI_PROPERTY_GET(Shader) { return makeJsiObject(runtime, _shaderFactory); }
-  JSI_PROPERTY_GET(TextBlob) {
-    return makeJsiObject(runtime, _textBlobFactory);
+  std::shared_ptr<JsiSkTextBlobFactory> getTextBlobFactory() {
+    return _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);
+  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;
   }
-  JSI_PROPERTY_GET(ParagraphBuilder) {
-    return makeJsiObject(runtime, _paragraphBuilderFactory);
+  std::shared_ptr<JsiSkParagraphBuilderFactory> getParagraphBuilderFactory() {
+    return _paragraphBuilderFactory;
   }
-  JSI_PROPERTY_GET(NativeBuffer) {
-    return makeJsiObject(runtime, _nativeBufferFactory);
+  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);
@@ -274,39 +278,39 @@ public:
                       &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);
+    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: