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

package/cpp/api/JsiSkFontMgrFactory.h

@@ -6,7 +6,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,8 +20,10 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontMgrFactory : public JsiSkHostObject {
+class JsiSkFontMgrFactory : public JsiSkNativeObject<JsiSkFontMgrFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "FontMgrFactory";
+
   static sk_sp<SkFontMgr>
   getFontMgr(std::shared_ptr<RNSkPlatformContext> context) {
     static SkOnce once;
@@ -32,19 +34,19 @@ public:
 
   JSI_HOST_FUNCTION(System) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
-    auto fontMgrObj = std::make_shared<JsiSkFontMgr>(getContext(), fontMgr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontMgrObj,
-                                                       getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkFontMgr>(getContext(), fontMgr));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))
-
-  size_t getMemoryPressure() const override { return 1024; }
+  size_t getMemoryPressure() override { return 1024; }
 
-  std::string getObjectType() const override { return "JsiSkFontMgrFactory"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "System",
+                      &JsiSkFontMgrFactory::System);
+  }
 
   explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkFontMgrFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkFontStyle.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,13 +18,14 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkFontStyle : public JsiSkWrappingSharedPtrHostObject<SkFontStyle> {
+class JsiSkFontStyle
+    : public JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle> {
 public:
-  JSI_API_TYPENAME("FontStyle");
+  static constexpr const char *CLASS_NAME = "FontStyle";
 
   JsiSkFontStyle(std::shared_ptr<RNSkPlatformContext> context,
                  const SkFontStyle &fontStyle)
-      : JsiSkWrappingSharedPtrHostObject<SkFontStyle>(
+      : JsiSkWrappingSharedPtrNativeObject<JsiSkFontStyle, SkFontStyle>(
             std::move(context), std::make_shared<SkFontStyle>(fontStyle)) {}
 
   /**
@@ -33,8 +34,9 @@ public:
   static std::shared_ptr<SkFontStyle> fromValue(jsi::Runtime &runtime,
                                                 const jsi::Value &obj) {
     const auto &object = obj.asObject(runtime);
-    if (object.isHostObject(runtime)) {
-      return object.asHostObject<JsiSkFontStyle>(runtime)->getObject();
+    auto fontStyle = tryGetJsiObject<JsiSkFontStyle>(runtime, object);
+    if (fontStyle) {
+      return fontStyle->getObject();
     } else {
       auto weightProp = object.getProperty(runtime, "weight");
       auto weight = static_cast<int>(
@@ -56,11 +58,13 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     return std::max(sizeof(SkFontStyle), kMinMemoryPressure);
   }
 
-  std::string getObjectType() const override { return "JsiSkFontStyle"; }
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
 
   /**
   Returns the jsi object from a host object of this type
@@ -68,10 +72,8 @@ public:
   static jsi::Value toValue(jsi::Runtime &runtime,
                             std::shared_ptr<RNSkPlatformContext> context,
                             const SkFontStyle &fontStyle) {
-    auto fontStyleObj =
-        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, fontStyleObj,
-                                                       context);
+    return makeJsiObject(runtime, std::make_shared<JsiSkFontStyle>(
+                                      std::move(context), fontStyle));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -5,9 +5,9 @@
 #include <utility>
 
 #include "JsiSkDispatcher.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
+#include "JsiSkNativeObjects.h"
 #include "JsiSkShader.h"
 #include "api/third_party/base64.h"
 
@@ -15,8 +15,8 @@
 #include "utils/RNSkTypedArray.h"
 
 #if defined(SK_GRAPHITE)
-#include "rnskia/RNDawnContext.h"
 #include "include/gpu/graphite/Context.h"
+#include "rnskia/RNDawnContext.h"
 #else
 #include "include/gpu/ganesh/GrDirectContext.h"
 #endif
@@ -140,11 +140,13 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
   return samplingOptions;
 }
 
-class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
+class JsiSkImage : public JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage> {
 private:
   std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
+  static constexpr const char *CLASS_NAME = "Image";
+
   // TODO-API: Properties?
   JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
   JSI_HOST_FUNCTION(height) {
@@ -166,10 +168,8 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions(fm, mm), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(shader)));
   }
 
   JSI_HOST_FUNCTION(makeShaderCubic) {
@@ -182,10 +182,8 @@ public:
                  : nullptr;
     auto shader =
         getObject()->makeShader(tmx, tmy, SkSamplingOptions({B, C}), m);
-    auto shaderObj =
-        std::make_shared<JsiSkShader>(getContext(), std::move(shader));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shaderObj,
-                                                       getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkShader>(
+                                      getContext(), std::move(shader)));
   }
 
   sk_sp<SkData> encodeImageData(const jsi::Value *arguments, size_t count) {
@@ -344,10 +342,8 @@ public:
     if (!rasterImage) {
       return jsi::Value::null();
     }
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime, std::make_shared<JsiSkImage>(
+                                      getContext(), std::move(rasterImage)));
   }
 
   JSI_HOST_FUNCTION(getNativeTextureUnstable) {
@@ -363,25 +359,42 @@ public:
     return jsi::Value(getObject()->isTextureBacked());
   }
 
-  EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
-                       JSI_EXPORT_FUNC(JsiSkImage, height),
-                       JSI_EXPORT_FUNC(JsiSkImage, getImageInfo),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderOptions),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeShaderCubic),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBytes),
-                       JSI_EXPORT_FUNC(JsiSkImage, encodeToBase64),
-                       JSI_EXPORT_FUNC(JsiSkImage, readPixels),
-                       JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
-                       JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
-                       JSI_EXPORT_FUNC(JsiSkImage, dispose))
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkImage> fromValue(jsi::Runtime &runtime,
+                                  const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+    installHostMethod(runtime, prototype, "width", &JsiSkImage::width);
+    installHostMethod(runtime, prototype, "height", &JsiSkImage::height);
+    installHostMethod(runtime, prototype, "getImageInfo",
+                      &JsiSkImage::getImageInfo);
+    installHostMethod(runtime, prototype, "makeShaderOptions",
+                      &JsiSkImage::makeShaderOptions);
+    installHostMethod(runtime, prototype, "makeShaderCubic",
+                      &JsiSkImage::makeShaderCubic);
+    installHostMethod(runtime, prototype, "encodeToBytes",
+                      &JsiSkImage::encodeToBytes);
+    installHostMethod(runtime, prototype, "encodeToBase64",
+                      &JsiSkImage::encodeToBase64);
+    installHostMethod(runtime, prototype, "readPixels",
+                      &JsiSkImage::readPixels);
+    installHostMethod(runtime, prototype, "makeNonTextureImage",
+                      &JsiSkImage::makeNonTextureImage);
+    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
+                      &JsiSkImage::getNativeTextureUnstable);
+    installHostMethod(runtime, prototype, "isTextureBacked",
+                      &JsiSkImage::isTextureBacked);
+  }
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
-      : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
-                                              std::move(image)) {
+      : JsiSkWrappingSkPtrNativeObject<JsiSkImage, SkImage>(std::move(context),
+                                                            std::move(image)) {
     // Get the dispatcher for the current thread
     _dispatcher = Dispatcher::getDispatcher();
     // Process any pending operations (e.g. deletions of previous resources)
@@ -406,7 +419,7 @@ public:
     }
   }
 
-  size_t getMemoryPressure() const override {
+  size_t getMemoryPressure() override {
     if (isDisposed()) {
       return 0;
     }
@@ -420,8 +433,6 @@ public:
     }
     return 0;
   }
-
-  std::string getObjectType() const override { return "JsiSkImage"; }
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFactory.h

@@ -5,11 +5,11 @@
 
 #include <jsi/jsi.h>
 
-#include "jsi/JsiPromises.h"
 #include "JsiSkData.h"
-#include "JsiSkHostObjects.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageInfo.h"
+#include "JsiSkNativeObjects.h"
+#include "jsi/JsiPromises.h"
 
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
@@ -20,13 +20,13 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkImageFactory : public JsiSkHostObject {
+class JsiSkImageFactory : public JsiSkNativeObject<JsiSkImageFactory> {
 public:
+  static constexpr const char *CLASS_NAME = "ImageFactory";
+
   JSI_HOST_FUNCTION(MakeNull) {
-    auto hostObjectInstance =
-        std::make_shared<JsiSkImage>(getContext(), nullptr);
-    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-        runtime, hostObjectInstance, getContext());
+    return makeJsiObject(runtime,
+                         std::make_shared<JsiSkImage>(getContext(), nullptr));
   }
 
   JSI_HOST_FUNCTION(MakeImageFromEncoded) {
@@ -35,10 +35,8 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    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(MakeImageFromNativeBuffer) {
@@ -49,10 +47,8 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert NativeBuffer to SkImage!");
     }
-    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(MakeImage) {
@@ -63,10 +59,8 @@ public:
     if (image == nullptr) {
       return jsi::Value::null();
     }
-    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(MakeImageFromViewTag) {
@@ -88,10 +82,9 @@ public:
                     promise->reject("Failed to create image from view tag");
                     return;
                   }
-                  auto hostObjectInstance =
-                      std::make_shared<JsiSkImage>(context, std::move(result));
-                  promise->resolve(JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
-                      runtime, hostObjectInstance, context));
+                  promise->resolve(
+                      makeJsiObject(runtime, std::make_shared<JsiSkImage>(
+                                                 context, std::move(result))));
                 });
               });
         });
@@ -105,17 +98,15 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert native texture to SkImage!");
     }
-    if (count > 4 && arguments[4].isObject() &&
-        arguments[4].asObject(runtime).isHostObject(runtime)) {
-      auto jsiImage =
-          arguments[4].asObject(runtime).asHostObject<JsiSkImage>(runtime);
-      jsiImage->setObject(image);
-      return jsi::Value(runtime, arguments[4]);
+    if (count > 4) {
+      auto jsiImage = tryGetJsiObject<JsiSkImage>(runtime, arguments[4]);
+      if (jsiImage) {
+        jsiImage->setObject(image);
+        return jsi::Value(runtime, arguments[4]);
+      }
     }
-    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(MakeImageFromTexture) {
@@ -141,10 +132,8 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to create SkImage from GPUTexture!");
     }
-    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)));
 #else
     throw std::runtime_error(
         "MakeImageFromTexture is only available with the Graphite backend. "
@@ -179,23 +168,29 @@ public:
 #endif
   }
 
-  size_t getMemoryPressure() const override { return 1024; }
-
-  std::string getObjectType() const override { return "JsiSkImageFactory"; }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromEncoded),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromViewTag),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory,
-                                       MakeImageFromNativeBuffer),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory,
-                                       MakeImageFromNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeNull),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromTexture),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeTextureFromImage))
+  size_t getMemoryPressure() override { return 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "MakeImageFromEncoded",
+                      &JsiSkImageFactory::MakeImageFromEncoded);
+    installHostMethod(runtime, prototype, "MakeImageFromViewTag",
+                      &JsiSkImageFactory::MakeImageFromViewTag);
+    installHostMethod(runtime, prototype, "MakeImageFromNativeBuffer",
+                      &JsiSkImageFactory::MakeImageFromNativeBuffer);
+    installHostMethod(runtime, prototype, "MakeImageFromNativeTextureUnstable",
+                      &JsiSkImageFactory::MakeImageFromNativeTextureUnstable);
+    installHostMethod(runtime, prototype, "MakeImage",
+                      &JsiSkImageFactory::MakeImage);
+    installHostMethod(runtime, prototype, "MakeNull",
+                      &JsiSkImageFactory::MakeNull);
+    installHostMethod(runtime, prototype, "MakeImageFromTexture",
+                      &JsiSkImageFactory::MakeImageFromTexture);
+    installHostMethod(runtime, prototype, "MakeTextureFromImage",
+                      &JsiSkImageFactory::MakeTextureFromImage);
+  }
 
   explicit JsiSkImageFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(std::move(context)) {}
+      : JsiSkNativeObject<JsiSkImageFactory>(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFilter.h

@@ -5,7 +5,7 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkHostObjects.h"
+#include "JsiSkNativeObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -18,19 +18,29 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkImageFilter : public JsiSkWrappingSkPtrHostObject<SkImageFilter> {
+class JsiSkImageFilter
+    : public JsiSkWrappingSkPtrNativeObject<JsiSkImageFilter, SkImageFilter> {
 public:
+  static constexpr const char *CLASS_NAME = "ImageFilter";
+
   JsiSkImageFilter(std::shared_ptr<RNSkPlatformContext> context,
                    sk_sp<SkImageFilter> imageFilter)
-      : JsiSkWrappingSkPtrHostObject<SkImageFilter>(std::move(context),
-                                                    std::move(imageFilter)) {}
-
-  size_t getMemoryPressure() const override { return 1024 * 1024; }
-
-  std::string getObjectType() const override { return "JsiSkImageFilter"; }
-
-  EXPORT_JSI_API_TYPENAME(JsiSkImageFilter, ImageFilter)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFilter, dispose))
+      : JsiSkWrappingSkPtrNativeObject<JsiSkImageFilter, SkImageFilter>(
+            std::move(context), std::move(imageFilter)) {}
+
+  size_t getMemoryPressure() override { return 1024 * 1024; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installCommon(runtime, prototype);
+  }
+
+  /**
+    Returns the underlying object from a host object of this type
+   */
+  static sk_sp<SkImageFilter> fromValue(jsi::Runtime &runtime,
+                                        const jsi::Value &obj) {
+    return objectFromValue(runtime, obj);
+  }
 };
 
 } // namespace RNSkia