@pompadour/react-native-skia 1.4.0

package/cpp/rnskia/RNSkDomView.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiValueWrapper.h"
+#include "RNSkView.h"
+
+#include "JsiDomRenderNode.h"
+#include "RNSkInfoParameter.h"
+#include "RNSkLog.h"
+#include "RNSkPlatformContext.h"
+#include "RNSkTimingInfo.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkBBHFactory.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPictureRecorder.h"
+
+#pragma clang diagnostic pop
+
+class SkPicture;
+class SkRect;
+class SkImage;
+
+namespace RNSkia {
+class JsiSkCanvas;
+namespace jsi = facebook::jsi;
+
+class RNSkDomRenderer : public RNSkRenderer,
+                        public std::enable_shared_from_this<RNSkDomRenderer> {
+public:
+  RNSkDomRenderer(std::function<void()> requestRedraw,
+                  std::shared_ptr<RNSkPlatformContext> context);
+
+  ~RNSkDomRenderer();
+
+  bool tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override;
+
+  void
+  renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override;
+
+  void setRoot(std::shared_ptr<JsiDomRenderNode> node);
+
+  void setOnTouchCallback(std::shared_ptr<jsi::Function> onTouchCallback);
+
+  void updateTouches(std::vector<RNSkTouchInfo> &touches);
+
+private:
+  void callOnTouch();
+  void renderCanvas(SkCanvas *canvas, float scaledWidth, float scaledHeight);
+  void renderDebugOverlays(SkCanvas *canvas);
+
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+  std::shared_ptr<jsi::Function> _touchCallback;
+
+  std::shared_ptr<std::timed_mutex> _renderLock;
+  std::shared_ptr<std::timed_mutex> _touchCallbackLock;
+
+  std::shared_ptr<JsiDomRenderNode> _root;
+  std::shared_ptr<DrawingContext> _drawingContext;
+
+  RNSkTimingInfo _renderTimingInfo;
+
+  std::mutex _touchMutex;
+  std::vector<std::vector<RNSkTouchInfo>> _currentTouches;
+  std::vector<std::vector<RNSkTouchInfo>> _touchesCache;
+  std::mutex _rootLock;
+};
+
+class RNSkDomView : public RNSkView {
+public:
+  /**
+   * Constructor
+   */
+  RNSkDomView(std::shared_ptr<RNSkPlatformContext> context,
+              std::shared_ptr<RNSkCanvasProvider> canvasProvider)
+      : RNSkView(context, canvasProvider,
+                 std::make_shared<RNSkDomRenderer>(
+                     std::bind(&RNSkView::requestRedraw, this), context)) {}
+
+  void updateTouchState(std::vector<RNSkTouchInfo> &touches) override {
+    std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
+        ->updateTouches(touches);
+    RNSkView::updateTouchState(touches);
+  }
+
+  void setJsiProperties(
+      std::unordered_map<std::string, JsiValueWrapper> &props) override {
+
+    RNSkView::setJsiProperties(props);
+
+    for (auto &prop : props) {
+      if (prop.first == "onTouch") {
+        if (prop.second.isUndefinedOrNull()) {
+          // Clear touchCallback
+          std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
+              ->setOnTouchCallback(nullptr);
+          requestRedraw();
+          continue;
+
+        } else if (prop.second.getType() != JsiWrapperValueType::Function) {
+          // We expect a function for the draw callback custom property
+          throw std::runtime_error(
+              "Expected a function for the onTouch property.");
+        }
+
+        // Save callback
+        std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
+            ->setOnTouchCallback(prop.second.getAsFunction());
+
+        // Request redraw
+        requestRedraw();
+
+      } else if (prop.first == "root") {
+        // Save root
+        if (prop.second.isUndefined() || prop.second.isNull()) {
+          std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
+              ->setRoot(nullptr);
+        } else {
+          std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
+              ->setRoot(std::dynamic_pointer_cast<JsiDomRenderNode>(
+                  prop.second.getAsHostObject()));
+        }
+
+        // Request redraw
+        requestRedraw();
+      }
+    }
+  }
+};
+} // namespace RNSkia

package/cpp/rnskia/RNSkInfoParameter.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiHostObject.h"
+#include "RNSkView.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class RNSkInfoObject : public RNJsi::JsiHostObject {
+public:
+  JSI_PROPERTY_GET(width) { return _width; }
+  JSI_PROPERTY_GET(height) { return _height; }
+  JSI_PROPERTY_GET(timestamp) { return _timestamp; }
+
+  JSI_PROPERTY_GET(touches) {
+    auto ops = jsi::Array(runtime, _touchesCache.size());
+    for (size_t i = 0; i < _touchesCache.size(); i++) {
+      auto cur = _touchesCache.at(i);
+      auto touches = jsi::Array(runtime, cur.size());
+      for (size_t n = 0; n < cur.size(); n++) {
+        auto touchObj = jsi::Object(runtime);
+        auto t = cur.at(n);
+        touchObj.setProperty(runtime, "x", t.x);
+        touchObj.setProperty(runtime, "y", t.y);
+        touchObj.setProperty(runtime, "force", t.force);
+        touchObj.setProperty(runtime, "type", static_cast<double>(t.type));
+        touchObj.setProperty(runtime, "timestamp",
+                             static_cast<double>(t.timestamp / 1000.0));
+        touchObj.setProperty(runtime, "id", static_cast<double>(t.id));
+        touches.setValueAtIndex(runtime, n, touchObj);
+      }
+      ops.setValueAtIndex(runtime, i, touches);
+    }
+    return ops;
+  }
+
+  JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(RNSkInfoObject, width),
+                              JSI_EXPORT_PROP_GET(RNSkInfoObject, height),
+                              JSI_EXPORT_PROP_GET(RNSkInfoObject, timestamp),
+                              JSI_EXPORT_PROP_GET(RNSkInfoObject, touches))
+
+  void beginDrawOperation(int width, int height, double timestamp) {
+    _width = width;
+    _height = height;
+    _timestamp = timestamp;
+
+    // Copy touches so that we can continue to add/receive touch points while
+    // in the drawing callback.
+    std::lock_guard<std::mutex> lock(_mutex);
+    _touchesCache.clear();
+    _touchesCache.reserve(_currentTouches.size());
+    for (size_t i = 0; i < _currentTouches.size(); ++i) {
+      _touchesCache.push_back(_currentTouches.at(i));
+    }
+    _currentTouches.clear();
+  }
+
+  void endDrawOperation() { _touchesCache.clear(); }
+
+  void updateTouches(std::vector<RNSkTouchInfo> &touches) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    // Add timestamp
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                  std::chrono::system_clock::now().time_since_epoch())
+                  .count();
+
+    for (size_t i = 0; i < touches.size(); i++) {
+      touches.at(i).timestamp = ms;
+    }
+    _currentTouches.push_back(std::move(touches));
+  }
+
+  RNSkInfoObject() : JsiHostObject() {}
+
+private:
+  int _width;
+  int _height;
+  double _timestamp;
+  std::vector<std::vector<RNSkTouchInfo>> _currentTouches;
+  std::vector<std::vector<RNSkTouchInfo>> _touchesCache;
+  std::mutex _mutex;
+};
+} // namespace RNSkia

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -0,0 +1,286 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "JsiHostObject.h"
+#include "JsiValueWrapper.h"
+#include "RNSkPlatformContext.h"
+#include "RNSkView.h"
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+namespace jsi = facebook::jsi;
+
+using RNSkViewInfo = struct RNSkViewInfo {
+  RNSkViewInfo() { view = nullptr; }
+  std::shared_ptr<RNSkView> view;
+  std::unordered_map<std::string, RNJsi::JsiValueWrapper> props;
+};
+
+class RNSkJsiViewApi : public RNJsi::JsiHostObject,
+                       public std::enable_shared_from_this<RNSkJsiViewApi> {
+public:
+  /**
+   Sets a custom property on a view given a view id. The property name/value
+   will be stored in a map alongside the id of the view and propagated to the
+   view when needed.
+   */
+  JSI_HOST_FUNCTION(setJsiProperty) {
+    if (count != 3) {
+      _platformContext->raiseError(
+          std::string("setJsiProperty: Expected 3 arguments, got " +
+                      std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "setJsiProperty: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[1].isString()) {
+      _platformContext->raiseError("setJsiProperty: Second argument must be "
+                                   "the name of the property to set.");
+
+      return jsi::Value::undefined();
+    }
+
+    auto nativeId = arguments[0].asNumber();
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto info = getEnsuredViewInfo(nativeId);
+
+    info->props.insert_or_assign(arguments[1].asString(runtime).utf8(runtime),
+                                 RNJsi::JsiValueWrapper(runtime, arguments[2]));
+
+    // Now let's see if we have a view that we can update
+    if (info->view != nullptr) {
+      // Update view!
+      info->view->setNativeId(nativeId);
+      info->view->setJsiProperties(info->props);
+      info->props.clear();
+    }
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(requestRedraw) {
+    if (count != 1) {
+      _platformContext->raiseError(
+          std::string("requestRedraw: Expected 1 arguments, got " +
+                      std::to_string(count) + "."));
+
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "requestRedraw: First argument must be a number");
+
+      return jsi::Value::undefined();
+    }
+
+    // find Skia View
+    int nativeId = arguments[0].asNumber();
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto info = getEnsuredViewInfo(nativeId);
+    if (info->view != nullptr) {
+      info->view->requestRedraw();
+    }
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(makeImageSnapshot) {
+    if (count < 1) {
+      _platformContext->raiseError(
+          std::string("makeImageSnapshot: Expected at least 1 argument, got " +
+                      std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "makeImageSnapshot: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    // find Skia view
+    int nativeId = arguments[0].asNumber();
+    sk_sp<SkImage> image;
+    std::shared_ptr<RNSkView> view;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      auto info = getEnsuredViewInfo(nativeId);
+      view = info->view;
+    }
+    if (view != nullptr) {
+      if (count > 1 && !arguments[1].isUndefined() && !arguments[1].isNull()) {
+        auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
+        image = view->makeImageSnapshot(rect.get());
+      } else {
+        image = view->makeImageSnapshot(nullptr);
+      }
+      if (image == nullptr) {
+        throw jsi::JSError(runtime,
+                           "Could not create image from current surface.");
+        return jsi::Value::undefined();
+      }
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkImage>(_platformContext, image));
+    }
+    throw jsi::JSError(runtime, "No Skia View currently available.");
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(makeImageSnapshotAsync) {
+    if (count < 1) {
+      _platformContext->raiseError(std::string(
+          "makeImageSnapshotAsync: Expected at least 1 argument, got " +
+          std::to_string(count) + "."));
+      return jsi::Value::undefined();
+    }
+
+    if (!arguments[0].isNumber()) {
+      _platformContext->raiseError(
+          "makeImageSnapshot: First argument must be a number");
+      return jsi::Value::undefined();
+    }
+
+    // find Skia view
+    int nativeId = arguments[0].asNumber();
+    std::shared_ptr<RNSkView> view;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      auto info = getEnsuredViewInfo(nativeId);
+      view = info->view;
+    }
+    auto context = _platformContext;
+    auto bounds =
+        count > 1 && !arguments[1].isUndefined() && !arguments[1].isNull()
+            ? JsiSkRect::fromValue(runtime, arguments[1])
+            : nullptr;
+    return RNJsi::JsiPromises::createPromiseAsJSIValue(
+        runtime, [context = std::move(context), view, bounds](
+                     jsi::Runtime &runtime,
+                     std::shared_ptr<RNJsi::JsiPromises::Promise> promise) {
+          context->runOnMainThread([&runtime, view = std::move(view),
+                                    promise = std::move(promise),
+                                    context = std::move(context), bounds]() {
+            auto image = view->makeImageSnapshot(
+                bounds == nullptr ? nullptr : bounds.get());
+            context->runOnJavascriptThread(
+                [&runtime, context = std::move(context),
+                 promise = std::move(promise), image = std::move(image)]() {
+                  if (image == nullptr) {
+                    promise->reject("Failed to make snapshot from view.");
+                    return;
+                  }
+                  promise->resolve(jsi::Object::createFromHostObject(
+                      runtime, std::make_shared<JsiSkImage>(std::move(context),
+                                                            std::move(image))));
+                });
+          });
+        });
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkJsiViewApi, setJsiProperty),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, requestRedraw),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, makeImageSnapshotAsync),
+                       JSI_EXPORT_FUNC(RNSkJsiViewApi, makeImageSnapshot))
+
+  /**
+   * Constructor
+   * @param platformContext Platform context
+   */
+  explicit RNSkJsiViewApi(std::shared_ptr<RNSkPlatformContext> platformContext)
+      : JsiHostObject(), _platformContext(platformContext) {}
+
+  /**
+   Call to remove all draw view infos
+   */
+  void unregisterAll() {
+    std::lock_guard<std::mutex> lock(_mutex);
+    // Unregister all views
+    auto tempList = _viewInfos;
+    for (const auto &info : tempList) {
+      unregisterSkiaView(info.first);
+    }
+    _viewInfos.clear();
+  }
+
+  /**
+   * Registers a skia view
+   * @param nativeId Id of view to register
+   * @param view View to register
+   */
+  void registerSkiaView(size_t nativeId, std::shared_ptr<RNSkView> view) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto info = getEnsuredViewInfo(nativeId);
+    info->view = view;
+    info->view->setNativeId(nativeId);
+    info->view->setJsiProperties(info->props);
+    info->props.clear();
+  }
+
+  /**
+   * Unregisters a Skia draw view
+   * @param nativeId View id
+   */
+  void unregisterSkiaView(size_t nativeId) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_viewInfos.count(nativeId) == 0) {
+      return;
+    }
+    auto info = getEnsuredViewInfo(nativeId);
+
+    info->view = nullptr;
+    _viewInfos.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.
+   */
+  void setSkiaView(size_t nativeId, std::shared_ptr<RNSkView> view) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_viewInfos.find(nativeId) == _viewInfos.end()) {
+      return;
+    }
+    auto info = getEnsuredViewInfo(nativeId);
+    if (view != nullptr) {
+      info->view = view;
+      info->view->setNativeId(nativeId);
+      info->view->setJsiProperties(info->props);
+      info->props.clear();
+    } else if (view == nullptr) {
+      info->view = view;
+    }
+  }
+
+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
+   */
+  RNSkViewInfo *getEnsuredViewInfo(size_t nativeId) {
+    if (_viewInfos.count(nativeId) == 0) {
+      RNSkViewInfo info;
+      _viewInfos.emplace(nativeId, info);
+    }
+    return &_viewInfos.at(nativeId);
+  }
+
+  std::unordered_map<size_t, RNSkViewInfo> _viewInfos;
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+  std::mutex _mutex;
+};
+} // namespace RNSkia

package/cpp/rnskia/RNSkManager.cpp

@@ -0,0 +1,87 @@
+#include "RNSkManager.h"
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkApi.h"
+#include "RNSkJsiViewApi.h"
+#include "RNSkView.h"
+
+#include "JsiDomApi.h"
+#include "RuntimeAwareCache.h"
+
+namespace RNSkia {
+namespace jsi = facebook::jsi;
+
+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)) {
+
+  // Register main runtime
+  BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
+
+  // 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->unregisterAll();
+  _platformContext->invalidate();
+}
+
+void RNSkManager::registerSkiaView(size_t nativeId,
+                                   std::shared_ptr<RNSkView> view) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->registerSkiaView(nativeId, view);
+}
+
+void RNSkManager::unregisterSkiaView(size_t nativeId) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->unregisterSkiaView(nativeId);
+}
+
+void RNSkManager::setSkiaView(size_t nativeId, std::shared_ptr<RNSkView> view) {
+  if (!_isInvalidated && _viewApi != nullptr)
+    _viewApi->setSkiaView(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 skiaDomApi = std::make_shared<JsiDomApi>(_platformContext);
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "SkiaDomApi",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(skiaDomApi)));
+}
+} // namespace RNSkia

package/cpp/rnskia/RNSkManager.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+
+#include "RNSkPlatformContext.h"
+
+namespace facebook {
+namespace react {
+class CallInvoker;
+}
+} // namespace facebook
+
+namespace RNSkia {
+class RNSkView;
+class RNSkJsiViewApi;
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+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 RNSkView with the given native id
+   * @param nativeId Native view id
+   * @param view View to register
+   */
+  void registerSkiaView(size_t nativeId, std::shared_ptr<RNSkView> view);
+
+  /**
+   * Unregisters the RNSkView from the list of registered views
+   * @param nativeId Native view Id
+   */
+  void unregisterSkiaView(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 setSkiaView(size_t nativeId, std::shared_ptr<RNSkView> view);
+
+  /**
+   * @return The platform context
+   */
+  std::shared_ptr<RNSkPlatformContext> getPlatformContext() {
+    return _platformContext;
+  }
+
+private:
+  /**
+   * Installs the javascript methods for registering/unregistering draw
+   * callbacks for RNSkViews. 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