@shopify/react-native-skia 0.1.115

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -0,0 +1,305 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <JsiHostObject.h>
+#include <RNSkDrawView.h>
+#include <RNSkPlatformContext.h>
+#include <RNSkValue.h>
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+using namespace facebook;
+
+using CallbackInfo = struct CallbackInfo {
+  CallbackInfo() {
+    drawCallback = nullptr;
+    view = nullptr;
+  }
+  std::shared_ptr<jsi::Function> drawCallback;
+  RNSkDrawView *view;
+};
+
+class RNSkJsiViewApi : public JsiHostObject {
+public:
+  JSI_HOST_FUNCTION(setDrawCallback) {
+    if (count != 2) {
+      _platformContext->raiseError(
+          std::string("setDrawCallback: Expected 2 arguments, got " +
+                      std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "setDrawCallback: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    // We accept undefined to zero out the drawCallback
+    if (!arguments[1].isUndefined()) {
+      if (!arguments[1].isObject()) {
+        _platformContext->raiseError(
+            "setDrawCallback: Second argument must be a function");
+        return jsi::Value::undefined();
+      }
+      if (!arguments[1].asObject(runtime).isFunction(runtime)) {
+        _platformContext->raiseError(
+            "setDrawCallback: Second argument must be a function");
+        return jsi::Value::undefined();
+      }
+    }
+
+    // find skia draw view
+    int nativeId = arguments[0].asNumber();
+
+    // and function to install as the draw drawCallback
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if (arguments[1].isUndefined()) {
+      info->drawCallback = nullptr;
+    } else {
+      info->drawCallback = std::make_shared<jsi::Function>(
+          arguments[1].asObject(runtime).asFunction(runtime));
+    }
+
+    // Update view if set
+    if (info->view != nullptr && info->drawCallback != nullptr) {
+      info->view->setNativeId(nativeId);
+      info->view->setDrawCallback(info->drawCallback);
+    }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(invalidateSkiaView) {
+    if (count != 1) {
+      _platformContext->raiseError(
+          std::string("invalidateSkiaView: Expected 2 arguments, got " +
+                      std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "invalidateSkiaView: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    // find skia draw view
+    int nativeId = arguments[0].asNumber();
+
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if (info->view != nullptr) {
+      info->view->requestRedraw();
+    }
+    return jsi::Value::undefined();
+  }
+  
+  JSI_HOST_FUNCTION(makeImageSnapshot) {
+    
+    // find skia draw view
+    int nativeId = arguments[0].asNumber();
+    sk_sp<SkImage> image;
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if (info->view != nullptr) {
+      if(count > 1 && !arguments[1].isUndefined() && arguments[1].isNull()) {
+        auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
+        image = info->view->makeImageSnapshot(rect);
+      } else {
+        image = info->view->makeImageSnapshot(nullptr);
+      }
+      if(image == nullptr) {
+        jsi::detail::throwJSError(runtime, "Could not create image from current surface.");
+        return jsi::Value::undefined();
+      }
+      return jsi::Object::createFromHostObject(runtime, std::make_shared<JsiSkImage>(_platformContext, image));
+    }
+    jsi::detail::throwJSError(runtime, "No Skia View currently available.");
+    return jsi::Value::undefined();
+  }
+  
+  JSI_HOST_FUNCTION(setDrawMode) {
+    if (count != 2) {
+      _platformContext->raiseError(
+          std::string("setDrawMode: Expected 2 arguments, got " +
+                      std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "setDrawMode: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    // find skia draw view
+    int nativeId = arguments[0].asNumber();
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if (info->view != nullptr) {
+      auto nextMode = arguments[1].asString(runtime).utf8(runtime);
+      if(nextMode.compare("continuous") == 0) {
+        info->view->setDrawingMode(RNSkDrawingMode::Continuous);
+      } else {
+        info->view->setDrawingMode(RNSkDrawingMode::Default);
+      }
+    }
+    return jsi::Value::undefined();
+  }
+  
+  JSI_HOST_FUNCTION(registerValuesInView) {
+    // Check params
+    if(!arguments[1].isObject() || !arguments[1].asObject(runtime).isArray(runtime)) {
+      jsi::detail::throwJSError(runtime, "Expected array of Values as second parameter");
+      return jsi::Value::undefined();
+    }
+    
+    // Get identifier of native SkiaView
+    int nativeId = arguments[0].asNumber();
+    
+    // Get values that should be added as dependencies
+    auto values = arguments[1].asObject(runtime).asArray(runtime);
+    std::vector<std::function<void()>> unsubscribers;
+    const std::size_t size = values.size(runtime);
+    unsubscribers.reserve(size);
+    for(size_t i=0; i<size; ++i) {
+      auto value = values.getValueAtIndex(runtime, i).asObject(runtime).asHostObject<RNSkReadonlyValue>(runtime);
+      
+      if(value != nullptr) {
+        // Add change listener
+        unsubscribers.push_back(value->addListener([this, nativeId](jsi::Runtime&){
+          requestRedrawView(nativeId);
+        }));
+      }
+    }
+    
+    // Return unsubscribe method that unsubscribes to all values
+    // that we subscribed to.
+    return jsi::Function::createFromHostFunction(runtime,
+                                                 jsi::PropNameID::forUtf8(runtime, "unsubscribe"),
+                                                 0,
+                                                 JSI_HOST_FUNCTION_LAMBDA {
+      // decrease dependency count on the Skia View
+      for(auto &unsub : unsubscribers) {
+        unsub();
+      }
+      return jsi::Value::undefined();
+    });
+  }
+  
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkJsiViewApi, setDrawCallback),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, invalidateSkiaView),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, makeImageSnapshot),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, setDrawMode),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, registerValuesInView))
+
+  /**
+   * Constructor
+   * @param platformContext Platform context
+   */
+  RNSkJsiViewApi(std::shared_ptr<RNSkPlatformContext> platformContext)
+      : JsiHostObject(), _platformContext(platformContext) {}
+
+  /**
+   * Invalidates the api object
+   */
+  void invalidate() {
+    unregisterAll();
+  }
+
+  /**
+   Call to remove all draw view infos
+   */
+  void unregisterAll() {
+    // Unregister all views
+    auto tempList = _callbackInfos;
+    for (const auto& info : tempList) {
+      unregisterSkiaDrawView(info.first);
+    }
+    _callbackInfos.clear();
+  }
+
+  /**
+   * Registers a skia view
+   * @param nativeId Id of view to register
+   * @param view View to register
+   */
+  void registerSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+    auto info = getEnsuredCallbackInfo(nativeId);
+    info->view = view;
+    if (info->drawCallback != nullptr) {
+      info->view->setNativeId(nativeId);
+      info->view->setDrawCallback(info->drawCallback);
+    }
+  }
+
+  /**
+   * Unregisters a Skia draw view
+   * @param nativeId View id
+   */
+  void unregisterSkiaDrawView(size_t nativeId) {
+    if (_callbackInfos.count(nativeId) == 0) {
+      return;
+    }
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if (info->view != nullptr) {
+      info->view->setDrawCallback(nullptr);
+    }
+    info->view = nullptr;
+    info->drawCallback = nullptr;
+    _callbackInfos.erase(nativeId);
+  }
+  
+  /**
+   Sets a skia draw view for the given id. This function can be used
+   to mark that an underlying SkiaView is not available (it could be
+   removed due to ex. a transition). The view can be set to a nullptr
+   or a valid view, effectively toggling the view's availability. If
+   a valid view is set, the setDrawCallback method is called on the
+   view (if a valid callback exists).
+   */
+  void setSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+    if (_callbackInfos.find(nativeId) == _callbackInfos.end()) {
+      return;
+    }
+    auto info = getEnsuredCallbackInfo(nativeId);
+    info->view = view;
+    if (view != nullptr && info->drawCallback != nullptr) {
+      info->view->setNativeId(nativeId);
+      info->view->setDrawCallback(info->drawCallback);
+    }
+  }
+
+private:
+  /**
+   * Creates or returns the callback info object for the given view
+   * @param nativeId View id
+   * @return The callback info object for the requested view
+   */
+  CallbackInfo *getEnsuredCallbackInfo(size_t nativeId) {
+    if (_callbackInfos.count(nativeId) == 0) {
+      CallbackInfo info;
+      _callbackInfos.emplace(nativeId, info);
+    }
+    return &_callbackInfos.at(nativeId);
+  }
+  
+  /**
+    Send a redraw request to the view
+   */
+  void requestRedrawView(size_t nativeId) {
+    auto info = getEnsuredCallbackInfo(nativeId);
+    if(info->view != nullptr) {
+      info->view->requestRedraw();
+    }
+  }
+  
+  // List of callbacks
+  std::unordered_map<size_t, CallbackInfo> _callbackInfos;
+  
+  // Platform context
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+};
+} // namespace RNSkia

package/cpp/rnskia/RNSkManager.cpp

@@ -0,0 +1,81 @@
+#include "RNSkManager.h"
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include <JsiSkApi.h>
+#include <RNSkJsiViewApi.h>
+#include <RNSkDrawView.h>
+#include <RNSkValueApi.h>
+
+namespace RNSkia {
+using namespace facebook;
+
+RNSkManager::RNSkManager(
+    jsi::Runtime *jsRuntime,
+    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<RNSkPlatformContext> platformContext)
+    : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
+      _platformContext(platformContext),
+      _viewApi(std::make_shared<RNSkJsiViewApi>(platformContext)) {
+
+  // Install bindings
+  installBindings();
+}
+
+RNSkManager::~RNSkManager() {
+  invalidate();
+  // Free up any references
+  _viewApi = nullptr;
+  _jsRuntime = nullptr;
+  _platformContext = nullptr;
+  _jsCallInvoker = nullptr;
+}
+
+void RNSkManager::invalidate() {
+  if(_isInvalidated) {
+    return;
+  }
+  _isInvalidated = true;
+  
+  // Invalidate members
+  _viewApi->invalidate();
+  _platformContext->invalidate();
+}
+
+void RNSkManager::registerSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->registerSkiaDrawView(nativeId, view);
+}
+
+void RNSkManager::unregisterSkiaDrawView(size_t nativeId) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->unregisterSkiaDrawView(nativeId);
+}
+
+void RNSkManager::setSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->setSkiaDrawView(nativeId, view);
+}
+
+void RNSkManager::installBindings() {
+  // Create the API objects and install it on the global object in the
+  // provided runtime.
+
+  auto skiaApi = std::make_shared<JsiSkApi>(*_jsRuntime, _platformContext);
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "SkiaApi",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(skiaApi)));
+
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "SkiaViewApi",
+      jsi::Object::createFromHostObject(*_jsRuntime, _viewApi));
+
+  auto skiaValueApi = std::make_shared<RNSkValueApi>(_platformContext);
+  _jsRuntime->global().setProperty(
+    *_jsRuntime, "SkiaValueApi",
+    jsi::Object::createFromHostObject(*_jsRuntime, std::move(skiaValueApi)));
+}
+} // namespace RNSkia

package/cpp/rnskia/RNSkManager.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+
+#include "RNSkPlatformContext.h"
+
+namespace facebook {
+  namespace react {
+    class CallInvoker;
+  }
+}
+
+namespace RNSkia {
+class RNSkDrawView;
+class RNSkJsiViewApi;
+using namespace facebook;
+
+class RNSkManager {
+public:
+  /**
+    Initialializes a new instance of the RNSkManager
+    @param jsRuntime The main JavaScript runtime
+    @param jsCallInvoker The callinvoker
+    @param platformContext Context used by wrappers to get platform
+    functionality
+  */
+  RNSkManager(jsi::Runtime *jsRuntime,
+              std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+              std::shared_ptr<RNSkPlatformContext> platformContext);
+
+  ~RNSkManager();
+  
+  /**
+   Invalidates the Skia Manager
+   */
+  void invalidate();
+
+  /**
+   * Registers a RNSkDrawView with the given native id
+   * @param nativeId Native view id
+   * @param view View to register
+   */
+  void registerSkiaDrawView(size_t nativeId, RNSkDrawView *view);
+
+  /**
+   * Unregisters the RNSkDrawView from the list of registered views
+   * @param nativeId Native view Id
+   */
+  void unregisterSkiaDrawView(size_t nativeId);
+  
+  /**
+   Sets the view pointed to by nativeId to the provided value.
+   Used when we want to remove a view without unregistering it
+   - this happens typically on iOS.
+   */
+  void setSkiaDrawView(size_t nativeId, RNSkDrawView *view);
+
+  /**
+   * @return The platform context
+   */
+  std::shared_ptr<RNSkPlatformContext> getPlatformContext() {
+    return _platformContext;
+  }
+
+private:
+  /**
+   * Installs the javascript methods for registering/unregistering draw
+   * callbacks for RNSkDrawViews. Called on installation of the parent native
+   * module.
+   */
+  void installBindings();
+
+  jsi::Runtime *_jsRuntime;
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+  std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
+  std::shared_ptr<RNSkJsiViewApi> _viewApi;
+  std::atomic<bool> _isInvalidated = {false};
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkPlatformContext.h

@@ -0,0 +1,196 @@
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <mutex>
+#include <memory>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <utility>
+
+#include <RNSkDispatchQueue.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkStream.h>
+
+#pragma clang diagnostic pop
+
+#include <jsi/jsi.h>
+
+#include <ReactCommon/CallInvoker.h>
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class RNSkPlatformContext {
+public:
+  /**
+   * Constructor
+   */
+  RNSkPlatformContext(
+      jsi::Runtime *runtime, std::shared_ptr<react::CallInvoker> callInvoker,
+      float pixelDensity)
+      : _pixelDensity(pixelDensity), _jsRuntime(runtime),
+        _callInvoker(callInvoker),
+        _dispatchQueue(std::make_unique<RNSkDispatchQueue>("skia-render-thread")) {
+          _jsThreadId = std::this_thread::get_id();
+        }
+
+  /**
+   * Destructor
+   */
+  ~RNSkPlatformContext() {
+    invalidate();
+  }
+  
+  void invalidate() {
+    if(!_isValid) {
+      return;
+    }
+    // Stop the refresh loop
+    stopDrawLoop();
+    // Notify draw loop listeners once with the invalidated parameter
+    // set to true signalling that we are done and can clean up.
+    notifyDrawLoop(true);
+    _isValid = false;
+  }
+  
+  /*
+   Returns true if the current execution context is the javascript thread.
+   */
+  bool isOnJavascriptThread() {
+    return _jsThreadId == std::this_thread::get_id();
+  };
+  
+  /**
+   * Schedules the function to be run on the javascript thread async
+   * @param func Function to run
+   */
+  void runOnJavascriptThread(std::function<void()> func) {
+    if(!_isValid) { return; }
+    _callInvoker->invokeAsync(std::move(func));
+  }
+
+  /**
+   Runs the function on the render thread
+   */
+  void runOnRenderThread(std::function<void()> func) {
+    if(!_isValid) { return; }
+    _dispatchQueue->dispatch(std::move(func));
+  }
+
+  /**
+   Returns the javascript runtime
+   */
+  jsi::Runtime *getJsRuntime() { return _jsRuntime; }
+
+  /**
+   * Returns an SkStream wrapping the require uri provided.
+   * @param sourceUri Uri for the resource to load as a string
+   * @op Operation to execute when the stream has successfuly been loaded.
+   */
+  virtual void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) = 0;
+  
+  /**
+   * Raises an exception on the platform. This function does not necessarily
+   * throw an exception and stop execution, so it is important to stop execution
+   * by returning after calling the function
+   * @param err Error to raise
+   */
+  virtual void raiseError(const std::exception &err) = 0;
+
+  /**
+   * Raises an exception on the platform. This function does not necessarily
+   * throw an exception and stop execution, so it is important to stop execution
+   * by returning after calling the function
+   * @param message Message to show
+   */
+  void raiseError(const std::string &message) {
+    return raiseError(std::runtime_error(message));
+  }
+
+  /**
+   * @return Current scale factor for pixels
+   */
+  float getPixelDensity() { return _pixelDensity; };
+
+  /**
+   * Starts (if not started) a loop that will call back on display sync
+   * @param callback Callback to call on sync
+   * @returns Identifier of the draw loop entry
+   */
+  size_t beginDrawLoop(size_t nativeId, std::function<void(bool)> callback) {
+    if(!_isValid) { return 0; }
+    auto shouldStart = false;
+    {
+      std::lock_guard<std::mutex> lock(_drawCallbacksLock);
+      _drawCallbacks.emplace(nativeId, std::move(callback));
+      shouldStart = _drawCallbacks.size() == 1;
+    }
+    if (shouldStart) {
+      // Start
+      startDrawLoop();
+    }
+    return nativeId;
+  }
+
+  /**
+   * Ends (if running) the drawing loop that was started with beginDrawLoop.
+   * This method must be called symmetrically with the beginDrawLoop method.
+   * @param nativeId Identifier of view to end
+   */
+  void endDrawLoop(size_t nativeId) {
+    if(!_isValid) { return; }
+    auto shouldStop = false;
+    {
+      std::lock_guard<std::mutex> lock(_drawCallbacksLock);
+      if (_drawCallbacks.count(nativeId) > 0) {
+        _drawCallbacks.erase(nativeId);
+      }
+      shouldStop = _drawCallbacks.size() == 0;
+    }
+    if (shouldStop) {
+      stopDrawLoop();
+    }
+  }
+
+  /**
+   * Notifies all drawing callbacks
+   * @param invalidated True if the context was invalidated, otherwise false. This
+   * can be used to receive a notification that we have stopped the main drawloop
+   */
+  void notifyDrawLoop(bool invalidated) {
+    if(!_isValid) { return; }
+    std::unordered_map<size_t, std::function<void(bool)>> tmp;
+    {
+      std::lock_guard<std::mutex> lock(_drawCallbacksLock);
+      tmp.insert(_drawCallbacks.cbegin(), _drawCallbacks.cend());      
+    }
+    for (auto it = tmp.begin(); it != tmp.end(); it++) {
+      it->second(invalidated);
+    }    
+  }
+
+  virtual void startDrawLoop() = 0;
+  virtual void stopDrawLoop() = 0;
+
+private:
+  float _pixelDensity;
+  
+  std::thread::id _jsThreadId;
+
+  jsi::Runtime *_jsRuntime;
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+  std::unique_ptr<RNSkDispatchQueue> _dispatchQueue;
+
+  std::unordered_map<size_t, std::function<void(bool)>> _drawCallbacks;
+  std::mutex _drawCallbacksLock;
+  std::atomic<bool> _isValid = {true};
+};
+} // namespace RNSkia