@pompadour/react-native-skia 1.4.0

package/cpp/api/JsiSkTextStyle.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "modules/skparagraph/include/Paragraph.h"
+#include "modules/skparagraph/include/ParagraphStyle.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ Implementation of the TextStyle object in JSI for the paragraph builder
+ */
+class JsiSkTextStyle {
+public:
+  static para::TextStyle fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+
+    para::TextStyle retVal;
+
+    // Accept undefined && null
+    if (value.isUndefined() || value.isNull()) {
+      return retVal;
+    }
+
+    // Read values from the argument - expected to be a TextStyle shaped object
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime, "Expected SkTextStyle as first argument");
+    }
+
+    auto object = value.asObject(runtime);
+
+    if (object.hasProperty(runtime, "backgroundColor")) {
+      auto propValue = object.getProperty(runtime, "backgroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setBackgroundPaint(p);
+    }
+    if (object.hasProperty(runtime, "color")) {
+      auto propValue = object.getProperty(runtime, "color");
+      retVal.setColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decoration")) {
+      auto propValue = object.getProperty(runtime, "decoration");
+      retVal.setDecoration(
+          static_cast<para::TextDecoration>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "decorationColor")) {
+      auto propValue = object.getProperty(runtime, "decorationColor");
+      retVal.setDecorationColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decorationThickness")) {
+      auto propValue = object.getProperty(runtime, "decorationThickness");
+      retVal.setDecorationThicknessMultiplier(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "decorationStyle")) {
+      auto propValue = object.getProperty(runtime, "decorationStyle");
+      retVal.setDecorationStyle(
+          static_cast<para::TextDecorationStyle>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "fontFamilies")) {
+      auto propValue = object.getProperty(runtime, "fontFamilies")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      std::vector<SkString> families(size);
+      for (size_t i = 0; i < size; ++i) {
+        families[i] = propValue.getValueAtIndex(runtime, i)
+                          .asString(runtime)
+                          .utf8(runtime)
+                          .c_str();
+      }
+      retVal.setFontFamilies(families);
+    }
+    if (object.hasProperty(runtime, "fontFeatures")) {
+      auto propValue = object.getProperty(runtime, "fontFeatures")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetFontFeatures();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto name = element.getProperty(runtime, "name")
+                        .asString(runtime)
+                        .utf8(runtime);
+        auto value = element.getProperty(runtime, "value").asNumber();
+        retVal.addFontFeature(SkString(name), value);
+      }
+    }
+    if (object.hasProperty(runtime, "fontSize")) {
+      auto propValue = object.getProperty(runtime, "fontSize");
+      retVal.setFontSize(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "fontStyle")) {
+      auto propValue =
+          object.getProperty(runtime, "fontStyle").asObject(runtime);
+      auto weight = static_cast<SkFontStyle::Weight>(
+          propValue.hasProperty(runtime, "weight")
+              ? propValue.getProperty(runtime, "weight").asNumber()
+              : SkFontStyle::Weight::kNormal_Weight);
+
+      auto width = static_cast<SkFontStyle::Width>(
+          propValue.hasProperty(runtime, "width")
+              ? propValue.getProperty(runtime, "width").asNumber()
+              : SkFontStyle::Width::kNormal_Width);
+
+      auto slant = static_cast<SkFontStyle::Slant>(
+          propValue.hasProperty(runtime, "slant")
+              ? propValue.getProperty(runtime, "slant").asNumber()
+              : SkFontStyle::Slant::kUpright_Slant);
+
+      retVal.setFontStyle(SkFontStyle(weight, width, slant));
+    }
+    if (object.hasProperty(runtime, "foregroundColor")) {
+      auto propValue = object.getProperty(runtime, "foregroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setForegroundColor(p);
+    }
+    if (object.hasProperty(runtime, "heightMultiplier")) {
+      auto propValue = object.getProperty(runtime, "heightMultiplier");
+      retVal.setHeight(propValue.asNumber());
+      retVal.setHeightOverride(true);
+    }
+    if (object.hasProperty(runtime, "halfLeading")) {
+      auto propValue = object.getProperty(runtime, "halfLeading");
+      retVal.setHalfLeading(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "letterSpacing")) {
+      auto propValue = object.getProperty(runtime, "letterSpacing");
+      retVal.setLetterSpacing(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "locale")) {
+      auto propValue = object.getProperty(runtime, "locale");
+      retVal.setLocale(SkString(propValue.asString(runtime).utf8(runtime)));
+    }
+    if (object.hasProperty(runtime, "shadows")) {
+      auto propValue = object.getProperty(runtime, "shadows")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetShadows();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto color = element.hasProperty(runtime, "color")
+                         ? JsiSkColor::fromValue(
+                               runtime, element.getProperty(runtime, "color"))
+                         : SK_ColorBLACK;
+        SkPoint offset =
+            element.hasProperty(runtime, "offset")
+                ? *JsiSkPoint::fromValue(runtime,
+                                         element.getProperty(runtime, "offset"))
+                       .get()
+                : SkPoint::Make(0, 0);
+        auto blurSigma =
+            element.hasProperty(runtime, "blurRadius")
+                ? element.getProperty(runtime, "blurRadius").asNumber()
+                : 0;
+        retVal.addShadow(para::TextShadow(color, offset, blurSigma));
+      }
+    }
+    if (object.hasProperty(runtime, "textBaseline")) {
+      auto propValue = object.getProperty(runtime, "textBaseline");
+      retVal.setTextBaseline(
+          static_cast<para::TextBaseline>(propValue.asNumber()));
+    }
+
+    return retVal;
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypeface.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+#include "RNSkLog.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkTypeface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkTypeface : public JsiSkWrappingSkPtrHostObject<SkTypeface> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiSkTypeface, Typeface)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypeface, getGlyphIDs),
+                       JSI_EXPORT_FUNC(JsiSkTypeface, dispose))
+
+  JsiSkTypeface(std::shared_ptr<RNSkPlatformContext> context,
+                sk_sp<SkTypeface> typeface)
+      : JsiSkWrappingSkPtrHostObject(std::move(context), std::move(typeface)) {}
+
+  JSI_HOST_FUNCTION(getGlyphIDs) {
+    auto str = arguments[0].asString(runtime).utf8(runtime);
+    int numGlyphIDs =
+        count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
+            ? static_cast<int>(arguments[1].asNumber())
+            : getObject()->textToGlyphs(str.c_str(), str.length(),
+                                        SkTextEncoding::kUTF8, nullptr, 0);
+    std::vector<SkGlyphID> glyphIDs;
+    glyphIDs.resize(numGlyphIDs);
+    getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
+                              static_cast<SkGlyphID *>(glyphIDs.data()),
+                              numGlyphIDs);
+    auto jsiGlyphIDs = jsi::Array(runtime, numGlyphIDs);
+    for (int i = 0; i < numGlyphIDs; i++) {
+      jsiGlyphIDs.setValueAtIndex(runtime, i,
+                                  jsi::Value(static_cast<int>(glyphIDs[i])));
+    }
+    return jsiGlyphIDs;
+  }
+
+  /**
+   Returns the jsi object from a host object of this type
+  */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            sk_sp<SkTypeface> tf) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkTypeface>(std::move(context), std::move(tf)));
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypefaceFactory.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkData.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkTypeface.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkTypefaceFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
+    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+    auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
+    auto typeface = fontMgr->makeFromData(std::move(data));
+    if (typeface == nullptr) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFactory,
+                                       MakeFreeTypeFaceFromData))
+
+  explicit JsiSkTypefaceFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkFontStyle.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkTypeface.h"
+
+#include "RNSkLog.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkFont.h"
+#include "modules/skparagraph/include/TypefaceFontProvider.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+namespace para = skia::textlayout;
+
+class JsiSkTypefaceFontProvider
+    : public JsiSkWrappingSkPtrHostObject<para::TypefaceFontProvider> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiSkTypefaceFontProvider, TypefaceFontProvider)
+
+  JSI_EXPORT_FUNCTIONS(
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, dispose),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, registerFont),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, matchFamilyStyle),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, countFamilies),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, getFamilyName))
+
+  JSI_HOST_FUNCTION(registerFont) {
+    sk_sp<SkTypeface> typeface =
+        JsiSkTypeface::fromValue(runtime, arguments[0]);
+    SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
+    auto result = getObject()->registerTypeface(typeface, familyName);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(matchFamilyStyle) {
+    auto name = count > 0 ? arguments[0].asString(runtime).utf8(runtime) : "";
+    auto fontStyle =
+        count > 1 ? JsiSkFontStyle::fromValue(runtime, arguments[1]) : nullptr;
+    if (name == "" || fontStyle == nullptr) {
+      throw std::runtime_error("matchFamilyStyle requires a name and a style");
+    }
+    auto set = getObject()->onMatchFamily(name.c_str());
+    if (!set) {
+      throw std::runtime_error("Could not find font family " + name);
+    }
+    auto typeface = set->matchStyle(*fontStyle);
+    if (!typeface) {
+      throw std::runtime_error("Could not find font style for " + name);
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+  }
+
+  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+
+  JSI_HOST_FUNCTION(getFamilyName) {
+    auto i = static_cast<int>(arguments[0].asNumber());
+    SkString name;
+    getObject()->getFamilyName(i, &name);
+    return jsi::String::createFromUtf8(runtime, name.c_str());
+  }
+
+  JsiSkTypefaceFontProvider(std::shared_ptr<RNSkPlatformContext> context,
+                            sk_sp<para::TypefaceFontProvider> tfProvider)
+      : JsiSkWrappingSkPtrHostObject(std::move(context),
+                                     std::move(tfProvider)) {}
+
+  /**
+   Returns the jsi object from a host object of this type
+  */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            sk_sp<para::TypefaceFontProvider> tfProvider) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
+                     std::move(context), std::move(tfProvider)));
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypefaceFontProviderFactory.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkData.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkTypefaceFontProvider.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+namespace para = skia::textlayout;
+
+class JsiSkTypefaceFontProviderFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
+                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFontProviderFactory, Make))
+
+  explicit JsiSkTypefaceFontProviderFactory(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkVertices.h

@@ -0,0 +1,144 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkVertices.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkVertices : public JsiSkWrappingSkPtrHostObject<SkVertices> {
+public:
+  JsiSkVertices(std::shared_ptr<RNSkPlatformContext> context,
+                sk_sp<SkVertices> vertices)
+      : JsiSkWrappingSkPtrHostObject<SkVertices>(std::move(context),
+                                                 std::move(vertices)) {}
+
+  EXPORT_JSI_API_TYPENAME(JsiSkVertices, Vertices)
+
+  JSI_HOST_FUNCTION(bounds) {
+    const auto &result = getObject()->bounds();
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkRect>(getContext(), result));
+  }
+
+  JSI_HOST_FUNCTION(uniqueID) {
+    return static_cast<double>(getObject()->uniqueID());
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkVertices, bounds),
+                       JSI_EXPORT_FUNC(JsiSkVertices, uniqueID),
+                       JSI_EXPORT_FUNC(JsiSkVertices, dispose))
+
+  /**
+   * Creates the function for construction a new instance of the SkVertices
+   * wrapper
+   * @param context platform context
+   * @return A function for creating a new host object wrapper for the
+   * SkVertices class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      auto mode = static_cast<SkVertices::VertexMode>(arguments[0].getNumber());
+      std::vector<SkPoint> positions;
+      std::vector<SkPoint> texs;
+      std::vector<SkColor> colors;
+      std::vector<uint16_t> indices;
+
+      auto jsiPositions = arguments[1].asObject(runtime).asArray(runtime);
+      auto positionsSize = static_cast<int>(jsiPositions.size(runtime));
+      positions.reserve(positionsSize);
+      for (int i = 0; i < positionsSize; i++) {
+        std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
+            runtime,
+            jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
+        positions.push_back(*point.get());
+      }
+
+      if (count >= 3 && !arguments[2].isNull() && !arguments[2].isUndefined()) {
+        auto jsiTexs = arguments[2].asObject(runtime).asArray(runtime);
+        auto texsSize = jsiTexs.size(runtime);
+        texs.reserve(texsSize);
+        for (int i = 0; i < texsSize; i++) {
+          auto point = JsiSkPoint::fromValue(
+              runtime, jsiTexs.getValueAtIndex(runtime, i).asObject(runtime));
+          texs.push_back(*point.get());
+        }
+      }
+
+      if (count >= 4 && !arguments[3].isNull() && !arguments[3].isUndefined()) {
+        auto jsiColors = arguments[3].asObject(runtime).asArray(runtime);
+        auto colorsSize = jsiColors.size(runtime);
+        colors.reserve(colorsSize);
+        for (int i = 0; i < colorsSize; i++) {
+          SkColor color = JsiSkColor::fromValue(
+              runtime, jsiColors.getValueAtIndex(runtime, i));
+          colors.push_back(color);
+        }
+      }
+
+      int indicesSize = 0;
+      if (count >= 5 && !arguments[4].isNull() && !arguments[4].isUndefined()) {
+        auto jsiIndices = arguments[4].asObject(runtime).asArray(runtime);
+        indicesSize = static_cast<int>(jsiIndices.size(runtime));
+        indices.reserve(indicesSize);
+        for (int i = 0; i < indicesSize; i++) {
+          uint16_t index = jsiIndices.getValueAtIndex(runtime, i).asNumber();
+          indices.push_back(index);
+        }
+      }
+      // TODO: this is the technic used in CanvasKit:
+      // https://github.com/google/skia/blob/main/modules/canvaskit/interface.js#L1216
+      // Note that the isVolatile parameter is unused when using MakeCopy()
+      //                auto isVolatile = count >= 6 && !arguments[5].isNull()
+      //                && !arguments[5].isUndefined() ? arguments[5].getBool()
+      //                : false; auto flags = 0;
+      //                // These flags are from SkVertices.h and should be kept
+      //                in sync with those. if (texs.size() > 0) {
+      //                    flags |= (1 << 0);
+      //                }
+      //                if (colors.size() > 0) {
+      //                    flags |= (1 << 1);
+      //                }
+      //                if (!isVolatile) {
+      //                    flags |= (1 << 2);
+      //                }
+      //                auto builder = SkVertices::Builder(mode,
+      //                positionsSize/2, indicesSize, flags);
+      //                std::copy(positions.data(), positions.data() +
+      //                positionsSize, builder.positions()); if
+      //                (builder.texCoords()) {
+      //                    std::copy(std::begin(texs), std::end(texs),
+      //                    builder.texCoords());
+      //                }
+      //                if (builder.colors()) {
+      //                    std::copy(std::begin(colors), std::end(colors),
+      //                    builder.colors());
+      //                }
+      //                if (builder.indices()) {
+      //                    std::copy(std::begin(indices), std::end(indices),
+      //                    builder.indices());
+      //                }
+      //                auto vertices = builder.detach();
+      auto vertices = SkVertices::MakeCopy(
+          mode, positionsSize, positions.data(), texs.data(), colors.data(),
+          indicesSize, indices.data());
+      return jsi::Object::createFromHostObject(
+          runtime,
+          std::make_shared<JsiSkVertices>(context, std::move(vertices)));
+    };
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiVideo.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <memory>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "JsiSkHostObjects.h"
+#include "RNSkLog.h"
+#include <jsi/jsi.h>
+
+#include "JsiSkPaint.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRect.h"
+#include "JsiSkTypeface.h"
+
+#include "RNSkVideo.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkFont.h"
+#include "include/core/SkFontMetrics.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiVideo : public JsiSkWrappingSharedPtrHostObject<RNSkVideo> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiVideo, Video)
+
+  JSI_HOST_FUNCTION(nextImage) {
+    double timestamp = 0;
+    auto video = getObject();
+    auto image = video->nextImage(&timestamp);
+    if (!image) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+  }
+
+  JSI_HOST_FUNCTION(duration) { return getObject()->duration(); }
+
+  JSI_HOST_FUNCTION(framerate) { return getObject()->framerate(); }
+
+  JSI_HOST_FUNCTION(seek) {
+    double timestamp = arguments[0].asNumber();
+    getObject()->seek(timestamp);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(rotation) {
+    auto context = getContext();
+    auto rot = getObject()->getRotationInDegrees();
+    return jsi::Value(static_cast<double>(rot));
+  }
+
+  JSI_HOST_FUNCTION(size) {
+    auto context = getContext();
+    auto size = getObject()->getSize();
+    auto result = jsi::Object(runtime);
+    result.setProperty(runtime, "width", static_cast<double>(size.width()));
+    result.setProperty(runtime, "height", static_cast<double>(size.height()));
+    return result;
+  }
+
+  JSI_HOST_FUNCTION(play) {
+    getObject()->play();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(pause) {
+    getObject()->pause();
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(setVolume) {
+    auto volume = arguments[0].asNumber();
+    getObject()->setVolume(static_cast<float>(volume));
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+      JSI_EXPORT_FUNC(JsiVideo, nextImage), JSI_EXPORT_FUNC(JsiVideo, duration),
+      JSI_EXPORT_FUNC(JsiVideo, framerate), JSI_EXPORT_FUNC(JsiVideo, seek),
+      JSI_EXPORT_FUNC(JsiVideo, rotation), JSI_EXPORT_FUNC(JsiVideo, size),
+      JSI_EXPORT_FUNC(JsiVideo, play), JSI_EXPORT_FUNC(JsiVideo, pause),
+      JSI_EXPORT_FUNC(JsiVideo, setVolume), JSI_EXPORT_FUNC(JsiVideo, dispose))
+
+  JsiVideo(std::shared_ptr<RNSkPlatformContext> context,
+           std::shared_ptr<RNSkVideo> video)
+      : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(video)) {
+  }
+
+  /**
+   * Creates the function for construction a new instance of the SkFont
+   * wrapper
+   * @param context Platform context
+   * @return A function for creating a new host object wrapper for the SkFont
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      auto url = arguments[0].asString(runtime).utf8(runtime);
+      auto video = context->createVideo(url);
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime,
+          std::make_shared<JsiVideo>(std::move(context), std::move(video)));
+    };
+  }
+};
+
+} // namespace RNSkia