@shopify/react-native-skia 0.1.155 → 0.1.157

package/cpp/rnskia/RNSkPlatformContext.h

@@ -2,8 +2,8 @@
 
 #include <exception>
 #include <functional>
-#include <mutex>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <thread>
 #include <unordered_map>
@@ -24,31 +24,31 @@
 
 namespace RNSkia {
 
-using namespace facebook;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
 
 class RNSkPlatformContext {
 public:
   /**
    * Constructor
    */
-  RNSkPlatformContext(
-      jsi::Runtime *runtime, std::shared_ptr<react::CallInvoker> callInvoker,
-      float pixelDensity)
+  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();
-        }
+        _dispatchQueue(
+            std::make_unique<RNSkDispatchQueue>("skia-render-thread")) {
+    _jsThreadId = std::this_thread::get_id();
+  }
 
   /**
    * Destructor
    */
-  virtual ~RNSkPlatformContext() {
-    invalidate();
-  }
-  
+  virtual ~RNSkPlatformContext() { invalidate(); }
+
   void invalidate() {
-    if(!_isValid) {
+    if (!_isValid) {
       return;
     }
     // Stop the refresh loop
@@ -58,20 +58,22 @@ public:
     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; }
+    if (!_isValid) {
+      return;
+    }
     _callInvoker->invokeAsync(std::move(func));
   }
 
@@ -79,7 +81,9 @@ public:
    Runs the function on the render thread
    */
   void runOnRenderThread(std::function<void()> func) {
-    if(!_isValid) { return; }
+    if (!_isValid) {
+      return;
+    }
     _dispatchQueue->dispatch(std::move(func));
   }
 
@@ -96,7 +100,7 @@ public:
   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
@@ -118,7 +122,7 @@ public:
   /**
    * @return Current scale factor for pixels
    */
-  float getPixelDensity() { return _pixelDensity; };
+  float getPixelDensity() { return _pixelDensity; }
 
   /**
    * Starts (if not started) a loop that will call back on display sync
@@ -126,7 +130,9 @@ public:
    * @returns Identifier of the draw loop entry
    */
   size_t beginDrawLoop(size_t nativeId, std::function<void(bool)> callback) {
-    if(!_isValid) { return 0; }
+    if (!_isValid) {
+      return 0;
+    }
     auto shouldStart = false;
     {
       std::lock_guard<std::mutex> lock(_drawCallbacksLock);
@@ -146,7 +152,9 @@ public:
    * @param nativeId Identifier of view to end
    */
   void endDrawLoop(size_t nativeId) {
-    if(!_isValid) { return; }
+    if (!_isValid) {
+      return;
+    }
     auto shouldStop = false;
     {
       std::lock_guard<std::mutex> lock(_drawCallbacksLock);
@@ -162,19 +170,22 @@ public:
 
   /**
    * 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
+   * @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; }
+    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());      
+      tmp.insert(_drawCallbacks.cbegin(), _drawCallbacks.cend());
     }
     for (auto it = tmp.begin(); it != tmp.end(); it++) {
       it->second(invalidated);
-    }    
+    }
   }
 
   virtual void startDrawLoop() = 0;
@@ -182,7 +193,7 @@ public:
 
 private:
   float _pixelDensity;
-  
+
   std::thread::id _jsThreadId;
 
   jsi::Runtime *_jsRuntime;

package/cpp/rnskia/RNSkValueApi.h

@@ -1,65 +1,64 @@
-
 #pragma once
 
+#include <memory>
+
 #include <JsiHostObject.h>
+#include <RNSkAnimation.h>
+#include <RNSkComputedValue.h>
 #include <RNSkPlatformContext.h>
 #include <RNSkValue.h>
-#include <RNSkComputedValue.h>
-#include <RNSkAnimation.h>
 #include <jsi/jsi.h>
 
 namespace RNSkia {
-using namespace facebook;
 
-class RNSkValueApi : public JsiHostObject {
+namespace jsi = facebook::jsi;
+
+class RNSkValueApi : public RNJsi::JsiHostObject {
 public:
   /**
    * Constructor
    * @param platformContext Platform context
    */
-  RNSkValueApi(std::shared_ptr<RNSkPlatformContext> platformContext)
+  explicit RNSkValueApi(std::shared_ptr<RNSkPlatformContext> platformContext)
       : JsiHostObject(), _platformContext(platformContext) {
-        _valueIdentifier = 50000;
-      }
+    _valueIdentifier = 50000;
+  }
 
   /**
    * Destructor
    */
-  ~RNSkValueApi() {    
-  }
-  
+  ~RNSkValueApi() {}
+
   JSI_HOST_FUNCTION(createValue) {
-    return jsi::Object::createFromHostObject(runtime,
-      std::make_shared<RNSkValue>(_platformContext, runtime, arguments, count));
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<RNSkValue>(_platformContext, runtime,
+                                             arguments, count));
   }
-  
+
   JSI_HOST_FUNCTION(createComputedValue) {
-    // Creation and initialization is done in two steps to be able to use weak references when setting
-    // up dependencies - since weak_from_this needs our instance to be a shared_ptr before calling
-    // weak_from_this().
-    auto computedValue = std::make_shared<RNSkComputedValue>(_platformContext, runtime, arguments, count);
+    // Creation and initialization is done in two steps to be able to use weak
+    // references when setting up dependencies - since weak_from_this needs our
+    // instance to be a shared_ptr before calling weak_from_this().
+    auto computedValue = std::make_shared<RNSkComputedValue>(
+        _platformContext, runtime, arguments, count);
     computedValue->initializeDependencies(runtime, arguments, count);
     return jsi::Object::createFromHostObject(runtime, computedValue);
   }
-  
+
   JSI_HOST_FUNCTION(createAnimation) {
-    return jsi::Object::createFromHostObject(runtime,
-      std::make_shared<RNSkAnimation>(_platformContext,
-                                      ++_valueIdentifier,
-                                      runtime,
-                                      arguments,
-                                      count));
+    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));
+    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, createComputedValue),
                        JSI_EXPORT_FUNC(RNSkValueApi, createClockValue),
@@ -68,6 +67,6 @@ public:
 private:
   // Platform context
   std::shared_ptr<RNSkPlatformContext> _platformContext;
-  std::atomic<long> _valueIdentifier;  
+  std::atomic<long> _valueIdentifier;
 };
 } // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -2,115 +2,127 @@
 #pragma once
 
 #include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 #include <RNSkPlatformContext.h>
 
 #include <JsiValueWrapper.h>
 
-#include <JsiSkRect.h>
 #include <JsiSkImage.h>
+#include <JsiSkRect.h>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include <SkSurface.h>
 #include <SkCanvas.h>
+#include <SkSurface.h>
 
 #pragma clang diagnostic pop
 
 namespace RNSkia {
 
-using namespace facebook;
+namespace jsi = facebook::jsi;
 
 class RNSkCanvasProvider {
 public:
-  RNSkCanvasProvider(std::function<void()> requestRedraw): _requestRedraw(requestRedraw) {}
-  
+  explicit RNSkCanvasProvider(std::function<void()> requestRedraw)
+      : _requestRedraw(requestRedraw) {}
+
   /**
    Returns the scaled width of the view
    */
   virtual float getScaledWidth() = 0;
-  
+
   /**
    Returns the scaled height of the view
    */
   virtual float getScaledHeight() = 0;
-  
+
   /**
    Render to a canvas
    */
-  virtual void renderToCanvas(const std::function<void(SkCanvas*)>&) = 0;
+  virtual void renderToCanvas(const std::function<void(SkCanvas *)> &) = 0;
+
 protected:
   std::function<void()> _requestRedraw;
 };
 
 class RNSkRenderer {
 public:
-  RNSkRenderer(std::function<void()> requestRedraw): _requestRedraw(requestRedraw) {}
-  
+  explicit RNSkRenderer(std::function<void()> requestRedraw)
+      : _requestRedraw(requestRedraw) {}
+
   /**
-   Tries to render the current set of drawing operations. If we're busy we'll return false so that the calling RNSkBaseDrawView
-   can request a new render next frame. The tryRender method is typically called on each frame if there are any redraw
-   requests. The method will be called from the main thread, so the implementor must make sure any thread requirements are
-   met before rendering. This method will also allow the rendering to be dispatched to another thread.
+   Tries to render the current set of drawing operations. If we're busy we'll
+   return false so that the calling RNSkBaseDrawView can request a new render
+   next frame. The tryRender method is typically called on each frame if there
+   are any redraw requests. The method will be called from the main thread, so
+   the implementor must make sure any thread requirements are met before
+   rendering. This method will also allow the rendering to be dispatched to
+   another thread.
    */
-  virtual bool tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
-  
+  virtual bool
+  tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
+
   /**
-   Renders directly to the canvas in the canvas provider. This method is called from a Javascript call to render a
-   snapshot of the SkiaView to an image, and can therefore run outside the tryRender loop and directly in the
-   javascript thread.
+   Renders directly to the canvas in the canvas provider. This method is called
+   from a Javascript call to render a snapshot of the SkiaView to an image, and
+   can therefore run outside the tryRender loop and directly in the javascript
+   thread.
    */
-  virtual void renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
-  
-  void setShowDebugOverlays(bool showDebugOverlays) { _showDebugOverlays = showDebugOverlays; }
+  virtual void
+  renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
+
+  void setShowDebugOverlays(bool showDebugOverlays) {
+    _showDebugOverlays = showDebugOverlays;
+  }
   bool getShowDebugOverlays() { return _showDebugOverlays; }
-  
+
 protected:
   std::function<void()> _requestRedraw;
   bool _showDebugOverlays;
 };
 
-class RNSkImageCanvasProvider: public RNSkCanvasProvider {
+class RNSkImageCanvasProvider : public RNSkCanvasProvider {
 public:
-  RNSkImageCanvasProvider(std::function<void()> requestRedraw,
-                          float width,
-                          float height):
-    RNSkCanvasProvider(requestRedraw),
-    _width(width),
-    _height(height) {
+  RNSkImageCanvasProvider(std::function<void()> requestRedraw, float width,
+                          float height)
+      : RNSkCanvasProvider(requestRedraw), _width(width), _height(height) {
     _surface = SkSurface::MakeRasterN32Premul(_width, _height);
   }
-  
+
   /**
    Returns a snapshot of the current surface/canvas
    */
   sk_sp<SkImage> makeSnapshot(std::shared_ptr<SkRect> bounds) {
-    if(bounds != nullptr) {
-      SkIRect b = SkIRect::MakeXYWH(bounds->x(), bounds->y(), bounds->width(), bounds->height());
+    if (bounds != nullptr) {
+      SkIRect b = SkIRect::MakeXYWH(bounds->x(), bounds->y(), bounds->width(),
+                                    bounds->height());
       return _surface->makeImageSnapshot(b);
     } else {
       return _surface->makeImageSnapshot();
     }
   }
-  
+
   /**
    Returns the scaled width of the view
    */
   float getScaledWidth() override { return _width; };
-  
+
   /**
    Returns the scaled height of the view
    */
   float getScaledHeight() override { return _height; };
-  
+
   /**
    Render to a canvas
    */
-  void renderToCanvas(const std::function<void(SkCanvas*)>& cb) override {
+  void renderToCanvas(const std::function<void(SkCanvas *)> &cb) override {
     cb(_surface->getCanvas());
   };
-  
+
 private:
   float _width;
   float _height;
@@ -129,52 +141,50 @@ using RNSkTouchInfo = struct {
   long timestamp;
 };
 
-class RNSkView: public std::enable_shared_from_this<RNSkView> {
+class RNSkView : public std::enable_shared_from_this<RNSkView> {
 public:
   /**
    * Constructor
    */
   RNSkView(std::shared_ptr<RNSkPlatformContext> context,
            std::shared_ptr<RNSkCanvasProvider> canvasProvider,
-           std::shared_ptr<RNSkRenderer> renderer):
-    _platformContext(context),
-    _canvasProvider(canvasProvider),
-    _renderer(renderer) {}
+           std::shared_ptr<RNSkRenderer> renderer)
+      : _platformContext(context), _canvasProvider(canvasProvider),
+        _renderer(renderer) {}
 
   /**
    Destructor
    */
-  virtual ~RNSkView() {
-    endDrawingLoop();
-  }
-  
+  virtual ~RNSkView() { endDrawingLoop(); }
+
   /**
-   Sets custom properties. Custom properties are properties that are set directly from Javascript without having
-   to go through the async bridge.
+   Sets custom properties. Custom properties are properties that are set
+   directly from Javascript without having to go through the async bridge.
    */
-  virtual void setJsiProperties(std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) {
-    throw std::runtime_error("The base Skia View does not support any custom properties.");
-  };
-  
+  virtual void setJsiProperties(
+      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) {
+    throw std::runtime_error(
+        "The base Skia View does not support any custom properties.");
+  }
+
   /**
    Calls a custom action.
    */
-  virtual jsi::Value callJsiMethod(jsi::Runtime& runtime,
-                                   const std::string& name,
-                                   const jsi::Value *arguments,
-                                   size_t count) {
-    throw std::runtime_error("The base Skia View does not support any commands. Command " + name + " not found.");
-  };
+  virtual jsi::Value callJsiMethod(jsi::Runtime &runtime,
+                                   const std::string &name,
+                                   const jsi::Value *arguments, size_t count) {
+    throw std::runtime_error(
+        "The base Skia View does not support any commands. Command " + name +
+        " not found.");
+  }
 
   /**
    * Repaints the Skia view using the underlying context and the drawcallback.
    * This method schedules a draw request that will be run on the correct
    * thread and js runtime.
    */
-  void requestRedraw() {
-    _redrawRequestCounter++;
-  }
-  
+  void requestRedraw() { _redrawRequestCounter++; }
+
   /**
    Sets the native id of the view
    */
@@ -182,12 +192,12 @@ public:
     _nativeId = nativeId;
     beginDrawingLoop();
   }
-  
+
   /**
    Returns the native id
    */
   size_t getNativeId() { return _nativeId; }
-  
+
   /**
    Sets the drawing mode for the view
    */
@@ -207,34 +217,38 @@ public:
   /**
     Update touch state with new touch points
    */
-  virtual void updateTouchState(std::vector<RNSkTouchInfo>&) {
+  virtual void updateTouchState(std::vector<RNSkTouchInfo> &) {
     requestRedraw();
   }
-  
+
   /**
    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),
-                                                              _canvasProvider->getScaledWidth(),
-                                                              _canvasProvider->getScaledHeight());
-    
+    auto provider = std::make_shared<RNSkImageCanvasProvider>(
+        std::bind(&RNSkView::requestRedraw, this),
+        _canvasProvider->getScaledWidth(), _canvasProvider->getScaledHeight());
+
     _renderer->renderImmediate(provider);
     return provider->makeSnapshot(bounds);
   }
 
 protected:
-  std::shared_ptr<RNSkPlatformContext> getPlatformContext() { return _platformContext; }
-  std::shared_ptr<RNSkCanvasProvider> getCanvasProvider() { return _canvasProvider; }
+  std::shared_ptr<RNSkPlatformContext> getPlatformContext() {
+    return _platformContext;
+  }
+  std::shared_ptr<RNSkCanvasProvider> getCanvasProvider() {
+    return _canvasProvider;
+  }
   std::shared_ptr<RNSkRenderer> getRenderer() { return _renderer; }
 
   /**
-   Ends an ongoing beginDrawCallback loop for this view. This method is made protected if
-   the drawing loop should be stopped before reaching the destructor (like we do for Android
-   views)
+   Ends an ongoing beginDrawCallback loop for this view. This method is made
+   protected if the drawing loop should be stopped before reaching the
+   destructor (like we do for Android views)
    */
   void endDrawingLoop() {
-    if(_drawingLoopId != 0) {
+    if (_drawingLoopId != 0) {
       _drawingLoopId = 0;
       _platformContext->endDrawLoop(_nativeId);
     }
@@ -249,39 +263,40 @@ private:
       return;
     }
     // Set to zero to avoid calling beginDrawLoop before we return
-    _drawingLoopId = _platformContext->beginDrawLoop(_nativeId,
-      [weakSelf = weak_from_this()](bool invalidated) {
-      auto self = weakSelf.lock();
-      if(self) {
-        self->drawLoopCallback(invalidated);
-      }
-    });
+    _drawingLoopId = _platformContext->beginDrawLoop(
+        _nativeId, [weakSelf = weak_from_this()](bool invalidated) {
+          auto self = weakSelf.lock();
+          if (self) {
+            self->drawLoopCallback(invalidated);
+          }
+        });
   }
 
   /**
     Draw loop callback
    */
   void drawLoopCallback(bool invalidated) {
-    if(_redrawRequestCounter > 0 || _drawingMode == RNSkDrawingMode::Continuous) {
-        _redrawRequestCounter = 0;
-        
-      if(!_renderer->tryRender(_canvasProvider)) {
-        // The renderer could not render cause it was busy, just schedule redrawing
-        // on the next frame.
+    if (_redrawRequestCounter > 0 ||
+        _drawingMode == RNSkDrawingMode::Continuous) {
+      _redrawRequestCounter = 0;
+
+      if (!_renderer->tryRender(_canvasProvider)) {
+        // The renderer could not render cause it was busy, just schedule
+        // redrawing on the next frame.
         requestRedraw();
       }
     }
   }
-  
+
   std::shared_ptr<RNSkPlatformContext> _platformContext;
   std::shared_ptr<RNSkCanvasProvider> _canvasProvider;
   std::shared_ptr<RNSkRenderer> _renderer;
 
   RNSkDrawingMode _drawingMode;
   size_t _nativeId;
-  
+
   size_t _drawingLoopId = 0;
-  std::atomic<int> _redrawRequestCounter = { 1 };
+  std::atomic<int> _redrawRequestCounter = {1};
 };
 
 } // namespace RNSkia