@shopify/react-native-skia 0.1.115

package/cpp/jsi/JsiHostObject.h

@@ -0,0 +1,241 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <functional>
+#include <unordered_map>
+#include <memory>
+#include <string>
+
+#define STR_CAT_NX(A, B) A##B
+#define STR_CAT(A, B) STR_CAT_NX(A, B)
+#define STR_GET get_
+#define STR_SET set_
+
+/**
+ * Creates a new Host function declaration as a lambda with all deps passed
+ * with implicit lambda capture clause
+ */
+#define JSI_HOST_FUNCTION_LAMBDA                                               \
+  [=](jsi::Runtime & runtime, const jsi::Value &thisValue,                     \
+      const jsi::Value *arguments, size_t count) -> jsi::Value
+
+/**
+ * Creates a new Host function declaration
+ */
+#define JSI_HOST_FUNCTION(NAME)                                                \
+  jsi::Value NAME(jsi::Runtime &runtime, const jsi::Value &thisValue,          \
+                  const jsi::Value *arguments, size_t count)
+
+/**
+ * Creates a new property setter function declaration
+ */
+#define JSI_PROPERTY_SET(NAME)                                                 \
+  void STR_CAT(STR_SET, NAME)(jsi::Runtime & runtime, const jsi::Value &value)
+
+/**
+ * Creates a new property getter function declaration
+ */
+#define JSI_PROPERTY_GET(NAME)                                                 \
+  jsi::Value STR_CAT(STR_GET, NAME)(jsi::Runtime & runtime)
+
+/**
+ * Creates a JSI export function declaration
+ */
+#define JSI_EXPORT_FUNC(CLASS, FUNCTION)                                       \
+  {                                                                            \
+#FUNCTION, (jsi::Value(JsiHostObject::*)(                                      \
+                   jsi::Runtime & runtime, const jsi::Value &thisValue,        \
+                   const jsi::Value *arguments, size_t)) &                     \
+                   CLASS::FUNCTION                                             \
+  }
+
+/**
+ * Creates a JSI export functions statement
+ */
+#define JSI_EXPORT_FUNCTIONS(...)                                              \
+  const JsiFunctionMap &getExportedFunctionMap() override {                    \
+    static JsiFunctionMap map = {__VA_ARGS__};                                 \
+    return map;                                                                \
+  }
+
+/**
+ * Creates a JSI export getter declaration
+ */
+#define JSI_EXPORT_PROP_GET(CLASS, FUNCTION)                                   \
+  {                                                                            \
+#FUNCTION, (jsi::Value(JsiHostObject::*)(jsi::Runtime & runtime)) &            \
+                   CLASS::STR_CAT(STR_GET, FUNCTION)                           \
+  }
+
+/**
+ * Creates a JSI export getters statement
+ */
+#define JSI_EXPORT_PROPERTY_GETTERS(...)                                       \
+  const JsiPropertyGettersMap &getExportedPropertyGettersMap() override {      \
+  static JsiPropertyGettersMap map = {__VA_ARGS__};                            \
+  return map;                                                                  \
+}
+
+/**
+ * Creates a JSI export setter declaration
+ */
+#define JSI_EXPORT_PROP_SET(CLASS, FUNCTION)                                   \
+  {                                                                            \
+#FUNCTION,                                                                     \
+        (void(JsiHostObject::*)(jsi::Runtime & runtime, const jsi::Value &)) & \
+            CLASS::STR_CAT(STR_SET, FUNCTION)                                  \
+  }
+
+/**
+ * Creates a JSI export setters statement
+ */
+#define JSI_EXPORT_PROPERTY_SETTERS(...)                                       \
+  const JsiPropertySettersMap &getExportedPropertySettersMap() override {      \
+    static JsiPropertySettersMap map = {__VA_ARGS__};                          \
+    return map;                                                                \
+  }
+
+namespace RNJsi {
+
+using namespace facebook;
+
+using JsPropertyType = struct {
+  std::function<jsi::Value(jsi::Runtime &)> get;
+  std::function<void(jsi::Runtime &, const jsi::Value &)> set;
+};
+
+class JsiHostObject;
+
+using JsiFunctionMap = std::unordered_map<std::string,
+  jsi::Value (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>;
+
+using JsiPropertyGettersMap = std::unordered_map<std::string,
+  jsi::Value (JsiHostObject::*)(jsi::Runtime &)>;
+
+using JsiPropertySettersMap = std::unordered_map<std::string,
+  void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>;
+
+using JsiHostFunctionCache =
+    std::unordered_map<std::string, std::unique_ptr<jsi::Function>>;
+
+using JsiRuntimeCache =
+    std::unordered_map<jsi::Runtime *, JsiHostFunctionCache>;
+
+/**
+ * Base class for jsi host objects
+ */
+class JsiHostObject : public jsi::HostObject {
+public:
+  JsiHostObject();
+  ~JsiHostObject();
+
+protected:
+  /**
+   Override to return map of name/functions
+   */
+  virtual const JsiFunctionMap &getExportedFunctionMap() {
+    static const JsiFunctionMap empty;
+    return empty;
+  };
+
+  /**
+   Override to get property getters map of name/functions
+   */
+  virtual const JsiPropertyGettersMap &getExportedPropertyGettersMap() {
+    static const JsiPropertyGettersMap empty;
+    return empty;
+  };
+
+  /**
+   Override to get property setters map of name/functions
+   */
+  virtual const JsiPropertySettersMap &getExportedPropertySettersMap() {
+    static const JsiPropertySettersMap empty;
+    return empty;
+  };
+
+  /**
+   * Overridden jsi::HostObject set property method
+   * @param rt Runtime
+   * @param name Name of value to set
+   * @param value Value to set
+   */
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
+
+  /**
+   * Overridden jsi::HostObject get property method. Returns functions from
+   * the map of functions.
+   * @param runtime Runtime
+   * @param name Name of value to get
+   * @return Value
+   */
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  /**
+   * Overridden getPropertyNames from jsi::HostObject. Returns all keys in the
+   * function and property maps
+   * @param runtime Runtime
+   * @return List of property names
+   */
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &runtime) override;
+
+  /**
+   * Installs a function into the function map
+   */
+  void installFunction(const std::string &name,
+                       const jsi::HostFunctionType &function) {
+    _funcMap.emplace(name, function);
+  }
+
+  /**
+   * Installs a property with get/set
+   * @param name Name of property to install
+   * @param get Getter function
+   * @param set Setter function
+   */
+  void installProperty(
+      const std::string &name,
+      const std::function<jsi::Value(jsi::Runtime &)> &get,
+      const std::function<void(jsi::Runtime &, const jsi::Value &)> &set) {
+    _propMap.emplace(name, JsPropertyType{.get = get, .set = set});
+  }
+
+  /**
+   * Installs a property with only getter
+   * @param name Name of property to install
+   * @param get Getter function
+   */
+  void installReadonlyProperty(
+      const std::string &name,
+      const std::function<jsi::Value(jsi::Runtime &)> &get) {
+    _propMap.emplace(name, JsPropertyType{
+                               .get = get,
+                               .set = [](jsi::Runtime &, const jsi::Value &) {},
+                           });
+  }
+
+  /**
+   * Installs a property which points to a given host object
+   * @param name Name of property to install
+   * @param hostObject Object to return
+   */
+  void installReadonlyProperty(const std::string &name,
+                               std::shared_ptr<jsi::HostObject> hostObject) {
+    _propMap.emplace(name, JsPropertyType{
+                               .get =
+                                   [hostObject](jsi::Runtime &runtime) {
+                                     return jsi::Object::createFromHostObject(
+                                         runtime, hostObject);
+                                   },
+                               .set = [](jsi::Runtime &, const jsi::Value &) {},
+                           });
+  }
+
+private:
+  std::unordered_map<std::string, jsi::HostFunctionType> _funcMap;
+  std::unordered_map<std::string, JsPropertyType> _propMap;
+  JsiRuntimeCache _cache;
+};
+} // namespace RNJsi

package/cpp/rnskia/RNSkAnimation.h

@@ -0,0 +1,73 @@
+
+#pragma once
+
+#include <array>
+
+#include <JsiHostObject.h>
+#include <RNSkPlatformContext.h>
+#include <RNSkClockValue.h>
+#include <jsi/jsi.h>
+
+namespace RNSkia
+{
+using namespace facebook;
+
+/**
+ Implements an animation that can be used to drive other values
+ */
+class RNSkAnimation : public RNSkClockValue, public std::enable_shared_from_this<RNSkAnimation>
+{
+  
+public:
+  RNSkAnimation(std::shared_ptr<RNSkPlatformContext> platformContext,
+                     size_t identifier,
+                     jsi::Runtime& runtime,
+                     const jsi::Value *arguments,
+                     size_t count)
+      : RNSkClockValue(platformContext, identifier, runtime, arguments, count) {
+    // Save the update function
+    _updateFunction = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+        
+    // Set state to undefined initially.
+    _args[1] = jsi::Value::undefined();
+  }
+  
+  ~RNSkAnimation() {
+    // We need to stop/unsubscribe
+    stopClock();
+  }
+  
+  JSI_HOST_FUNCTION(cancel) {
+    stopClock();
+    return jsi::Value::undefined();
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkAnimation, cancel))
+
+    
+protected:
+   
+  void tick(jsi::Runtime &runtime, const jsi::Value &value) override {
+    // Set up arguments and call the update function
+    _args[0] = value.asNumber();
+    _args[1] = _updateFunction->call(runtime, static_cast<const jsi::Value*>(_args.data()), _args.size());
+    
+    // Get finished
+    auto finished = _args[1].asObject(runtime).getProperty(runtime, "finished").getBool();
+    if(finished) {
+      stopClock();
+    }
+    
+    // Get the next value
+    auto nextValue = _args[1].asObject(runtime).getProperty(runtime, "current").asNumber();
+    
+    // Update self
+    update(runtime, nextValue);
+  }
+  
+private:
+  
+  std::shared_ptr<jsi::Function> _updateFunction;
+  std::array<jsi::Value, 2> _args;
+};
+}

package/cpp/rnskia/RNSkDispatchQueue.cpp

@@ -0,0 +1,84 @@
+#include "RNSkDispatchQueue.h"
+
+#include <memory>
+#include <mutex>
+#include <utility>
+
+namespace RNSkia
+{
+
+  RNSkDispatchQueue::~RNSkDispatchQueue()
+  {
+    // Signal to dispatch threads that it's time to wrap up
+    std::unique_lock<std::mutex> lock(lock_);
+    quit_ = true;
+    lock.unlock();
+    cv_.notify_all();
+
+    // Wait for threads to finish before we exit
+    for (size_t i = 0; i < threads_.size(); i++)
+    {
+      if (threads_[i].joinable())
+      {
+        threads_[i].join();
+      }
+    }
+  }
+
+  RNSkDispatchQueue::RNSkDispatchQueue(std::string name, size_t thread_cnt)
+      : name_{std::move(name)}, threads_(thread_cnt)
+  {
+    for (size_t i = 0; i < threads_.size(); i++)
+    {
+      threads_[i] = std::thread(&RNSkDispatchQueue::dispatch_thread_handler, this);
+    }
+  }
+
+  void RNSkDispatchQueue::dispatch(const fp_t &op)
+  {
+    std::unique_lock<std::mutex> lock(lock_);
+    q_.push(op);
+
+    // Manual unlocking is done before notifying, to avoid waking up
+    // the waiting thread only to block again (see notify_one for details)
+    lock.unlock();
+    cv_.notify_one();
+  }
+
+  void RNSkDispatchQueue::dispatch(fp_t &&op)
+  {
+    std::unique_lock<std::mutex> lock(lock_);
+    q_.push(std::move(op));
+
+    // Manual unlocking is done before notifying, to avoid waking up
+    // the waiting thread only to block again (see notify_one for details)
+    lock.unlock();
+    cv_.notify_one();
+  }
+
+  void RNSkDispatchQueue::dispatch_thread_handler(void)
+  {
+    std::unique_lock<std::mutex> lock(lock_);
+
+    do
+    {
+      // Wait until we have data or a quit signal
+      cv_.wait(lock, [this]
+               { return (q_.size() || quit_); });
+
+      // after wait, we own the lock
+      if (!quit_ && q_.size())
+      {
+        auto op = std::move(q_.front());
+        q_.pop();
+
+        // unlock now that we're done messing with the queue
+        lock.unlock();
+
+        op();
+
+        lock.lock();
+      }
+    } while (!quit_);
+  }
+} // namespace RNSkia

package/cpp/rnskia/RNSkDispatchQueue.h

@@ -0,0 +1,47 @@
+#include <condition_variable>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <vector>
+
+// https://github.com/embeddedartistry/embedded-resources/blob/master/examples/cpp/dispatch.cpp
+namespace RNSkia {
+
+class RNSkDispatchQueue {
+  typedef std::function<void(void)> fp_t;
+
+public:
+  RNSkDispatchQueue(std::string name, size_t thread_cnt = 1);
+
+  ~RNSkDispatchQueue();
+
+  // dispatch and copy
+  void dispatch(const fp_t &op);
+
+  // dispatch and move
+  void dispatch(fp_t &&op);
+
+  // Deleted operations
+  RNSkDispatchQueue(const RNSkDispatchQueue &rhs) = delete;
+
+  RNSkDispatchQueue &operator=(const RNSkDispatchQueue &rhs) = delete;
+
+  RNSkDispatchQueue(RNSkDispatchQueue &&rhs) = delete;
+
+  RNSkDispatchQueue &operator=(RNSkDispatchQueue &&rhs) = delete;
+
+private:
+  std::string name_;
+  std::mutex lock_;
+  std::vector<std::thread> threads_;
+  std::queue<fp_t> q_;
+  std::condition_variable cv_;
+  bool quit_ = false;
+
+  void dispatch_thread_handler(void);
+};
+} // namespace RNSkia