@shopify/react-native-skia 0.1.229 → 0.1.231

package/cpp/rnskia/dom/base/JsiDependencyManager.h

@@ -1,297 +0,0 @@
-#pragma once
-
-#include "JsiHostObject.h"
-
-#include "RNSkPlatformContext.h"
-
-#include "JsiDomNode.h"
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace RNSkia {
-
-static PropId PropNameSelector = JsiPropId::get("selector");
-static PropId PropNameValue = JsiPropId::get("value");
-
-class JsiDependencyManager
-    : public JsiHostObject,
-      public std::enable_shared_from_this<JsiDependencyManager> {
-public:
-  JsiDependencyManager(std::shared_ptr<RNSkPlatformContext> context,
-                       jsi::Runtime &runtime,
-                       const jsi::Value &registerValuesCallback)
-      : _registerValuesCallback(std::make_shared<jsi::Object>(
-            registerValuesCallback.asObject(runtime))),
-        JsiHostObject() {}
-
-  ~JsiDependencyManager() { unsubscribeAll(); }
-
-  /**
-   Call to unsubscribe all value listeners from the given node based on the
-   current list of subscriptions for the node. This function is typically called
-   when the node is unmounted or when one or more properties have changed. NOTE:
-   In this implementation we call unsubscribe directly without going through the
-   JSI method - but the method is kept for compatibility with the JS
-   implementation
-   */
-  JSI_HOST_FUNCTION(unsubscribeNode) {
-    // (node: Node<unknown>)
-    auto node =
-        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 0);
-    unsubscribeNode(node.get());
-    return jsi::Value::undefined();
-  }
-
-  /**
-   Adds listeners to the provided values so that the node is notified when a
-   value changes.
-   */
-  JSI_HOST_FUNCTION(subscribeNode) {
-    // subscribeNode<P>(node: Node<unknown>, props: AnimatedProps<P>)
-    auto node =
-        getArgumentAsHostObject<JsiDomNode>(runtime, arguments, count, 0);
-    auto nextProps = getArgumentAsObject(runtime, arguments, count, 1);
-
-    // Save unsubscribe callbacks
-    std::vector<
-        std::pair<std::shared_ptr<RNSkReadonlyValue>, std::function<void()>>>
-        unsubscribers;
-
-    // Enumerate registered keys for the given node to only handle known
-    // properties
-    node->getPropsContainer()->enumerateMappedProps(
-        [&](const PropId key, const std::vector<NodeProp *> &propMapping) {
-          auto jsValue = nextProps.getProperty(runtime, key);
-          JsiValue nativeValue(runtime, jsValue);
-
-          if (isAnimatedValue(nativeValue)) {
-            // Handle Skia Animation Values
-            auto animatedValue = getAnimatedValue(nativeValue);
-            auto unsubscribe = animatedValue->addListener(
-                [animatedValue, propMapping](jsi::Runtime &runtime) {
-                  // Get value from animation value
-                  auto nextJsValue = animatedValue->getCurrent(runtime);
-                  // Update all props that listens to this animation value
-                  for (auto &prop : propMapping) {
-                    prop->updateValue(runtime, nextJsValue);
-                  }
-                });
-
-            // Save unsubscribe methods
-            unsubscribers.push_back(std::make_pair(animatedValue, unsubscribe));
-
-          } else if (isSelector(nativeValue)) {
-            // Handle Skia Animation Value Selectors
-            auto animatedValue = std::dynamic_pointer_cast<RNSkReadonlyValue>(
-                nativeValue.getValue(PropNameValue).getAsHostObject());
-
-            auto selector =
-                nativeValue.getValue(PropNameSelector).getAsFunction();
-            // Add subscription to animated value in selector
-            auto unsubscribe = animatedValue->addListener(
-                [nativeValue, propMapping, selector = std::move(selector),
-                 animatedValue](jsi::Runtime &runtime) {
-                  // Get value from animation value
-                  jsi::Value jsValue = animatedValue->getCurrent(runtime);
-                  // Call selector to transform new value
-                  auto selectedJsValue =
-                      selector(runtime, jsi::Value::null(), &jsValue, 1);
-                  // Update all props that listens to this animation value
-                  for (auto &prop : propMapping) {
-                    prop->updateValue(runtime, selectedJsValue);
-                  }
-                });
-
-            // Save unsubscribe methods
-            unsubscribers.push_back(std::make_pair(animatedValue, unsubscribe));
-          }
-        });
-
-    // Now let's store the subscription info
-    _subscriptions.emplace(node.get(), unsubscribers);
-
-    // Set callback for unsubscribing
-    node->setDisposeCallback([node, weakSelf = weak_from_this()]() {
-      auto self = weakSelf.lock();
-      if (self) {
-        self->unsubscribeNode(node.get());
-      }
-    });
-
-    return jsi::Value::undefined();
-  }
-
-  /**
-   Called when the hosting container is mounted or updated. This ensures that we
-   have a ref to the underlying SkiaView so that we can registers redraw
-   listeners on values used in the current View automatically.
-   */
-  JSI_HOST_FUNCTION(update) {
-    if (_unregisterValues != nullptr) {
-      // unregisterValues is a pointer to unsubscribing to the automatic
-      // re-render when a value change
-      _unregisterValues->asFunction(runtime).call(runtime,
-                                                  jsi::Value::undefined(), 0);
-      _unregisterValues = nullptr;
-    }
-
-    // Now let's create connection between view and unique values
-    std::set<std::shared_ptr<RNSkReadonlyValue>> uniqueValues;
-
-    for (auto &nodeSub : _subscriptions) {
-      for (auto &sub : nodeSub.second) {
-        if (uniqueValues.count(sub.first) == 0) {
-          uniqueValues.emplace(sub.first);
-        }
-      }
-    }
-
-    // Copy to args
-    auto array = jsi::Array(runtime, uniqueValues.size());
-    size_t i = 0;
-    for (auto &el : uniqueValues) {
-      array.setValueAtIndex(runtime, i++,
-                            jsi::Object::createFromHostObject(runtime, el));
-    }
-
-    // Call JS registerValues callback
-    auto func = _registerValuesCallback->asFunction(runtime);
-    _unregisterValues = std::make_shared<jsi::Object>(
-        func.call(runtime, array, 1).asObject(runtime));
-
-    return jsi::Value::undefined();
-  }
-
-  /**
-   Called when the hosting container is unmounted or recreated. This ensures
-   that we remove all subscriptions to Skia values so that we don't have any
-   listeners left after the component is removed.
-
-    * Called when the hosting container is unmounted or recreated. This ensures
-   that we remove
-    * all subscriptions to Skia values so that we don't have any listeners left
-   after
-    * the component is removed.
-  */
-  JSI_HOST_FUNCTION(remove) {
-    if (_unregisterValues != nullptr) {
-      // unregisterValues is a pointer to unsubscribing to the automatic
-      // re-render when a value change
-      _unregisterValues->asFunction(runtime).call(runtime,
-                                                  jsi::Value::undefined(), 0);
-      _unregisterValues = nullptr;
-    }
-
-    unsubscribeAll();
-
-    _registerValuesCallback = nullptr;
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiDependencyManager, unsubscribeNode),
-                       JSI_EXPORT_FUNC(JsiDependencyManager, subscribeNode),
-                       JSI_EXPORT_FUNC(JsiDependencyManager, update),
-                       JSI_EXPORT_FUNC(JsiDependencyManager, remove))
-
-  /**
-   Constructor to add to the Api object
-   */
-  static const jsi::HostFunctionType
-  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
-    return JSI_HOST_FUNCTION_LAMBDA {
-      // Params: registerValues: (values: Array<SkiaValue<unknown>>) => () =>
-      // void
-      auto obj = std::make_shared<JsiDependencyManager>(context, runtime,
-                                                        arguments[0]);
-
-      return jsi::Object::createFromHostObject(runtime, std::move(obj));
-    };
-  }
-
-private:
-  /**
-   Removes all subscriptions
-   */
-  void unsubscribeAll() {
-    // Unregister all nodes
-    std::vector<JsiDomNode *> tmp;
-    tmp.reserve(_subscriptions.size());
-    for (auto &subInfo : _subscriptions) {
-      tmp.push_back(subInfo.first);
-    }
-    for (auto &node : tmp) {
-      unsubscribeNode(node);
-    }
-
-    // Clear all subscriptions
-    _subscriptions.clear();
-  }
-
-  /**
-   Unsubscribes from a given node
-   */
-  void unsubscribeNode(JsiDomNode *node) {
-    if (_subscriptions.count(node) > 0) {
-      auto subscriptions = _subscriptions.at(node);
-      for (auto &p : subscriptions) {
-        p.second();
-      }
-
-      // Remove node's subscriptions
-      _subscriptions.erase(node);
-
-      // Remove node's callback to avoid keeping
-      // cyclic dependencies between dep manager and the node
-      node->setDisposeCallback(nullptr);
-    }
-  }
-  /**
-   Returns true if the given value is a HostObject and it inherits from
-   RNSkReadonlyValue.
-   */
-  bool isAnimatedValue(JsiValue &value) {
-    return value.getType() == PropType::HostObject &&
-           std::dynamic_pointer_cast<RNSkReadonlyValue>(
-               value.getAsHostObject()) != nullptr;
-  }
-
-  /**
-   Returns the RNSkReadonlyValue pointer for a value that is an Animated value
-   */
-  std::shared_ptr<RNSkReadonlyValue> getAnimatedValue(JsiValue &value) {
-    return std::dynamic_pointer_cast<RNSkReadonlyValue>(
-        value.getAsHostObject());
-  }
-
-  /**
-   Returns true if the value is a selector. A Selector is a JS object that has
-   two properties, the selector and the the value. The selector is a function
-   that is used to transform the value - which is an animated skia value.
-   */
-  bool isSelector(JsiValue &value) {
-    // Handling selectors is rather easy, we just add
-    // a listener on the selector's callback and then we'll do the javascript
-    // resolving in the callback (which will always be on the Javascript
-    // thread)!
-    if (value.getType() == PropType::Object) {
-      if (value.hasValue(PropNameSelector) && value.hasValue(PropNameValue)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  std::shared_ptr<jsi::Object> _registerValuesCallback;
-  std::shared_ptr<jsi::Object> _unregisterValues;
-  std::map<JsiDomNode *,
-           std::vector<std::pair<std::shared_ptr<RNSkReadonlyValue>,
-                                 std::function<void()>>>>
-      _subscriptions;
-};
-} // namespace RNSkia

package/cpp/rnskia/dom/nodes/JsiCustomDrawingNode.h

@@ -1,127 +0,0 @@
-#pragma once
-
-#include "DrawingProp.h"
-#include "JsiDomDrawingNode.h"
-
-#include "JsiSkCanvas.h"
-#include "JsiSkPaint.h"
-
-#include <memory>
-#include <mutex>
-#include <utility>
-
-namespace RNSkia {
-
-class JsiCustomDrawingNode : public JsiDomDrawingNode,
-                             public JsiDomNodeCtor<JsiCustomDrawingNode> {
-public:
-  explicit JsiCustomDrawingNode(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiDomDrawingNode(context, "skCustomDrawing") {}
-
-protected:
-  void draw(DrawingContext *context) override {
-    if (_drawing != nullptr) {
-
-      // Only repaint the picture IF we did not get to the draw function
-      // from a redrawRequest after creating the picture!
-      if (!_inRedrawCycle || _drawingProp->isChanged()) {
-
-        float scaledWidth = context->getScaledWidth();
-        float scaledHeight = context->getScaledHeight();
-        auto paint = context->getPaint();
-        auto platformContext = getContext();
-        auto requestRedraw = context->getRequestRedraw();
-
-        // Create/set the paint/canvas wrappers
-        if (_jsiPaint == nullptr) {
-          _jsiPaint = std::make_shared<JsiSkPaint>(getContext(), *paint);
-        } else {
-          _jsiPaint->fromPaint(*paint);
-        }
-
-        if (_jsiCanvas == nullptr) {
-          _jsiCanvas = std::make_shared<JsiSkCanvas>(getContext());
-        }
-
-        // Run rendering on the javascript thread
-        getContext()->runOnJavascriptThread([this, platformContext,
-                                             requestRedraw, scaledWidth,
-                                             scaledHeight]() {
-          // Get the runtime
-          auto runtime = platformContext->getJsRuntime();
-
-          // Create the picture recorder
-          SkPictureRecorder recorder;
-          SkRTreeFactory factory;
-          SkCanvas *canvas =
-              recorder.beginRecording(scaledWidth, scaledHeight, &factory);
-
-          auto jsiCanvas =
-              std::make_shared<JsiSkCanvas>(platformContext, canvas);
-
-          // Create context wrapper
-          auto jsiCtx = jsi::Object(*runtime);
-          jsiCtx.setProperty(
-              *runtime, "paint",
-              jsi::Object::createFromHostObject(*runtime, this->_jsiPaint));
-
-          jsiCtx.setProperty(
-              *runtime, "canvas",
-              jsi::Object::createFromHostObject(*runtime, jsiCanvas));
-
-          std::array<jsi::Value, 1> args;
-          args[0] = std::move(jsiCtx);
-
-          // Draw
-          _drawing(*runtime, jsi::Value::undefined(),
-                   static_cast<const jsi::Value *>(args.data()), 1);
-
-          auto picture = recorder.finishRecordingAsPicture();
-          {
-            // Lock access to the picture property's setter
-            std::lock_guard<std::mutex> lock(_pictureLock);
-            this->_drawingProp->setPicture(picture);
-          }
-
-          // Ask view to redraw itself
-          _inRedrawCycle = true;
-          requestRedraw();
-        });
-      }
-    }
-
-    if (_drawingProp->isSet()) {
-      std::lock_guard<std::mutex> lock(_pictureLock);
-      context->getCanvas()->drawPicture(_drawingProp->getDerivedValue());
-      _inRedrawCycle = false;
-    }
-  }
-
-  void defineProperties(NodePropsContainer *container) override {
-    JsiDomDrawingNode::defineProperties(container);
-
-    NotifyNeedRenderCallback cb =
-        std::bind(&JsiCustomDrawingNode::notifyPictureNeeded, this,
-                  std::placeholders::_1);
-
-    _drawingProp = container->defineProperty<DrawingProp>("drawing", cb);
-  }
-
-private:
-  void notifyPictureNeeded(jsi::HostFunctionType drawing) {
-    _drawing = drawing;
-  }
-
-  jsi::HostFunctionType _drawing;
-
-  DrawingProp *_drawingProp;
-
-  std::array<jsi::Value, 1> _argsCache;
-  std::shared_ptr<JsiSkPaint> _jsiPaint;
-  std::shared_ptr<JsiSkCanvas> _jsiCanvas;
-
-  std::atomic<bool> _inRedrawCycle = {false};
-  std::mutex _pictureLock;
-};
-
-} // namespace RNSkia

package/cpp/rnskia/dom/props/DrawingProp.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-
-#include "JsiSkFont.h"
-
-#include <memory>
-
-namespace RNSkia {
-
-using NotifyNeedRenderCallback =
-    std::function<void(jsi::HostFunctionType drawing)>;
-
-class DrawingProp : public DerivedSkProp<SkPicture> {
-public:
-  DrawingProp(PropId name, NotifyNeedRenderCallback notifyPictureNeeded,
-              const std::function<void(BaseNodeProp *)> &onChange)
-      : _notifyPictureNeeded(notifyPictureNeeded), DerivedSkProp<SkPicture>(
-                                                       onChange) {
-    _drawingProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    auto drawingFunc = _drawingProp->value().getAsFunction();
-    _notifyPictureNeeded(drawingFunc);
-  }
-
-  void setPicture(sk_sp<SkPicture> picture) { setDerivedValue(picture); }
-
-private:
-  NodeProp *_drawingProp;
-  NotifyNeedRenderCallback _notifyPictureNeeded;
-};
-
-} // namespace RNSkia

package/cpp/rnskia/values/RNSkClockValue.h

@@ -1,140 +0,0 @@
-
-#pragma once
-
-#include "RNSkPlatformContext.h"
-#include "RNSkReadonlyValue.h"
-#include <jsi/jsi.h>
-
-#include <algorithm>
-#include <chrono>
-#include <functional>
-#include <memory>
-
-namespace RNSkia {
-namespace jsi = facebook::jsi;
-/**
- Implements a readonly Value that is updated every time the screen is redrawn.
- Its value will be the number of milliseconds since the animation value was
- started.
- */
-class RNSkClockValue : public RNSkReadonlyValue {
-  enum RNSkClockState { NotStarted = 0, Running = 1, Stopped = 2 };
-
-public:
-  RNSkClockValue(std::shared_ptr<RNSkPlatformContext> platformContext,
-                 size_t identifier, jsi::Runtime &runtime,
-                 const jsi::Value *arguments, size_t count)
-      : RNSkReadonlyValue(platformContext), _runtime(runtime),
-        _identifier(identifier) {
-    // Start by updating to zero (start value)
-    update(_runtime, static_cast<double>(0));
-  }
-
-  virtual ~RNSkClockValue() { stopClock(); }
-
-  JSI_HOST_FUNCTION(start) {
-    startClock();
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(stop) {
-    stopClock();
-    return jsi::Value::undefined();
-  }
-
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkReadonlyValue, addListener),
-                       JSI_EXPORT_FUNC(RNSkClockValue, start),
-                       JSI_EXPORT_FUNC(RNSkClockValue, stop))
-
-  virtual void startClock() {
-    if (_state == RNSkClockState::Running) {
-      return;
-    }
-
-    auto now = std::chrono::high_resolution_clock::now();
-    if (_state == RNSkClockState::NotStarted) {
-      _start = now;
-      _stop = now;
-    }
-
-    // Subtract pause time from start
-    auto timeSinceStop = now - _stop;
-    _start += timeSinceStop;
-
-    _state = RNSkClockState::Running;
-
-    getContext()->beginDrawLoop(
-        _identifier, [weakSelf = weak_from_this()](bool invalidated) {
-          auto self = weakSelf.lock();
-          if (self) {
-            std::dynamic_pointer_cast<RNSkClockValue>(self)->notifyUpdate(
-                invalidated);
-          }
-        });
-  }
-
-  virtual void stopClock() {
-    if (_state == RNSkClockState::Running) {
-      _state = RNSkClockState::Stopped;
-      _stop = std::chrono::high_resolution_clock::now();
-      getContext()->endDrawLoop(_identifier);
-    }
-  }
-
-protected:
-  virtual void tick(jsi::Runtime &runtime, const jsi::Value &value) {
-    RNSkClockValue::update(runtime, value);
-  }
-
-  void notifyUpdate(bool invalidated) {
-    if (invalidated) {
-      stopClock();
-      return;
-    }
-
-    if (_state != RNSkClockState::Running) {
-      return;
-    }
-
-    // Ensure we call any updates from the draw loop on the javascript thread
-    getContext()->runOnJavascriptThread(
-        // To ensure that this shared_ptr instance is not deallocated before we
-        // are done running the update lambda we pass a shared from this to the
-        // lambda scope.
-        [weakSelf = weak_from_this()]() {
-          auto self = weakSelf.lock();
-          if (self) {
-            auto selfClockValue =
-                std::dynamic_pointer_cast<RNSkClockValue>(self);
-            if (selfClockValue->getState() == RNSkClockState::Running) {
-              auto now = std::chrono::high_resolution_clock::now();
-              auto deltaFromStart =
-                  std::chrono::duration_cast<std::chrono::milliseconds>(
-                      now - selfClockValue->_start)
-                      .count();
-              selfClockValue->tick(selfClockValue->_runtime,
-                                   static_cast<double>(deltaFromStart));
-            }
-          }
-        });
-  }
-
-  /**
-   Returns the draw identifier for the clock. This identifier is used
-   for the draw loop.
-   */
-  size_t getIdentifier() { return _identifier; }
-
-  /**
-   Returns the state of the clock
-   */
-  RNSkClockState getState() { return _state; }
-
-  jsi::Runtime &_runtime;
-  size_t _identifier;
-  std::chrono::time_point<std::chrono::steady_clock> _start;
-  std::chrono::time_point<std::chrono::steady_clock> _stop;
-  std::atomic<RNSkClockState> _state = {RNSkClockState::NotStarted};
-};
-
-} // namespace RNSkia

package/cpp/rnskia/values/RNSkComputedValue.h

@@ -1,104 +0,0 @@
-
-#pragma once
-
-#include "RNSkPlatformContext.h"
-#include "RNSkReadonlyValue.h"
-#include <jsi/jsi.h>
-
-#include <algorithm>
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <vector>
-
-namespace RNSkia {
-namespace jsi = facebook::jsi;
-
-/**
-  Creates a readonly value that depends on one or more other values. The derived
-  value has a callback function that is used to calculate the new value when any
-  of the dependencies change.
- */
-class RNSkComputedValue : public RNSkReadonlyValue {
-public:
-  RNSkComputedValue(std::shared_ptr<RNSkPlatformContext> platformContext,
-                    jsi::Runtime &runtime, const jsi::Value *arguments,
-                    size_t count)
-      : RNSkReadonlyValue(platformContext) {
-    // Verify input
-    if (!arguments[0].isObject() ||
-        !arguments[0].asObject(runtime).isFunction(runtime)) {
-      throw jsi::JSError(runtime,
-                         "Expected callback function as first parameter");
-    }
-
-    if (!arguments[1].isObject() ||
-        !arguments[1].asObject(runtime).isArray(runtime)) {
-      throw jsi::JSError(runtime,
-                         "Expected array of dependencies as second parameter");
-    }
-
-    // Get callback for calculating result
-    _callback = std::make_shared<jsi::Function>(
-        arguments[0].asObject(runtime).asFunction(runtime));
-  }
-
-  void invalidate() override {
-    RNSkReadonlyValue::invalidate();
-
-    // Unregister listeners
-    for (const auto &unsubscribe : _unsubscribers) {
-      unsubscribe();
-    }
-    _unsubscribers.clear();
-  }
-
-  void initializeDependencies(jsi::Runtime &runtime,
-                              const jsi::Value *arguments, size_t count) {
-    // Save dependencies
-    std::vector<std::shared_ptr<RNSkReadonlyValue>> dependencies;
-
-    // Ensure that all dependencies are Values
-    auto deps = arguments[1].asObject(runtime).asArray(runtime);
-    const std::size_t size = deps.size(runtime);
-    dependencies.reserve(size);
-    for (size_t i = 0; i < size; ++i) {
-      auto dep = deps.getValueAtIndex(runtime, i);
-      if (!dep.isObject() || !dep.asObject(runtime).isHostObject(runtime)) {
-        continue;
-      }
-      auto value =
-          dep.asObject(runtime).asHostObject<RNSkReadonlyValue>(runtime);
-      if (value == nullptr) {
-        continue;
-      }
-      dependencies.push_back(value);
-    }
-
-    // register change handler on dependencies
-    _unsubscribers.reserve(_unsubscribers.size() + size);
-    for (const auto &dep : dependencies) {
-      _unsubscribers.push_back(dep->addListener([weakSelf = weak_from_this()](
-                                                    jsi::Runtime &runtime) {
-        auto self = weakSelf.lock();
-        if (self) {
-          auto selfAsThis = std::dynamic_pointer_cast<RNSkComputedValue>(self);
-          selfAsThis->dependencyUpdated(runtime);
-        }
-      }));
-    }
-
-    // Set initial value
-    dependencyUpdated(runtime);
-  }
-
-private:
-  void dependencyUpdated(jsi::Runtime &runtime) {
-    // Calculate new value
-    update(runtime, _callback->call(runtime, nullptr, 0));
-  }
-
-  std::shared_ptr<jsi::Function> _callback;
-  std::vector<std::function<void()>> _unsubscribers;
-};
-} // namespace RNSkia