@shopify/react-native-skia 0.1.210 → 0.1.212

package/cpp/api/JsiSkAnimatedImage.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "JsiSkImage.h"
+#include "SkBase64.h"
+#include "SkStream.h"
+#include "include/codec/SkEncodedImageFormat.h"
+
+#include "include/android/SkAnimatedImage.h"
+#include "include/codec/SkAndroidCodec.h"
+
+#pragma clang diagnostic pop
+
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkAnimatedImage
+    : public JsiSkWrappingSkPtrHostObject<SkAnimatedImage> {
+public:
+  // TODO-API: Properties?
+  JSI_HOST_FUNCTION(getCurrentFrame) {
+    auto image = getObject()->getCurrentFrame();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+  }
+
+  JSI_HOST_FUNCTION(currentFrameDuration) {
+    return static_cast<int>(getObject()->currentFrameDuration());
+  }
+
+  JSI_HOST_FUNCTION(decodeNextFrame) {
+    return static_cast<int>(getObject()->decodeNextFrame());
+  }
+
+  EXPORT_JSI_API_TYPENAME(JsiSkAnimatedImage, "AnimatedImage")
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkAnimatedImage, dispose),
+                       JSI_EXPORT_FUNC(JsiSkAnimatedImage, getCurrentFrame),
+                       JSI_EXPORT_FUNC(JsiSkAnimatedImage,
+                                       currentFrameDuration),
+                       JSI_EXPORT_FUNC(JsiSkAnimatedImage, decodeNextFrame))
+
+  JsiSkAnimatedImage(std::shared_ptr<RNSkPlatformContext> context,
+                     const sk_sp<SkAnimatedImage> image)
+      : JsiSkWrappingSkPtrHostObject<SkAnimatedImage>(std::move(context),
+                                                      std::move(image)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkAnimatedImageFactory.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiPromises.h"
+#include "JsiSkAnimatedImage.h"
+#include "JsiSkData.h"
+#include "JsiSkHostObjects.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkAnimatedImageFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeAnimatedImageFromEncoded) {
+    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+    auto codec = SkAndroidCodec::MakeFromData(data);
+    auto image = SkAnimatedImage::Make(std::move(codec));
+    if (image == nullptr) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkAnimatedImage>(getContext(), std::move(image)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkAnimatedImageFactory,
+                                       MakeAnimatedImageFromEncoded))
+
+  explicit JsiSkAnimatedImageFactory(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkApi.h

@@ -6,6 +6,8 @@
 
 #include "JsiSkHostObjects.h"
 
+#include "JsiSkAnimatedImage.h"
+#include "JsiSkAnimatedImageFactory.h"
 #include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
 #include "JsiSkColorFilterFactory.h"
@@ -79,6 +81,8 @@ public:
     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",

package/cpp/api/JsiSkImage.h

@@ -64,23 +64,32 @@ public:
         std::make_shared<JsiSkShader>(getContext(), std::move(shader)));
   }
 
-  JSI_HOST_FUNCTION(encodeToBytes) {
+  sk_sp<SkData> encodeImageData(const jsi::Value *arguments, size_t count) {
     // Get optional parameters
     auto format =
         count >= 1 ? static_cast<SkEncodedImageFormat>(arguments[0].asNumber())
                    : SkEncodedImageFormat::kPNG;
-    auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
 
-    // Get data
+    auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
+    auto image = getObject();
+    if (image->isTextureBacked()) {
+      image = image->makeNonTextureImage();
+    }
     sk_sp<SkData> data;
     if (format == SkEncodedImageFormat::kJPEG) {
       SkJpegEncoder::Options options;
       options.fQuality = quality;
-      data = SkJpegEncoder::Encode(nullptr, getObject().get(), options);
+      data = SkJpegEncoder::Encode(nullptr, image.get(), options);
     } else {
       SkPngEncoder::Options options;
-      data = SkPngEncoder::Encode(nullptr, getObject().get(), options);
+      data = SkPngEncoder::Encode(nullptr, image.get(), options);
     }
+    return data;
+  }
+
+  JSI_HOST_FUNCTION(encodeToBytes) {
+    auto data = encodeImageData(arguments, count);
+
     auto arrayCtor =
         runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
     size_t size = data->size();
@@ -99,25 +108,8 @@ public:
   }
 
   JSI_HOST_FUNCTION(encodeToBase64) {
-    // Get optional parameters
-    auto format =
-        count >= 1 ? static_cast<SkEncodedImageFormat>(arguments[0].asNumber())
-                   : SkEncodedImageFormat::kPNG;
+    auto data = encodeImageData(arguments, count);
 
-    auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
-    auto image = getObject();
-    if (image->isTextureBacked()) {
-      image = image->makeNonTextureImage();
-    }
-    sk_sp<SkData> data;
-    if (format == SkEncodedImageFormat::kJPEG) {
-      SkJpegEncoder::Options options;
-      options.fQuality = quality;
-      data = SkJpegEncoder::Encode(nullptr, image.get(), options);
-    } else {
-      SkPngEncoder::Options options;
-      data = SkPngEncoder::Encode(nullptr, image.get(), options);
-    }
     auto len = SkBase64::Encode(data->bytes(), data->size(), nullptr);
     auto buffer = std::string(len, 0);
     SkBase64::Encode(data->bytes(), data->size(),

package/cpp/api/JsiSkPath.h

@@ -27,6 +27,7 @@
 #include "SkStrokeRec.h"
 #include "SkTextUtils.h"
 #include "SkTrimPathEffect.h"
+#include "src/core/SkPathPriv.h"
 
 #pragma clang diagnostic pop
 
@@ -36,6 +37,13 @@ namespace jsi = facebook::jsi;
 
 class JsiSkPath : public JsiSkWrappingSharedPtrHostObject<SkPath> {
 private:
+  static const int MOVE = 0;
+  static const int LINE = 1;
+  static const int QUAD = 2;
+  static const int CONIC = 3;
+  static const int CUBIC = 4;
+  static const int CLOSE = 5;
+
   float pinT(double value) {
     // Clamp the double value between 0 and 1 and then cast it to float
     return static_cast<float>(std::clamp(value, 0.0, 1.0));
@@ -498,30 +506,66 @@ public:
   JSI_HOST_FUNCTION(toCmds) {
     auto path = *getObject();
     auto cmds = jsi::Array(runtime, path.countVerbs());
-    auto it = SkPath::Iter(path, false);
-    //                       { "Move", "Line", "Quad", "Conic", "Cubic",
-    //                       "Close", "Done" };
-    const int pointCount[] = {1, 1, 2, 2, 3, 0, 0};
-    const int cmdCount[] = {3, 3, 5, 6, 7, 1, 0};
-    SkPoint points[4];
-    SkPath::Verb verb;
-    auto k = 0;
-    while (SkPath::kDone_Verb != (verb = it.next(points))) {
-      auto verbVal = static_cast<int>(verb);
-      auto cmd = jsi::Array(runtime, cmdCount[verbVal]);
-      auto j = 0;
-      cmd.setValueAtIndex(runtime, j++, jsi::Value(verbVal));
-      for (int i = 0; i < pointCount[verbVal]; ++i) {
-        cmd.setValueAtIndex(runtime, j++,
-                            jsi::Value(static_cast<double>(points[1 + i].fX)));
-        cmd.setValueAtIndex(runtime, j++,
-                            jsi::Value(static_cast<double>(points[1 + i].fY)));
+    auto j = 0;
+    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
+      switch (verb) {
+      case SkPathVerb::kMove: {
+        auto cmd = jsi::Array(runtime, 3);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(MOVE));
+        cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[0].x()));
+        cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[0].y()));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
+      }
+      case SkPathVerb::kLine: {
+        auto cmd = jsi::Array(runtime, 3);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(LINE));
+        cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
+        cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
+      }
+      case SkPathVerb::kQuad: {
+        auto cmd = jsi::Array(runtime, 5);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(QUAD));
+        cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
+        cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
+        cmd.setValueAtIndex(runtime, 3, static_cast<double>(pts[2].x()));
+        cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
+      }
+      case SkPathVerb::kConic: {
+        auto cmd = jsi::Array(runtime, 6);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(CONIC));
+        cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
+        cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
+        cmd.setValueAtIndex(runtime, 3, static_cast<double>(pts[2].x()));
+        cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
+        cmd.setValueAtIndex(runtime, 5, static_cast<double>(*w));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
+      }
+      case SkPathVerb::kCubic: {
+        auto cmd = jsi::Array(runtime, 7);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(CUBIC));
+        cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
+        cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
+        cmd.setValueAtIndex(runtime, 3, static_cast<double>(pts[2].x()));
+        cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
+        cmd.setValueAtIndex(runtime, 5, static_cast<double>(pts[3].x()));
+        cmd.setValueAtIndex(runtime, 6, static_cast<double>(pts[3].y()));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
+      }
+      case SkPathVerb::kClose: {
+        auto cmd = jsi::Array(runtime, 1);
+        cmd.setValueAtIndex(runtime, 0, static_cast<double>(CLOSE));
+        cmds.setValueAtIndex(runtime, j, cmd);
+        break;
       }
-      if (SkPath::kConic_Verb == verb) {
-        cmd.setValueAtIndex(runtime, j,
-                            jsi::Value(static_cast<double>(it.conicWeight())));
       }
-      cmds.setValueAtIndex(runtime, k++, cmd);
+      j++;
     }
     return cmds;
   }