@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/rnskia/dom/base/DrawingContext.cpp

@@ -0,0 +1,227 @@
+#include "DrawingContext.h"
+
+namespace RNSkia {
+
+DrawingContext::DrawingContext(std::shared_ptr<SkPaint> paint, double opacity)
+    : DrawingContext("root") {
+  _paint = paint;
+  _opacity = opacity;
+}
+
+DrawingContext::DrawingContext(DrawingContext *parent, const char *source)
+    : DrawingContext(source) {
+  _parent = parent;
+}
+
+std::shared_ptr<DrawingContext>
+DrawingContext::inheritContext(const char *source) {
+  auto result = std::make_shared<DrawingContext>(this, source);
+  _children.push_back(result);
+  return result;
+}
+
+size_t DrawingContext::getLevel() {
+  if (_parent != nullptr) {
+    return _parent->getLevel() + 1;
+  }
+  return 0;
+}
+
+std::string DrawingContext::getDebugDescription() {
+  std::string v = "ctx for " + std::string(_source) + ":";
+
+  if (_paint != nullptr) {
+    auto clr = _paint->getColor();
+    auto a = SkColorGetA(clr);
+    auto r = SkColorGetR(clr);
+    auto g = SkColorGetG(clr);
+    auto b = SkColorGetB(clr);
+
+    if (r > 0 || g > 0 || b > 0) {
+      v += " color:rgba(" + std::to_string(r) + ", " + std::to_string(g) +
+           ", " + std::to_string(b) + ", " + std::to_string(a) + ")";
+    }
+
+    if (_paint->getMaskFilter() != nullptr) {
+      v += " maskFilter:set";
+    }
+    auto blendMode = _paint->getBlendMode_or(SkBlendMode::kSrc);
+    if (blendMode != SkBlendMode::kSrc) {
+      v += " blendMode:" + std::to_string(static_cast<size_t>(blendMode));
+    }
+
+    v += " opacity:" + std::to_string(_opacity);
+    if (_paint->getPathEffect() != nullptr) {
+      v += " [PathEffect]";
+    }
+  } else {
+    v = v + "[inherited] " +
+        (_parent != nullptr ? _parent->getDebugDescription() : "");
+  }
+
+  v = v + "\n";
+
+  return v;
+}
+
+/**
+ Invalidate cache
+ */
+void DrawingContext::markAsChanged() {
+  markChildrenAsChanged();
+  _paint = nullptr;
+  _isChanged = true;
+}
+
+/**
+ Call to reset invalidate flag after render cycle
+ */
+void DrawingContext::resetChangedFlag() { _isChanged = false; }
+
+/**
+ Dispose and remove the drawing context from its parent.
+ */
+void DrawingContext::dispose() {
+  if (_parent != nullptr) {
+    auto position = std::find(_parent->_children.begin(),
+                              _parent->_children.end(), shared_from_this());
+
+    if (position != _parent->_children.end()) {
+      _parent->_children.erase(position);
+    }
+    // TODO: This is called from the JS thread so we need somehow to avoid
+    // rendering after setting this to null, and we also need to protect this
+    // section.
+    _parent = nullptr;
+  }
+}
+
+/**
+ Returns true if the current cache is changed
+ */
+bool DrawingContext::isChanged() { return _isChanged; }
+
+/**
+ Get/Sets the canvas object
+ */
+SkCanvas *DrawingContext::getCanvas() {
+  if (_parent != nullptr) {
+    return _parent->getCanvas();
+  }
+
+  return _canvas;
+}
+
+/**
+ Sets the canvas
+ */
+void DrawingContext::setCanvas(SkCanvas *canvas) { _canvas = canvas; }
+
+/**
+ Gets the paint object
+ */
+std::shared_ptr<const SkPaint> DrawingContext::getPaint() {
+  if (_paint != nullptr) {
+    return _paint;
+  }
+  return _parent->getPaint();
+}
+
+/**
+ To be able to mutate and change the paint in a context we need to mutate the
+ underlying paint object - otherwise we'll just use the parent paint object
+ (to avoid having to create multiple paint objects for nodes that does not
+ change the paint).
+ */
+std::shared_ptr<SkPaint> DrawingContext::getMutablePaint() {
+  if (_paint == nullptr) {
+    auto parentPaint = _parent->getPaint();
+    _paint = std::make_shared<SkPaint>(*parentPaint);
+    _opacity = _parent->getOpacity();
+  }
+  // Calling the getMutablePaint accessor implies that the paint
+  // is about to be mutatet and will therefore invalidate
+  // any child contexts to pick up changes from this context as
+  // the parent context.
+  markChildrenAsChanged();
+  return _paint;
+}
+
+/**
+ Sets the paint in the current sub context
+ */
+void DrawingContext::setMutablePaint(std::shared_ptr<SkPaint> paint) {
+  _paint = paint;
+}
+
+/**
+ Getd the opacity value
+ */
+double DrawingContext::getOpacity() {
+  if (_paint == nullptr) {
+    return _parent->getOpacity();
+  }
+  return _opacity;
+}
+
+/**
+ Sets the opacity value
+ */
+void DrawingContext::setOpacity(double opacity) {
+  getMutablePaint()->setAlphaf(_opacity);
+  _opacity = opacity;
+}
+
+/**
+ Clears the opacity value
+ */
+void DrawingContext::clearOpacity() {
+  if (_parent != nullptr) {
+    _opacity = _parent->getOpacity();
+  } else {
+    _opacity = 1.0;
+  }
+  markChildrenAsChanged();
+}
+
+float DrawingContext::getScaledWidth() {
+  if (_parent != nullptr) {
+    return _parent->getScaledWidth();
+  }
+  return _scaledWidth;
+}
+
+float DrawingContext::getScaledHeight() {
+  if (_parent != nullptr) {
+    return _parent->getScaledHeight();
+  }
+  return _scaledHeight;
+}
+
+void DrawingContext::setScaledWidth(float v) { _scaledWidth = v; }
+void DrawingContext::setScaledHeight(float v) { _scaledHeight = v; }
+
+void DrawingContext::setRequestRedraw(std::function<void()> &&requestRedraw) {
+  if (_parent != nullptr) {
+    _parent->setRequestRedraw(std::move(requestRedraw));
+  } else {
+    _requestRedraw = std::move(requestRedraw);
+  }
+}
+
+const std::function<void()> &DrawingContext::getRequestRedraw() {
+  if (_parent != nullptr) {
+    return _parent->getRequestRedraw();
+  }
+  return _requestRedraw;
+}
+
+DrawingContext::DrawingContext(const char *source) { _source = source; }
+
+void DrawingContext::markChildrenAsChanged() {
+  for (auto &child : _children) {
+    child->markAsChanged();
+  }
+}
+
+} // namespace RNSkia

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

@@ -0,0 +1,136 @@
+#pragma once
+
+#include "JsiHostObject.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkCanvas.h>
+#include <SkPaint.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class DrawingContext : public std::enable_shared_from_this<DrawingContext> {
+public:
+  /**
+   Creates a root drawing context with paint and opacity
+   */
+  DrawingContext(std::shared_ptr<SkPaint> paint, double opacity);
+
+  /**
+   Initilalizes a new draw context.
+   */
+  DrawingContext(DrawingContext *parent, const char *source);
+
+  /**
+   Factory for creating a child context that inherits from this context
+   */
+  std::shared_ptr<DrawingContext> inheritContext(const char *source);
+
+  size_t getLevel();
+
+  std::string getDebugDescription();
+
+  /**
+   Mark the drawing context and any child contexts as changed
+   */
+  void markAsChanged();
+
+  /**
+   Call to reset invalidate flag after render cycle
+   */
+  void resetChangedFlag();
+
+  /**
+   Dispose and remove the drawing context from its parent.
+   */
+  void dispose();
+
+  /**
+   Returns true if the current cache is changed
+   */
+  bool isChanged();
+
+  /**
+   Get/Sets the canvas object
+   */
+  SkCanvas *getCanvas();
+
+  /**
+   Sets the canvas
+   */
+  void setCanvas(SkCanvas *canvas);
+
+  /**
+   Gets the paint object
+   */
+  std::shared_ptr<const SkPaint> getPaint();
+
+  /**
+   To be able to mutate and change the paint in a context we need to mutate the
+   underlying paint object - otherwise we'll just use the parent paint object
+   (to avoid having to create multiple paint objects for nodes that does not
+   change the paint).
+   */
+  std::shared_ptr<SkPaint> getMutablePaint();
+
+  /**
+   Sets the paint in the current sub context
+   */
+  void setMutablePaint(std::shared_ptr<SkPaint> paint);
+
+  /**
+   Getd the opacity value
+   */
+  double getOpacity();
+
+  /**
+   Sets the opacity value
+   */
+  void setOpacity(double opacity);
+
+  /**
+   Clears the opacity
+   */
+  void clearOpacity();
+
+  float getScaledWidth();
+
+  float getScaledHeight();
+
+  void setScaledWidth(float v);
+  void setScaledHeight(float v);
+
+  void setRequestRedraw(std::function<void()> &&requestRedraw);
+  const std::function<void()> &getRequestRedraw();
+
+private:
+  explicit DrawingContext(const char *source);
+
+  void markChildrenAsChanged();
+
+  bool _isChanged = true;
+
+  std::shared_ptr<SkPaint> _paint;
+  double _opacity = 1.0f;
+
+  SkCanvas *_canvas = nullptr;
+  const char *_source;
+
+  DrawingContext *_parent = nullptr;
+  std::vector<std::shared_ptr<DrawingContext>> _children;
+
+  float _scaledWidth = -1;
+  float _scaledHeight = -1;
+
+  std::function<void()> _requestRedraw;
+};
+
+} // namespace RNSkia

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

@@ -0,0 +1,294 @@
+#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::Object &&registerValuesCallback)
+      : _registerValuesCallback(std::move(registerValuesCallback)),
+        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
+    for (const auto &propMapping :
+         node->getPropsContainer()->getMappedProperties()) {
+      auto key = propMapping.first;
+      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.second) {
+                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.second) {
+                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 = node.get(), weakSelf = weak_from_this()]() {
+          auto self = weakSelf.lock();
+          if (self) {
+            self->unsubscribeNode(node);
+          }
+        });
+
+    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();
+
+    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, getArgumentAsObject(runtime, arguments, count, 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;
+  }
+
+  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