@shopify/react-native-skia 0.1.178 → 0.1.181

package/android/build.gradle

@@ -28,6 +28,11 @@ def safeExtGet(prop, fallback) {
 
 apply plugin: 'com.android.library'
 
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 static def findNodeModules(baseDir) {
   def basePath = baseDir.toPath().normalize()
   // Node's module resolution algorithm searches up to the root directory,
@@ -119,7 +124,7 @@ android {
         externalNativeBuild {
             cmake {
                 cppFlags "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
-                abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+                abiFilters (*reactNativeArchitectures())
                 arguments '-DANDROID_STL=c++_shared',
                           "-DREACT_NATIVE_VERSION=${REACT_NATIVE_VERSION}",
                           "-DNODE_MODULES_DIR=${nodeModules}",

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -1,5 +1,3 @@
-#pragma once
-
 #include "RuntimeAwareCache.h"
 
 namespace RNJsi {

package/cpp/rnskia/RNSkDomView.cpp

@@ -22,7 +22,7 @@ RNSkDomRenderer::RNSkDomRenderer(std::function<void()> requestRedraw,
 
 RNSkDomRenderer::~RNSkDomRenderer() {
   if (_root != nullptr) {
-    _root->dispose();
+    _root->dispose(true);
     _root = nullptr;
   }
 }
@@ -63,7 +63,7 @@ void RNSkDomRenderer::renderImmediate(
 void RNSkDomRenderer::setRoot(std::shared_ptr<JsiDomRenderNode> node) {
   std::lock_guard<std::mutex> lock(_rootLock);
   if (_root != nullptr) {
-    _root->dispose();
+    _root->dispose(true);
     _root = nullptr;
   }
   _root = node;

package/cpp/rnskia/RNSkPlatformContext.h

@@ -112,8 +112,8 @@ public:
 
   /**
    * Creates an offscreen surface
-   * @param width
-   * @param height
+   * @param width width of the surface
+   * @param height height of the surface
    * @return sk_sp<SkSurface>
    */
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;

package/cpp/rnskia/RNSkView.h

@@ -88,10 +88,11 @@ protected:
 
 class RNSkImageCanvasProvider : public RNSkCanvasProvider {
 public:
-  RNSkImageCanvasProvider(std::function<void()> requestRedraw, float width,
+  RNSkImageCanvasProvider(std::shared_ptr<RNSkPlatformContext> context,
+                          std::function<void()> requestRedraw, float width,
                           float height)
       : RNSkCanvasProvider(requestRedraw), _width(width), _height(height) {
-    _surface = SkSurface::MakeRasterN32Premul(_width, _height);
+    _surface = context->makeOffscreenSurface(_width, _height);
   }
 
   /**
@@ -261,8 +262,9 @@ public:
    Renders the view into an SkImage instead of the screen.
    */
   sk_sp<SkImage> makeImageSnapshot(std::shared_ptr<SkRect> bounds) {
+
     auto provider = std::make_shared<RNSkImageCanvasProvider>(
-        std::bind(&RNSkView::requestRedraw, this),
+        getPlatformContext(), std::bind(&RNSkView::requestRedraw, this),
         _canvasProvider->getScaledWidth(), _canvasProvider->getScaledHeight());
 
     _renderer->renderImmediate(provider);

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

@@ -23,8 +23,10 @@ class JsiDependencyManager
       public std::enable_shared_from_this<JsiDependencyManager> {
 public:
   JsiDependencyManager(std::shared_ptr<RNSkPlatformContext> context,
-                       jsi::Object &&registerValuesCallback)
-      : _registerValuesCallback(std::move(registerValuesCallback)),
+                       jsi::Runtime &runtime,
+                       const jsi::Value &registerValuesCallback)
+      : _registerValuesCallback(std::make_shared<jsi::Object>(
+            registerValuesCallback.asObject(runtime))),
         JsiHostObject() {}
 
   ~JsiDependencyManager() { unsubscribeAll(); }
@@ -158,7 +160,7 @@ public:
     }
 
     // Call JS registerValues callback
-    auto func = _registerValuesCallback.asFunction(runtime);
+    auto func = _registerValuesCallback->asFunction(runtime);
     _unregisterValues = std::make_shared<jsi::Object>(
         func.call(runtime, array, 1).asObject(runtime));
 
@@ -187,6 +189,8 @@ public:
 
     unsubscribeAll();
 
+    _registerValuesCallback = nullptr;
+
     return jsi::Value::undefined();
   }
 
@@ -203,8 +207,8 @@ public:
     return JSI_HOST_FUNCTION_LAMBDA {
       // Params: registerValues: (values: Array<SkiaValue<unknown>>) => () =>
       // void
-      auto obj = std::make_shared<JsiDependencyManager>(
-          context, getArgumentAsObject(runtime, arguments, count, 0));
+      auto obj = std::make_shared<JsiDependencyManager>(context, runtime,
+                                                        arguments[0]);
 
       return jsi::Object::createFromHostObject(runtime, std::move(obj));
     };
@@ -283,7 +287,7 @@ private:
     return false;
   }
 
-  jsi::Object _registerValuesCallback;
+  std::shared_ptr<jsi::Object> _registerValuesCallback;
   std::shared_ptr<jsi::Object> _unregisterValues;
   std::map<JsiDomNode *,
            std::vector<std::pair<std::shared_ptr<RNSkReadonlyValue>,

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

@@ -49,7 +49,19 @@ public:
   JsiDomNode(std::shared_ptr<RNSkPlatformContext> context, const char *type,
              NodeClass nodeClass)
       : _type(type), _context(context), _nodeClass(nodeClass),
-        _nodeId(NodeIdent++), JsiHostObject() {}
+        _nodeId(NodeIdent++), JsiHostObject() {
+#if SKIA_DOM_DEBUG
+    printDebugInfo("JsiDomNode." + std::string(_type) +
+                   " CTOR - nodeId: " + std::to_string(_nodeId));
+#endif
+  }
+
+  virtual ~JsiDomNode() {
+#if SKIA_DOM_DEBUG
+    printDebugInfo("JsiDomNode." + std::string(_type) +
+                   " DTOR - nodeId: " + std::to_string(_nodeId));
+#endif
+  }
 
   /**
    Called when creating the node, resolves properties from the node constructor.
@@ -65,7 +77,7 @@ public:
   JSI_HOST_FUNCTION(setProps) {
     if (count == 1) {
       // Initialize properties container
-      setProps(runtime, getArgumentAsObject(runtime, arguments, count, 0));
+      setProps(runtime, arguments[0]);
     } else {
       setEmptyProps();
     }
@@ -102,7 +114,7 @@ public:
    tree. Use for cleaning up.
    */
   JSI_HOST_FUNCTION(dispose) {
-    dispose();
+    dispose(false);
     return jsi::Value::undefined();
   }
 
@@ -247,36 +259,9 @@ public:
       _propsContainer->markAsResolved();
     }
 
-    // Now let's dispose if needed
+    // Now let's invalidate if needed
     if (_isDisposing && !_isDisposed) {
-      _isDisposed = true;
-
-      this->setParent(nullptr);
-
-      // Callback signaling that we're done
-      if (_disposeCallback != nullptr) {
-        _disposeCallback();
-        _disposeCallback = nullptr;
-      }
-
-      // Clear props
-      if (_propsContainer != nullptr) {
-        _propsContainer->dispose();
-      }
-
-      // Remove children
-      std::vector<std::shared_ptr<JsiDomNode>> tmp;
-      {
-        std::lock_guard<std::mutex> lock(_childrenLock);
-        tmp.reserve(_children.size());
-        for (auto &child : _children) {
-          tmp.push_back(child);
-        }
-        _children.clear();
-      }
-      for (auto &child : tmp) {
-        child->dispose();
-      }
+      invalidate();
     }
 
     // Resolve children
@@ -292,6 +277,22 @@ public:
     // Empty implementation
   }
 
+  /**
+   Called when a node has been removed from the dom tree and needs to be cleaned
+   up. If the invalidate parameter is set, we will invalidate the node directly.
+   Calling dispose from the JS dispose function calls this with invalidate set
+   to false, while the dom render view calls this with true.
+   */
+  virtual void dispose(bool immediate) {
+    if (_isDisposing) {
+      return;
+    }
+    _isDisposing = true;
+    if (immediate) {
+      invalidate();
+    }
+  }
+
 protected:
   /**
    Adds an operation that will be executed when the render cycle is finished.
@@ -319,24 +320,17 @@ protected:
 
   /**
    Native implementation of the set properties method. This is called from the
-   reconciler when properties are set due to changes in React. This method will
-   always call the onPropsSet method as a signal that things have changed.
+   reconciler when properties are set due to changes in React.
    */
-  void setProps(jsi::Runtime &runtime, jsi::Object &&props) {
+  void setProps(jsi::Runtime &runtime, const jsi::Value &maybeProps) {
 #if SKIA_DOM_DEBUG
     printDebugInfo("JS:setProps(nodeId: " + std::to_string(_nodeId) + ")");
 #endif
-    if (_propsContainer == nullptr) {
+    // Initialize properties container
+    ensurePropertyContainer();
 
-      // Initialize properties container
-      _propsContainer = std::make_shared<NodePropsContainer>(
-          getType(), [=](BaseNodeProp *p) { onPropertyChanged(p); });
-
-      // Ask sub classes to define their properties
-      defineProperties(_propsContainer.get());
-    }
     // Update properties container
-    _propsContainer->setProps(runtime, std::move(props));
+    _propsContainer->setProps(runtime, maybeProps);
 
     // Invalidate context
     invalidateContext();
@@ -349,15 +343,8 @@ protected:
 #if SKIA_DOM_DEBUG
     printDebugInfo("JS:setEmptyProps(nodeId: " + std::to_string(_nodeId) + ")");
 #endif
-    if (_propsContainer == nullptr) {
-
-      // Initialize properties container
-      _propsContainer = std::make_shared<NodePropsContainer>(
-          getType(), [=](BaseNodeProp *p) { onPropertyChanged(p); });
-
-      // Ask sub classes to define their properties
-      defineProperties(_propsContainer.get());
-    }
+    // Initialize properties container
+    ensurePropertyContainer();
   }
 
   /**
@@ -381,9 +368,12 @@ protected:
     printDebugInfo("JS:addChild(childId: " + std::to_string(child->_nodeId) +
                    ")");
 #endif
-    enqueAsynOperation([child, this]() {
-      _children.push_back(child);
-      child->setParent(this);
+    enqueAsynOperation([child, weakSelf = weak_from_this()]() {
+      auto self = weakSelf.lock();
+      if (self) {
+        self->_children.push_back(child);
+        child->setParent(self.get());
+      }
     });
   }
 
@@ -398,10 +388,14 @@ protected:
         "JS:insertChildBefore(childId: " + std::to_string(child->_nodeId) +
         ", beforeId: " + std::to_string(before->_nodeId) + ")");
 #endif
-    enqueAsynOperation([child, before, this]() {
-      auto position = std::find(_children.begin(), _children.end(), before);
-      _children.insert(position, child);
-      child->setParent(this);
+    enqueAsynOperation([child, before, weakSelf = weak_from_this()]() {
+      auto self = weakSelf.lock();
+      if (self) {
+        auto position =
+            std::find(self->_children.begin(), self->_children.end(), before);
+        self->_children.insert(position, child);
+        child->setParent(self.get());
+      }
     });
   }
 
@@ -414,27 +408,25 @@ protected:
     printDebugInfo("JS:removeChild(childId: " + std::to_string(child->_nodeId) +
                    ")");
 #endif
-    enqueAsynOperation([child, this]() {
-      // Delete child itself
-      _children.erase(
-          std::remove_if(_children.begin(), _children.end(),
-                         [child](const auto &node) { return node == child; }),
-          _children.end());
-
-      child->dispose();
-    });
-  }
+    auto removeChild = [child,
+                        weakSelf = weak_from_this()](bool immediate = false) {
+      auto self = weakSelf.lock();
+      if (self) {
+        // Delete child itself
+        self->_children.erase(
+            std::remove_if(self->_children.begin(), self->_children.end(),
+                           [child](const auto &node) { return node == child; }),
+            self->_children.end());
+
+        child->dispose(immediate);
+      }
+    };
 
-  /**
-   Called when a node has been removed from the dom tree and needs to be cleaned
-   up.
-   */
-  virtual void dispose() {
     if (_isDisposing) {
-      return;
+      removeChild(false);
+    } else {
+      enqueAsynOperation(removeChild);
     }
-
-    _isDisposing = true;
   }
 
 #if SKIA_DOM_DEBUG
@@ -477,6 +469,69 @@ protected:
   }
 
 private:
+  /**
+   Invalidates the node - meaning removing and clearing children and properties
+   **/
+  void invalidate() {
+    if (_isDisposing && !_isDisposed) {
+#if SKIA_DOM_DEBUG
+      printDebugInfo("JsiDomNode::invalidate: nodeid: " +
+                     std::to_string(_nodeId));
+#endif
+
+      _isDisposed = true;
+
+      // Clear parent
+      this->setParent(nullptr);
+
+      // Clear any async operations
+      _queuedNodeOps.clear();
+
+      // Callback signaling that we're done
+      if (_disposeCallback != nullptr) {
+        _disposeCallback();
+        _disposeCallback = nullptr;
+      }
+
+      // Clear props
+      if (_propsContainer != nullptr) {
+        _propsContainer->dispose();
+      }
+
+      // Remove children
+      std::vector<std::shared_ptr<JsiDomNode>> tmp;
+      {
+        std::lock_guard<std::mutex> lock(_childrenLock);
+        tmp.reserve(_children.size());
+        for (auto &child : _children) {
+          tmp.push_back(child);
+        }
+        _children.clear();
+      }
+      for (auto &child : tmp) {
+        child->dispose(true);
+      }
+    }
+  }
+
+  /**
+   Creates and sets up the property container
+   */
+  void ensurePropertyContainer() {
+    if (_propsContainer == nullptr) {
+      _propsContainer = std::make_shared<NodePropsContainer>(
+          getType(), [weakSelf = weak_from_this()](BaseNodeProp *p) {
+            auto self = weakSelf.lock();
+            if (self) {
+              self->onPropertyChanged(p);
+            }
+          });
+
+      // Ask sub classes to define their properties
+      defineProperties(_propsContainer.get());
+    }
+  }
+
   const char *_type;
   std::shared_ptr<RNSkPlatformContext> _context;
 

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

@@ -132,19 +132,19 @@ public:
    */
   void resetPendingChanges() override { JsiDomNode::resetPendingChanges(); }
 
-  /**
-   Signal from the JS side that the node is removed from the dom.
-   */
-  void dispose() override { JsiDomNode::dispose(); }
-
 protected:
   /**
    Invalidates and marks then context as changed.
    */
   void invalidateContext() override {
-    enqueAsynOperation([=]() {
-      _paintCache.parent = nullptr;
-      _paintCache.child = nullptr;
+    enqueAsynOperation([weakSelf = weak_from_this()]() {
+      auto self = weakSelf.lock();
+      if (self) {
+        std::static_pointer_cast<JsiDomRenderNode>(self)->_paintCache.parent =
+            nullptr;
+        std::static_pointer_cast<JsiDomRenderNode>(self)->_paintCache.child =
+            nullptr;
+      }
     });
   }
 

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

@@ -33,7 +33,7 @@ public:
     // readValueFromJS Function (which comes from the reconciler
     // setting a new property value on the property
     if (_value == nullptr) {
-      _value = std::make_shared<JsiValue>(runtime, read(runtime, _name, this));
+      _value = std::make_unique<JsiValue>(runtime, read(runtime, _name, this));
       _isChanged = true;
       _hasNewValue = false;
     } else {
@@ -41,7 +41,7 @@ public:
       std::lock_guard<std::mutex> lock(_swapMutex);
       if (_buffer == nullptr) {
         _buffer =
-            std::make_shared<JsiValue>(runtime, read(runtime, _name, this));
+            std::make_unique<JsiValue>(runtime, read(runtime, _name, this));
       } else {
         _buffer->setCurrent(runtime, read(runtime, _name, this));
       }
@@ -60,7 +60,7 @@ public:
     // and we don't want to rip out the underlying value object.
     std::lock_guard<std::mutex> lock(_swapMutex);
     if (_buffer == nullptr) {
-      _buffer = std::make_shared<JsiValue>(runtime, value);
+      _buffer = std::make_unique<JsiValue>(runtime, value);
     } else {
       _buffer->setCurrent(runtime, value);
     }
@@ -129,8 +129,8 @@ private:
 
   std::function<void(BaseNodeProp *)> _onChange;
 
-  std::shared_ptr<JsiValue> _value;
-  std::shared_ptr<JsiValue> _buffer;
+  std::unique_ptr<JsiValue> _value;
+  std::unique_ptr<JsiValue> _buffer;
   std::atomic<bool> _isChanged = {false};
   std::atomic<bool> _hasNewValue = {false};
   std::mutex _swapMutex;

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

@@ -82,10 +82,16 @@ public:
   /**
    Called when the React / JS side sets properties on a node
    */
-  void setProps(jsi::Runtime &runtime, jsi::Object &&props) {
+  void setProps(jsi::Runtime &runtime, const jsi::Value &maybePropsObject) {
     // Clear property mapping
     _mappedProperties.clear();
 
+    if (!maybePropsObject.isObject()) {
+      throw jsi::JSError(runtime, "Expected property object.");
+    }
+
+    auto props = maybePropsObject.asObject(runtime);
+
     // Use specialized reader function to be able to intercept calls that
     // reads specific named values from the js property object.
     auto read = [&](jsi::Runtime &runtime, PropId name, NodeProp *prop) {

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

@@ -158,20 +158,21 @@ public:
       : JsiBaseImageFilterNode(context, "skDisplacementMapImageFilter") {}
 
   void decorate(DeclarationContext *context) override {
-
+    decorateChildren(context);
     auto channelX =
         getColorChannelFromStringValue(_channelXProp->value().getAsString());
     auto channelY =
         getColorChannelFromStringValue(_channelYProp->value().getAsString());
     auto scale = _scaleProp->value().getAsNumber();
-
-    auto displacement = context->getImageFilters()->pop();
-
-    auto color = context->getImageFilters()->pop();
-
-    composeAndPush(context, SkImageFilters::DisplacementMap(
-                                channelX, channelY, scale, displacement,
-                                color ? color : nullptr));
+    auto shader = context->getShaders()->pop();
+    if (!shader) {
+      throw std::runtime_error("DisplacementMap expects a shader as child");
+    }
+    auto map = SkImageFilters::Shader(shader);
+    auto input = context->getImageFilters()->pop();
+    auto imgf = SkImageFilters::DisplacementMap(channelX, channelY, scale, map,
+                                                input ? input : nullptr);
+    context->getImageFilters()->push(imgf);
   }
 
 protected:

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

@@ -22,43 +22,36 @@ public:
   explicit ClipProp(PropId name,
                     const std::function<void(BaseNodeProp *)> &onChange)
       : BaseDerivedProp(onChange) {
-    _pathProp = defineProperty<PathProp>(name);
-    _rectProp = defineProperty<RectProp>(name);
-    _rrectProp = defineProperty<RRectProp>(name);
+    _clipProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
-    if (_pathProp->isSet()) {
-      _rect = nullptr;
-      _rrect = nullptr;
-      _path = _pathProp->getDerivedValue();
-    } else if (_rrectProp->isSet()) {
-      _rect = nullptr;
-      _rrect = _rrectProp->getDerivedValue();
-      _path = nullptr;
-    } else if (_rectProp->isSet()) {
-      _rect = _rectProp->getDerivedValue();
+    if (_clipProp->isSet()) {
+      auto value = _clipProp->value();
+      _rect = RectProp::processRect(value);
       _rrect = nullptr;
       _path = nullptr;
+      if (!_rect) {
+        _path = PathProp::processPath(value);
+        if (!_path) {
+          _rrect = RRectProp::processRRect(value);
+        }
+      }
     }
   }
 
-  bool isSet() override {
-    return _pathProp->isSet() || _rectProp->isSet() || _rrectProp->isSet();
-  }
+  bool isSet() override { return _clipProp->isSet(); }
 
   const SkPath *getPath() { return _path.get(); }
   const SkRect *getRect() { return _rect.get(); }
   const SkRRect *getRRect() { return _rrect.get(); }
 
 private:
-  PathProp *_pathProp;
-  RectProp *_rectProp;
-  RRectProp *_rrectProp;
+  NodeProp *_clipProp;
 
   std::shared_ptr<const SkPath> _path;
   std::shared_ptr<const SkRect> _rect;
   std::shared_ptr<const SkRRect> _rrect;
 };
 
-} // namespace RNSkia
+} // namespace RNSkia

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

@@ -22,32 +22,34 @@ public:
     _pathProp = defineProperty<NodeProp>(name);
   }
 
-  void updateDerivedValue() override {
-    if (!_pathProp->isSet()) {
-      setDerivedValue(nullptr);
-      return;
-    }
-
-    if (_pathProp->value().getType() == PropType::HostObject) {
+  static std::shared_ptr<SkPath> processPath(const JsiValue &value) {
+    if (value.getType() == PropType::HostObject) {
       // Try reading as Path
-      auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
-          _pathProp->value().getAsHostObject());
+      auto ptr = std::dynamic_pointer_cast<JsiSkPath>(value.getAsHostObject());
       if (ptr != nullptr) {
-        setDerivedValue(ptr->getObject());
+        return ptr->getObject();
       }
-    } else if (_pathProp->value().getType() == PropType::String) {
+    } else if (value.getType() == PropType::String) {
       // Read as string
-      auto pathString = _pathProp->value().getAsString();
+      auto pathString = value.getAsString();
       SkPath result;
 
       if (SkParsePath::FromSVGString(pathString.c_str(), &result)) {
-        setDerivedValue(std::make_shared<SkPath>(result));
+        return std::make_shared<SkPath>(result);
       } else {
         throw std::runtime_error("Could not parse path from string.");
       }
-    } else {
+    }
+    return nullptr;
+  }
+
+  void updateDerivedValue() override {
+    if (!_pathProp->isSet()) {
       setDerivedValue(nullptr);
+      return;
     }
+    auto value = _pathProp->value();
+    setDerivedValue(PathProp::processPath(value));
   }
 
 private:

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

@@ -29,7 +29,7 @@ public:
   void updateDerivedValue() override {
     if (_pointProp->isSet()) {
       // Check for JsiSkRect and JsiSkPoint
-      setDerivedValue(std::move(processValue(_pointProp->value())));
+      setDerivedValue(processValue(_pointProp->value()));
     } else {
       setDerivedValue(nullptr);
     }