@shopify/react-native-skia 2.9.1 → 2.10.0

package/cpp/api/JsiSkPathFactory.h

@@ -7,8 +7,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
@@ -17,7 +17,6 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include "utils/RNSkLog.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPathBuilder.h"
 #include "include/core/SkPathUtils.h"
@@ -26,6 +25,7 @@
 #include "include/effects/SkTrimPathEffect.h"
 #include "include/pathops/SkPathOps.h"
 #include "include/utils/SkTextUtils.h"
+#include "utils/RNSkLog.h"
 
 #pragma clang diagnostic pop
 
@@ -33,7 +33,7 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPathFactory : public JsiSkHostObject {
+class JsiSkPathFactory : public JsiSkNativeObject<JsiSkPathFactory> {
 
   static const int MOVE = 0;
   static const int LINE = 1;
@@ -43,11 +43,11 @@ class JsiSkPathFactory : public JsiSkHostObject {
   static const int CLOSE = 5;
 
 public:
+  static constexpr const char *CLASS_NAME = "PathFactory";
+
   JSI_HOST_FUNCTION(Make) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), SkPath());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkPath>(getContext(), SkPath()));
   }
 
   JSI_HOST_FUNCTION(MakeFromSVGString) {
@@ -57,10 +57,8 @@ public:
       throw jsi::JSError(runtime, "Could not parse Svg path");
       return jsi::Value(nullptr);
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
+                                      getContext(), std::move(result.value())));
   }
 
   JSI_HOST_FUNCTION(MakeFromOp) {
@@ -71,10 +69,8 @@ public:
     if (!result.has_value()) {
       return jsi::Value(nullptr);
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
+                                      getContext(), std::move(result.value())));
   }
 
   JSI_HOST_FUNCTION(MakeFromCmds) {
@@ -159,10 +155,8 @@ public:
       }
       }
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(MakeFromText) {
@@ -173,10 +167,8 @@ public:
     SkPath path;
     SkTextUtils::GetPath(text.c_str(), strlen(text.c_str()),
                          SkTextEncoding::kUTF8, x, y, *font, &path);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(path));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(path)));
   }
 
   // Static shape factories
@@ -188,10 +180,8 @@ public:
     }
     SkPathBuilder builder;
     builder.addRect(*rect, direction);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(Oval) {
@@ -203,10 +193,8 @@ public:
     unsigned startIndex = count < 3 ? 0 : arguments[2].asNumber();
     SkPathBuilder builder;
     builder.addOval(*rect, direction, startIndex);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(Circle) {
@@ -215,10 +203,8 @@ public:
     auto r = arguments[2].asNumber();
     SkPathBuilder builder;
     builder.addCircle(x, y, r);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(RRect) {
@@ -229,10 +215,8 @@ public:
     }
     SkPathBuilder builder;
     builder.addRRect(*rrect, direction);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(Line) {
@@ -241,10 +225,8 @@ public:
     SkPathBuilder builder;
     builder.moveTo(*p1);
     builder.lineTo(*p2);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   JSI_HOST_FUNCTION(Polygon) {
@@ -260,10 +242,8 @@ public:
     }
     SkPathBuilder builder;
     builder.addPolygon(SkSpan(points), close);
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), builder.snapshot());
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), builder.snapshot()));
   }
 
   // Static path operations
@@ -307,19 +287,17 @@ public:
       auto success =
           skpathutils::FillPathWithPaint(path, p, &resultBuilder, nullptr, ctm);
       if (success) {
-        auto hostObjectInstance =
-            std::make_shared<JsiSkPath>(getContext(), resultBuilder.snapshot());
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, getContext());
+        return makeJsiObject(
+            runtime, std::make_shared<JsiSkPath>(getContext(),
+                                                 resultBuilder.snapshot()));
       }
     } else {
       SkPathBuilder resultBuilder;
       auto success = skpathutils::FillPathWithPaint(path, p, &resultBuilder);
       if (success) {
-        auto hostObjectInstance =
-            std::make_shared<JsiSkPath>(getContext(), resultBuilder.snapshot());
-        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-            runtime, hostObjectInstance, getContext());
+        return makeJsiObject(
+            runtime, std::make_shared<JsiSkPath>(getContext(),
+                                                 resultBuilder.snapshot()));
       }
     }
     return jsi::Value::null();
@@ -335,10 +313,8 @@ public:
     // If requesting the full path in normal mode, just return a copy
     if (start <= 0 && end >= 1 && !isComplement) {
       SkPath result = srcPath->snapshot();
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPath>(getContext(), std::move(result));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
+                                        getContext(), std::move(result)));
     }
     SkPath path = srcPath->snapshot();
     auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
@@ -351,10 +327,8 @@ public:
     SkPathBuilder resultBuilder;
     if (pe->filterPath(&resultBuilder, path, &rec)) {
       auto result = resultBuilder.detach();
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPath>(getContext(), std::move(result));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
+                                        getContext(), std::move(result)));
     }
     return jsi::Value::null();
   }
@@ -363,10 +337,9 @@ public:
     auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
     auto result = ::Simplify(srcPath->snapshot());
     if (result.has_value()) {
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(
+          runtime,
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value())));
     }
     return jsi::Value::null();
   }
@@ -386,10 +359,8 @@ public:
     SkPathBuilder resultBuilder;
     if (pe->filterPath(&resultBuilder, srcPath->snapshot(), &rec)) {
       auto result = resultBuilder.detach();
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPath>(getContext(), std::move(result));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(runtime, std::make_shared<JsiSkPath>(
+                                        getContext(), std::move(result)));
     }
     return jsi::Value::null();
   }
@@ -398,10 +369,9 @@ public:
     auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
     auto result = ::AsWinding(srcPath->snapshot());
     if (result.has_value()) {
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(
+          runtime,
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value())));
     }
     return jsi::Value::null();
   }
@@ -417,38 +387,44 @@ public:
     if (!succeed) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPath>(getContext(), std::move(result));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(
+        runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkPathFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathFactory, Make),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromCmds),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText),
-                       // Static shape factories
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Rect),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Oval),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Circle),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, RRect),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Line),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Polygon),
-                       // Static path operations
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Stroke),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Trim),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Simplify),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Dash),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, AsWinding),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, Interpolate))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "Make", &JsiSkPathFactory::Make);
+    installHostMethod(runtime, prototype, "MakeFromSVGString",
+                      &JsiSkPathFactory::MakeFromSVGString);
+    installHostMethod(runtime, prototype, "MakeFromOp",
+                      &JsiSkPathFactory::MakeFromOp);
+    installHostMethod(runtime, prototype, "MakeFromCmds",
+                      &JsiSkPathFactory::MakeFromCmds);
+    installHostMethod(runtime, prototype, "MakeFromText",
+                      &JsiSkPathFactory::MakeFromText);
+    // Static shape factories
+    installHostMethod(runtime, prototype, "Rect", &JsiSkPathFactory::Rect);
+    installHostMethod(runtime, prototype, "Oval", &JsiSkPathFactory::Oval);
+    installHostMethod(runtime, prototype, "Circle", &JsiSkPathFactory::Circle);
+    installHostMethod(runtime, prototype, "RRect", &JsiSkPathFactory::RRect);
+    installHostMethod(runtime, prototype, "Line", &JsiSkPathFactory::Line);
+    installHostMethod(runtime, prototype, "Polygon",
+                      &JsiSkPathFactory::Polygon);
+    // Static path operations
+    installHostMethod(runtime, prototype, "Stroke", &JsiSkPathFactory::Stroke);
+    installHostMethod(runtime, prototype, "Trim", &JsiSkPathFactory::Trim);
+    installHostMethod(runtime, prototype, "Simplify",
+                      &JsiSkPathFactory::Simplify);
+    installHostMethod(runtime, prototype, "Dash", &JsiSkPathFactory::Dash);
+    installHostMethod(runtime, prototype, "AsWinding",
+                      &JsiSkPathFactory::AsWinding);
+    installHostMethod(runtime, prototype, "Interpolate",
+                      &JsiSkPathFactory::Interpolate);
+  }
 
   explicit JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkPathFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPicture.h

@@ -4,8 +4,8 @@
 
 #include "JsiSkData.h"
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkRect.h"
 #include "JsiSkShader.h"
 
@@ -20,14 +20,18 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPicture : public JsiSkWrappingSkPtrHostObject<SkPicture> {
+class JsiSkPicture
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkPicture, SkPicture> {
 private:
   std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
+  static constexpr const char *CLASS_NAME = "Picture";
+
   JsiSkPicture(std::shared_ptr<RNSkPlatformContext> context,
                const sk_sp<SkPicture> picture)
-      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {
+      : JsiSkWrappingSkPtrNativeObject<JsiSkPicture, SkPicture>(context,
+                                                                picture) {
     // Get the dispatcher for the current thread
     _dispatcher = Dispatcher::getDispatcher();
     // Process any pending operations
@@ -66,9 +70,8 @@ public:
 
     // Create shader
     auto shader = getObject()->makeShader(tmx, tmy, fm, m, tr);
-    auto shaderObj = std::make_shared<JsiSkShader>(getContext(), shader);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkShader>(getContext(), shader));
   }
 
   JSI_HOST_FUNCTION(serialize) {
@@ -90,13 +93,23 @@ public:
     return array;
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkPicture, Picture)
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkPicture> fromValue(jsi::Runtime &runtime,
+                                    const jsi::Value &obj) {
+    return getJsiObject<JsiSkPicture>(runtime, obj)->getObject();
+  }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPicture, makeShader),
-                       JSI_EXPORT_FUNC(JsiSkPicture, serialize),
-                       JSI_EXPORT_FUNC(JsiSkPicture, dispose))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "makeShader",
+                      &JsiSkPicture::makeShader);
+    installHostMethod(runtime, prototype, "serialize",
+                      &JsiSkPicture::serialize);
+  }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -108,7 +121,5 @@ public:
     auto bytesUsed = picture->approximateBytesUsed();
     return bytesUsed;
   }
-
-  std::string getObjectType() const override { return "JsiSkPicture"; }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkPictureFactory.h

@@ -4,7 +4,7 @@
 
 #include "JsiSkColorFilter.h"
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPicture.h"
 
 #pragma clang diagnostic push
@@ -19,15 +19,15 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkPictureFactory : public JsiSkHostObject {
+class JsiSkPictureFactory : public JsiSkNativeObject<JsiSkPictureFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "PictureFactory";
+
   JSI_HOST_FUNCTION(MakePicture) {
     // Handle null case - create JsiSkPicture with nullptr
     if (arguments[0].isNull() || arguments[0].isUndefined()) {
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPicture>(getContext(), nullptr);
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(
+          runtime, std::make_shared<JsiSkPicture>(getContext(), nullptr));
     }
 
     if (!arguments[0].isObject()) {
@@ -36,18 +36,14 @@ public:
     auto obj = arguments[0].asObject(runtime);
 
     // Check if it's a JsiSkData object first
-    if (obj.isHostObject(runtime)) {
-      if (auto jsiData = obj.asHostObject<JsiSkData>(runtime)) {
-        auto data = jsiData->getObject();
-        auto picture = SkPicture::MakeFromData(data.get());
-        if (picture != nullptr) {
-          auto hostObjectInstance =
-              std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
-          return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-              runtime, hostObjectInstance, getContext());
-        }
-        return jsi::Value::undefined();
+    if (auto jsiData = tryGetJsiObject<JsiSkData>(runtime, obj)) {
+      auto data = jsiData->getObject();
+      auto picture = SkPicture::MakeFromData(data.get());
+      if (picture != nullptr) {
+        return makeJsiObject(runtime, std::make_shared<JsiSkPicture>(
+                                          getContext(), std::move(picture)));
       }
+      return jsi::Value::undefined();
     }
 
     // Get ArrayBuffer - try buffer property first (Uint8Array, etc.), then
@@ -64,23 +60,22 @@ public:
         SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));
     auto picture = SkPicture::MakeFromData(data.get());
     if (picture != nullptr) {
-      auto hostObjectInstance =
-          std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-          runtime, hostObjectInstance, getContext());
+      return makeJsiObject(runtime, std::make_shared<JsiSkPicture>(
+                                        getContext(), std::move(picture)));
     } else {
       return jsi::Value::undefined();
     }
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureFactory, MakePicture))
+  size_t getMemoryPressure() override { return 1024; }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkPictureFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakePicture",
+                      &JsiSkPictureFactory::MakePicture);
+  }
 
   explicit JsiSkPictureFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkPictureFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPictureRecorder.h

@@ -3,7 +3,7 @@
 #include <memory>
 
 #include "JsiSkCanvas.h"
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkPicture.h"
 #include "JsiSkRect.h"
 
@@ -20,10 +20,14 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkPictureRecorder
-    : public JsiSkWrappingSharedPtrHostObject<SkPictureRecorder> {
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkPictureRecorder,
+                                                SkPictureRecorder> {
 public:
+  static constexpr const char *CLASS_NAME = "PictureRecorder";
+
   explicit JsiSkPictureRecorder(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkWrappingSharedPtrHostObject<SkPictureRecorder>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkPictureRecorder,
+                                           SkPictureRecorder>(
             context, std::make_shared<SkPictureRecorder>()) {}
 
   JSI_HOST_FUNCTION(beginRecording) {
@@ -37,36 +41,31 @@ public:
       SkRect rect = SkRect::Make(size);
       canvas = getObject()->beginRecording(rect, nullptr);
     }
-    auto canvasObj = std::make_shared<JsiSkCanvas>(getContext(), canvas);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvasObj,
-                                                       getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkCanvas>(getContext(), canvas));
   }
 
   JSI_HOST_FUNCTION(finishRecordingAsPicture) {
     auto picture = getObject()->finishRecordingAsPicture();
-    auto hostObjectInstance =
-        std::make_shared<JsiSkPicture>(getContext(), std::move(picture));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkPicture>(
+                                      getContext(), std::move(picture)));
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkPictureRecorder, PictureRecorder)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureRecorder, beginRecording),
-                       JSI_EXPORT_FUNC(JsiSkPictureRecorder,
-                                       finishRecordingAsPicture),
-                       JSI_EXPORT_FUNC(JsiSkPictureRecorder, dispose))
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "beginRecording",
+                      &JsiSkPictureRecorder::beginRecording);
+    installHostMethod(runtime, prototype, "finishRecordingAsPicture",
+                      &JsiSkPictureRecorder::finishRecordingAsPicture);
+  }
 
-  std::string getObjectType() const override { return "JsiSkPictureRecorder"; }
+  size_t getMemoryPressure() override { return 1024 * 1024; }
 
   static const jsi::HostFunctionType
   createCtor(std::shared_ptr<RNSkPlatformContext> context) {
     return JSI_HOST_FUNCTION_LAMBDA {
-      auto recorder = std::make_shared<JsiSkPictureRecorder>(context);
-      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, recorder,
-                                                         context);
+      return makeJsiObject(runtime,
+                           std::make_shared<JsiSkPictureRecorder>(context));
     };
   }
 };