@shopify/react-native-skia 0.1.115

package/cpp/rnskia/RNSkValueApi.h

@@ -0,0 +1,69 @@
+
+#pragma once
+
+#include <JsiHostObject.h>
+#include <RNSkPlatformContext.h>
+#include <RNSkValue.h>
+#include <RNSkDerivedValue.h>
+#include <RNSkAnimation.h>
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+using namespace facebook;
+
+class RNSkValueApi : public JsiHostObject {
+public:
+  /**
+   * Constructor
+   * @param platformContext Platform context
+   */
+  RNSkValueApi(std::shared_ptr<RNSkPlatformContext> platformContext)
+      : JsiHostObject(), _platformContext(platformContext) {
+        _valueIdentifier = 50000;
+      }
+
+  /**
+   * Destructor
+   */
+  ~RNSkValueApi() {    
+  }
+  
+  JSI_HOST_FUNCTION(createValue) {
+    return jsi::Object::createFromHostObject(runtime,
+      std::make_shared<RNSkValue>(_platformContext, runtime, arguments, count));
+  }
+  
+  JSI_HOST_FUNCTION(createDerivedValue) {
+    return jsi::Object::createFromHostObject(runtime,
+      std::make_shared<RNSkDerivedValue>(_platformContext, runtime, arguments, count));
+  }
+  
+  JSI_HOST_FUNCTION(createAnimation) {
+    return jsi::Object::createFromHostObject(runtime,
+      std::make_shared<RNSkAnimation>(_platformContext,
+                                      ++_valueIdentifier,
+                                      runtime,
+                                      arguments,
+                                      count));
+  }
+  
+  JSI_HOST_FUNCTION(createClockValue) {
+    return jsi::Object::createFromHostObject(runtime,
+      std::make_shared<RNSkClockValue>(_platformContext,
+                                      ++_valueIdentifier,
+                                      runtime,
+                                      arguments,
+                                      count));
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkValueApi, createValue),
+                       JSI_EXPORT_FUNC(RNSkValueApi, createDerivedValue),
+                       JSI_EXPORT_FUNC(RNSkValueApi, createClockValue),
+                       JSI_EXPORT_FUNC(RNSkValueApi, createAnimation))
+
+private:
+  // Platform context
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+  std::atomic<long> _valueIdentifier;  
+};
+} // namespace RNSkia

package/cpp/rnskia/values/RNSkClockValue.h

@@ -0,0 +1,133 @@
+
+#pragma once
+
+#include <RNSkPlatformContext.h>
+#include <RNSkReadonlyValue.h>
+#include <jsi/jsi.h>
+
+#include <algorithm>
+#include <functional>
+#include <chrono>
+#include <mutex>
+
+namespace RNSkia
+{
+using namespace facebook;
+/**
+ 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));
+  }
+  
+  ~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;
+    auto dispatch = std::bind(&RNSkClockValue::notifyUpdate, this, std::placeholders::_1);
+    getContext()->beginDrawLoop(_identifier, dispatch);
+  }
+  
+  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;
+    }
+    
+    // Avoid moving on if we are being called after the dtor was started
+    // Ensure we call any updates from the draw loop on the javascript thread
+    getContext()->runOnJavascriptThread(
+      [this]() {
+      if(_state == RNSkClockState::Running) {
+        auto now = std::chrono::high_resolution_clock::now();
+        auto deltaFromStart = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start).count();
+        tick(_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;
+};
+
+}

package/cpp/rnskia/values/RNSkDerivedValue.h

@@ -0,0 +1,92 @@
+
+#pragma once
+
+#include "RNSkReadonlyValue.h"
+#include <RNSkPlatformContext.h>
+#include <jsi/jsi.h>
+
+#include <algorithm>
+#include <functional>
+#include <chrono>
+#include <memory>
+#include <vector>
+
+namespace RNSkia
+{
+using namespace facebook;
+
+/**
+  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 RNSkDerivedValue : public RNSkReadonlyValue
+{
+public:
+  RNSkDerivedValue(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)) {
+      jsi::detail::throwJSError(runtime, "Expected callback function as first parameter");
+    }
+        
+    if(!arguments[1].isObject() ||
+       !arguments[1].asObject(runtime).isArray(runtime)) {
+      jsi::detail::throwJSError(runtime, "Expected array of dependencies as second parameter");
+    }
+        
+    // 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);
+    }
+    
+    // Get callback for calculating result
+    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+
+    // register change handler on dependencies
+    _unsubscribers.reserve(_unsubscribers.size() + size);
+    for(const auto &dep: dependencies) {
+      auto dispatcher = std::bind(&RNSkDerivedValue::dependencyUpdated, this, std::placeholders::_1);
+      _unsubscribers.push_back(dep->addListener(dispatcher));
+    }
+        
+    // Set initial value
+    dependencyUpdated(runtime);
+  }
+  
+  ~RNSkDerivedValue() {
+    // Unregister listeners
+    for(const auto &unsubscribe: _unsubscribers) {
+      unsubscribe();
+    }
+  }
+  
+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;
+};
+}

package/cpp/rnskia/values/RNSkReadonlyValue.h

@@ -0,0 +1,140 @@
+
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <chrono>
+#include <mutex>
+#include <unordered_map>
+#include <utility>
+#include <memory>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkHostObjects.h>
+#include <RNSkPlatformContext.h>
+
+namespace RNSkia
+{
+using namespace facebook;
+
+/**
+ 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 RNSkReadonlyValue : public JsiSkHostObject
+{
+public:
+  RNSkReadonlyValue(std::shared_ptr<RNSkPlatformContext> platformContext)
+      : JsiSkHostObject(platformContext),
+    _propNameId(jsi::PropNameID::forUtf8(*platformContext->getJsRuntime(), "value")) {}
+  
+  ~RNSkReadonlyValue() {
+    _invalidated = true;
+  }
+
+  JSI_PROPERTY_GET(__typename__) {
+    return jsi::String::createFromUtf8(runtime, "RNSkValue");
+  }
+  
+  JSI_PROPERTY_GET(current) {
+    return getCurrent(runtime);
+  }
+  
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue, __typename__),
+                              JSI_EXPORT_PROP_GET(RNSkReadonlyValue, current))
+    
+  
+  JSI_HOST_FUNCTION(addListener) {
+    if(!arguments[0].isObject() || !arguments[0].asObject(runtime).isFunction(runtime)) {
+      jsi::detail::throwJSError(runtime, "Expected function as first parameter.");
+      return jsi::Value::undefined();
+    }
+    auto callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+    
+    auto unsubscribe = addListener([this, callback = std::move(callback)](jsi::Runtime& runtime){
+      callback->call(runtime, get_current(runtime));
+    });
+    
+    return jsi::Function::createFromHostFunction(runtime,
+                                                 jsi::PropNameID::forUtf8(runtime, "unsubscribe"),
+                                                 0,
+                                                 JSI_HOST_FUNCTION_LAMBDA {
+      unsubscribe();
+      return jsi::Value::undefined();
+    });
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkReadonlyValue, addListener))
+    
+  /**
+  * Adds a callback that will be called whenever the value changes
+  * @param cb Callback
+  * @return unsubscribe function
+  */
+  const std::function<void()> addListener(const std::function<void(jsi::Runtime&)> cb) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto listenerId = _listenerId++;
+    _listeners.emplace(listenerId, cb);
+    return [this, listenerId]() {
+      if(!_invalidated) {
+        removeListener(listenerId);
+      }
+    };
+  }
+  
+  /**
+    Updates the underlying value and notifies all listeners about the change
+   @param runtime Current JS Runtime
+   @param value Next value
+   */
+  virtual void update(jsi::Runtime &runtime, const jsi::Value &value) {
+    if(_valueHolder == nullptr) {
+      _valueHolder = std::make_shared<jsi::Object>(runtime);
+    }
+    _valueHolder->setProperty(runtime, _propNameId, value);
+    notifyListeners(runtime);
+  }
+  
+  jsi::Value getCurrent(jsi::Runtime &runtime) {
+    if(_valueHolder == nullptr) {
+      return jsi::Value::undefined();
+    }
+    return _valueHolder->getProperty(runtime, _propNameId);
+  }
+  
+protected:
+  /**
+    Notifies listeners about changes
+   @param runtime Current JS Runtime
+   */
+  void notifyListeners(jsi::Runtime &runtime) {
+    std::unordered_map<long, std::function<void(jsi::Runtime&)>> tmp;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      tmp.insert(_listeners.cbegin(), _listeners.cend());
+    }
+    for(const auto &listener: tmp) {
+      listener.second(runtime);
+    }
+  }
+  
+  /**
+   Removes a subscription listeners
+   @param listenerId identifier of listener to remove
+   */
+  void removeListener(long listenerId) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _listeners.erase(listenerId);
+  }
+
+  std::atomic<bool> _invalidated = { false };
+
+private:
+  jsi::PropNameID _propNameId;
+  std::shared_ptr<jsi::Object> _valueHolder;
+  long _listenerId = 0;
+  std::unordered_map<long, std::function<void(jsi::Runtime&)>> _listeners;
+  std::mutex _mutex;
+};
+}

package/cpp/rnskia/values/RNSkValue.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include <JsiHostObject.h>
+#include <RNSkPlatformContext.h>
+#include <RNSkReadonlyValue.h>
+#include <RNSkAnimation.h>
+#include <jsi/jsi.h>
+
+namespace RNSkia
+{
+using namespace facebook;
+/**
+ Implements a Value that can be both read and written to. It inherits from the ReadonlyValue with
+ functionailty for subscribing to changes.
+ */
+class RNSkValue : public RNSkReadonlyValue
+{
+public:
+  RNSkValue(std::shared_ptr<RNSkPlatformContext> platformContext,
+            jsi::Runtime& runtime, const jsi::Value *arguments, size_t count)
+      : RNSkReadonlyValue(platformContext) {
+        if(count == 1) {
+          update(runtime, arguments[0]);
+        }
+      }
+  
+  ~RNSkValue() {
+    unsubscribe();
+  }
+  
+  JSI_PROPERTY_SET(current) {
+    // When someone else is setting the value we need to stop any ongoing
+    // animations
+    unsubscribe();
+    update(runtime, value);
+  }
+  
+  JSI_PROPERTY_SET(animation) {
+    // Cancel existing animation
+    unsubscribe();
+    
+    // Verify input
+    if(value.isObject() && value.asObject(runtime).isHostObject(runtime)) {
+      auto animation = value.asObject(runtime).getHostObject<RNSkAnimation>(runtime);
+      if(animation != nullptr) {
+        // Now we have a value animation - let us connect and start
+        subscribe(animation);
+      }
+    } else if(value.isUndefined() || value.isNull()) {
+      // Do nothing - we've already unsubscribed
+    } else {
+      jsi::detail::throwJSError(runtime, "Animation expected.");
+    }
+  }
+  
+  JSI_PROPERTY_GET(animation) {
+    if(_animation != nullptr) {
+      return jsi::Object::createFromHostObject(runtime, _animation);
+    }
+    return jsi::Value::undefined();
+  }
+  
+  JSI_EXPORT_PROPERTY_SETTERS(JSI_EXPORT_PROP_SET(RNSkValue, current),
+                              JSI_EXPORT_PROP_SET(RNSkValue, animation))
+  
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkReadonlyValue, __typename__),
+                              JSI_EXPORT_PROP_GET(RNSkValue, current),
+                              JSI_EXPORT_PROP_GET(RNSkValue, animation))
+  
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(RNSkValue, addListener),
+  )
+
+private:
+  void subscribe(std::shared_ptr<RNSkAnimation> animation) {
+    unsubscribe();
+    if(animation != nullptr) {
+      _animation = animation;
+      auto dispatch = std::bind(&RNSkValue::animationDidUpdate, this, std::placeholders::_1);
+      _unsubscribe = std::make_shared<std::function<void()>>(_animation->addListener(dispatch));
+      // Start the animation
+      _animation->startClock();
+    }
+  }
+  
+  void animationDidUpdate(jsi::Runtime& runtime) {
+    if(_animation != nullptr) {
+      // Update ourselves from the current animation value
+      update(runtime, _animation->get_current(runtime));
+    }
+  }
+  
+  void unsubscribe() {
+    if(_unsubscribe != nullptr) {
+      (*_unsubscribe)();
+      _unsubscribe = nullptr;
+    }
+    
+    if(_animation != nullptr) {
+      _animation->stopClock();
+      _animation = nullptr;
+    }
+  }
+  
+  std::shared_ptr<RNSkAnimation> _animation;
+  std::shared_ptr<std::function<void()>> _unsubscribe;
+};
+
+}

package/cpp/skia/include/android/SkAndroidFrameworkUtils.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAndroidFrameworkUtils_DEFINED
+#define SkAndroidFrameworkUtils_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+
+class SkCanvas;
+struct SkIRect;
+struct SkRect;
+class SkSurface;
+
+/**
+ *  SkAndroidFrameworkUtils expose private APIs used only by Android framework.
+ */
+class SkAndroidFrameworkUtils {
+public:
+
+#if SK_SUPPORT_GPU
+    /**
+     *  clipWithStencil draws the current clip into a stencil buffer with reference value and mask
+     *  set to 0x1. This function works only on a GPU canvas.
+     *
+     *  @param  canvas A GPU canvas that has a non-empty clip.
+     *
+     *  @return true on success or false if clip is empty or not a GPU canvas.
+     */
+    static bool clipWithStencil(SkCanvas* canvas);
+#endif //SK_SUPPORT_GPU
+
+    static void SafetyNetLog(const char*);
+
+    static sk_sp<SkSurface> getSurfaceFromCanvas(SkCanvas* canvas);
+
+    static int SaveBehind(SkCanvas* canvas, const SkRect* subset);
+
+    // Operating within the canvas' clip stack, this resets the geometry of the clip to be wide
+    // open modula any device clip restriction that was set outside of the clip stack.
+    static void ResetClip(SkCanvas* canvas);
+
+    /**
+     * Unrolls a chain of nested SkPaintFilterCanvas to return the base wrapped canvas.
+     *
+     *  @param  canvas A SkPaintFilterCanvas or any other SkCanvas subclass.
+     *
+     *  @return SkCanvas that was found in the innermost SkPaintFilterCanvas.
+     */
+    static SkCanvas* getBaseWrappedCanvas(SkCanvas* canvas);
+};
+
+#endif // SK_BUILD_FOR_ANDROID_ANDROID
+
+#endif // SkAndroidFrameworkUtils_DEFINED