@shopify/react-native-skia 0.1.155 → 0.1.157

package/cpp/rnskia/RNSkJsView.cpp

@@ -1,29 +1,30 @@
+#include <utility>
+
 #include "RNSkJsView.h"
 
-namespace RNSkia
-{
+namespace RNSkia {
 
 RNSkJsRenderer::RNSkJsRenderer(std::function<void()> requestRedraw,
-                               std::shared_ptr<RNSkPlatformContext> context) :
-  RNSkRenderer(requestRedraw),
-  _jsiCanvas(std::make_shared<JsiSkCanvas>(context)),
-  _platformContext(std::move(context)),
-  _infoObject(std::make_shared<RNSkInfoObject>()),
-  _jsDrawingLock(std::make_shared<std::timed_mutex>()),
-  _gpuDrawingLock(std::make_shared<std::timed_mutex>()),
-  _jsTimingInfo("SKIA/JS"),
-  _gpuTimingInfo("SKIA/GPU") {
-}
-
-bool RNSkJsRenderer::tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
+                               std::shared_ptr<RNSkPlatformContext> context)
+    : RNSkRenderer(requestRedraw),
+      _jsiCanvas(std::make_shared<JsiSkCanvas>(context)),
+      _platformContext(std::move(context)),
+      _infoObject(std::make_shared<RNSkInfoObject>()),
+      _jsDrawingLock(std::make_shared<std::timed_mutex>()),
+      _gpuDrawingLock(std::make_shared<std::timed_mutex>()),
+      _jsTimingInfo("SKIA/JS"), _gpuTimingInfo("SKIA/GPU") {}
+
+bool RNSkJsRenderer::tryRender(
+    std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
   // We render on the javascript thread.
-  if(_jsDrawingLock->try_lock()) {
-    _platformContext->runOnJavascriptThread([weakSelf = weak_from_this(), canvasProvider](){
-      auto self = weakSelf.lock();
-      if(self) {
-        self->performDraw(canvasProvider);
-      }
-    });
+  if (_jsDrawingLock->try_lock()) {
+    _platformContext->runOnJavascriptThread(
+        [weakSelf = weak_from_this(), canvasProvider]() {
+          auto self = weakSelf.lock();
+          if (self) {
+            self->performDraw(canvasProvider);
+          }
+        });
     return true;
   } else {
 #ifdef DEBUG
@@ -31,84 +32,87 @@ bool RNSkJsRenderer::tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvide
 #endif
     return false;
   }
-};
+}
 
-void RNSkJsRenderer::renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
-  milliseconds ms = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
-  canvasProvider->renderToCanvas([&](SkCanvas* canvas) {
+void RNSkJsRenderer::renderImmediate(
+    std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
+  std::chrono::milliseconds ms =
+      std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::system_clock::now().time_since_epoch());
+  canvasProvider->renderToCanvas([&](SkCanvas *canvas) {
     // Create jsi canvas
     auto jsiCanvas = std::make_shared<JsiSkCanvas>(_platformContext);
     jsiCanvas->setCanvas(canvas);
-    
-    drawInJsiCanvas(std::move(jsiCanvas),
-                    canvasProvider->getScaledWidth(),
-                    canvasProvider->getScaledHeight(),
-                    ms.count() / 1000);
+
+    drawInJsiCanvas(std::move(jsiCanvas), canvasProvider->getScaledWidth(),
+                    canvasProvider->getScaledHeight(), ms.count() / 1000);
   });
-};
+}
 
-void RNSkJsRenderer::setDrawCallback(std::shared_ptr<jsi::Function> drawCallback) {
+void RNSkJsRenderer::setDrawCallback(
+    std::shared_ptr<jsi::Function> drawCallback) {
   _drawCallback = drawCallback;
 }
 
 std::shared_ptr<RNSkInfoObject> RNSkJsRenderer::getInfoObject() {
   return _infoObject;
 }
-  
-void RNSkJsRenderer::performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
+
+void RNSkJsRenderer::performDraw(
+    std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
   // Start timing
   _jsTimingInfo.beginTiming();
-  
+
   // Record the drawing operations on the JS thread so that we can
   // move the actual drawing onto the render thread later
   SkPictureRecorder recorder;
   SkRTreeFactory factory;
-  SkCanvas* canvas = recorder.beginRecording(canvasProvider->getScaledWidth(),
-                                             canvasProvider->getScaledHeight(),
-                                             &factory);
-  
+  SkCanvas *canvas =
+      recorder.beginRecording(canvasProvider->getScaledWidth(),
+                              canvasProvider->getScaledHeight(), &factory);
+
   _jsiCanvas->setCanvas(canvas);
-  
+
   // Get current milliseconds
-  milliseconds ms = duration_cast<milliseconds>(
-          system_clock::now().time_since_epoch());
-  
+  std::chrono::milliseconds ms =
+      std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::system_clock::now().time_since_epoch());
+
   try {
     // Perform the javascript drawing
-    drawInJsiCanvas(_jsiCanvas,
-                    canvasProvider->getScaledWidth(),
-                    canvasProvider->getScaledHeight(),
-                    ms.count() / 1000.0);
-    
-  } catch(...) {
+    drawInJsiCanvas(_jsiCanvas, canvasProvider->getScaledWidth(),
+                    canvasProvider->getScaledHeight(), ms.count() / 1000.0);
+
+  } catch (...) {
     _jsTimingInfo.stopTiming();
     _jsDrawingLock->unlock();
     throw;
   }
-  
+
   // Finish drawing operations
   auto p = recorder.finishRecordingAsPicture();
 
   _jsiCanvas->setCanvas(nullptr);
-  
+
   // Calculate duration
   _jsTimingInfo.stopTiming();
-  
-  if(_gpuDrawingLock->try_lock()) {
+
+  if (_gpuDrawingLock->try_lock()) {
 
     // Post drawing message to the render thread where the picture recorded
     // will be sent to the GPU/backend for rendering to screen.
     auto gpuLock = _gpuDrawingLock;
-    _platformContext->runOnRenderThread([weakSelf = weak_from_this(), p = std::move(p), gpuLock, canvasProvider]() {
+    _platformContext->runOnRenderThread([weakSelf = weak_from_this(),
+                                         p = std::move(p), gpuLock,
+                                         canvasProvider]() {
       auto self = weakSelf.lock();
       if (self) {
         // Draw the picture recorded on the real GPU canvas
         self->_gpuTimingInfo.beginTiming();
-        
-        canvasProvider->renderToCanvas([p = std::move(p)](SkCanvas* canvas) {
-          canvas->drawPicture(p);
-        });
-        
+
+        canvasProvider->renderToCanvas(
+            [p = std::move(p)](SkCanvas *canvas) { canvas->drawPicture(p); });
+
         self->_gpuTimingInfo.stopTiming();
       }
       // Unlock GPU drawing
@@ -121,17 +125,16 @@ void RNSkJsRenderer::performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvi
     // Request a new redraw since the last frame was skipped.
     _requestRedraw();
   }
-  
+
   // Unlock JS drawing
   _jsDrawingLock->unlock();
 }
-  
+
 void RNSkJsRenderer::callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas,
-                        int width,
-                        int height,
-                        double timestamp) {
-  
-  if(_drawCallback == nullptr) {
+                                        int width, int height,
+                                        double timestamp) {
+
+  if (_drawCallback == nullptr) {
     return;
   }
 
@@ -150,9 +153,8 @@ void RNSkJsRenderer::callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas,
   args[1] = jsi::Object::createFromHostObject(*runtime, _infoObject);
 
   // To be able to call the drawing function we'll wrap it once again
-  _drawCallback->call(*runtime,
-                      static_cast<const jsi::Value *>(args.data()),
-                      (size_t)2);
+  _drawCallback->call(*runtime, static_cast<const jsi::Value *>(args.data()),
+                      static_cast<size_t>(2));
 
   // Reset touches
   _infoObject->endDrawOperation();
@@ -162,16 +164,17 @@ void RNSkJsRenderer::callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas,
 
     // Display average rendering timer
     auto jsAvg = _jsTimingInfo.getAverage();
-    //auto jsFps = _jsTimingInfo.getFps();
+    // auto jsFps = _jsTimingInfo.getFps();
 
     auto gpuAvg = _gpuTimingInfo.getAverage();
-    //auto gpuFps = _gpuTimingInfo.getFps();
+    // auto gpuFps = _gpuTimingInfo.getFps();
 
     auto total = jsAvg + gpuAvg;
 
     // Build string
     std::ostringstream stream;
-    stream << "js: " << jsAvg << "ms gpu: " << gpuAvg << "ms " << " total: " << total << "ms";
+    stream << "js: " << jsAvg << "ms gpu: " << gpuAvg << "ms "
+           << " total: " << total << "ms";
 
     std::string debugString = stream.str();
 
@@ -181,16 +184,14 @@ void RNSkJsRenderer::callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas,
     auto paint = SkPaint();
     paint.setColor(SkColors::kRed);
     jsiCanvas->getCanvas()->drawSimpleText(
-            debugString.c_str(), debugString.size(), SkTextEncoding::kUTF8, 8,
-            18, font, paint);
+        debugString.c_str(), debugString.size(), SkTextEncoding::kUTF8, 8, 18,
+        font, paint);
   }
 }
 
 void RNSkJsRenderer::drawInJsiCanvas(std::shared_ptr<JsiSkCanvas> jsiCanvas,
-                     int width,
-                     int height,
-                     double time) {
-  
+                                     int width, int height, double time) {
+
   // Call the draw drawCallback and perform js based drawing
   auto skCanvas = jsiCanvas->getCanvas();
   if (_drawCallback != nullptr && skCanvas != nullptr) {
@@ -198,14 +199,14 @@ void RNSkJsRenderer::drawInJsiCanvas(std::shared_ptr<JsiSkCanvas> jsiCanvas,
     auto pd = _platformContext->getPixelDensity();
     skCanvas->save();
     skCanvas->scale(pd, pd);
-    
+
     // Call draw function.
     callJsDrawCallback(jsiCanvas, width / pd, height / pd, time);
-    
+
     // Restore and flush canvas
     skCanvas->restore();
     skCanvas->flush();
   }
 }
 
-} // Namespace RNSkia
+} // namespace RNSkia

package/cpp/rnskia/RNSkJsView.h

@@ -3,25 +3,26 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <vector>
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 #include <jsi/jsi.h>
 
 #include <JsiValueWrapper.h>
 #include <RNSkView.h>
 
+#include <JsiSkCanvas.h>
 #include <RNSkInfoParameter.h>
+#include <RNSkLog.h>
 #include <RNSkPlatformContext.h>
 #include <RNSkTimingInfo.h>
-#include <RNSkLog.h>
-#include <JsiSkCanvas.h>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include <SkCanvas.h>
 #include <SkBBHFactory.h>
+#include <SkCanvas.h>
 #include <SkPictureRecorder.h>
 
 #pragma clang diagnostic pop
@@ -32,35 +33,31 @@ class SkImage;
 
 namespace RNSkia {
 class JsiSkCanvas;
-using namespace facebook;
+namespace jsi = facebook::jsi;
 
-class RNSkJsRenderer:
-  public RNSkRenderer,
-  public std::enable_shared_from_this<RNSkJsRenderer> {
+class RNSkJsRenderer : public RNSkRenderer,
+                       public std::enable_shared_from_this<RNSkJsRenderer> {
 public:
   RNSkJsRenderer(std::function<void()> requestRedraw,
                  std::shared_ptr<RNSkPlatformContext> context);
-  
+
   bool tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override;
-  
-  void renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override;
-  
+
+  void
+  renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override;
+
   void setDrawCallback(std::shared_ptr<jsi::Function> drawCallback);
-    
+
   std::shared_ptr<RNSkInfoObject> getInfoObject();
-    
+
 private:
   void performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider);
-    
-  void callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas,
-                          int width,
-                          int height,
-                          double timestamp);
-  
-  void drawInJsiCanvas(std::shared_ptr<JsiSkCanvas> jsiCanvas,
-                       int width,
-                       int height,
-                       double time);
+
+  void callJsDrawCallback(std::shared_ptr<JsiSkCanvas> jsiCanvas, int width,
+                          int height, double timestamp);
+
+  void drawInJsiCanvas(std::shared_ptr<JsiSkCanvas> jsiCanvas, int width,
+                       int height, double time);
 
   std::shared_ptr<RNSkPlatformContext> _platformContext;
   std::shared_ptr<jsi::Function> _drawCallback;
@@ -72,36 +69,43 @@ private:
   RNSkTimingInfo _gpuTimingInfo;
 };
 
-class RNSkJsView: public RNSkView {
+class RNSkJsView : public RNSkView {
 public:
   /**
    * Constructor
    */
   RNSkJsView(std::shared_ptr<RNSkPlatformContext> context,
-             std::shared_ptr<RNSkCanvasProvider> canvasProvider):
-    RNSkView(context,
-             canvasProvider,
-             std::make_shared<RNSkJsRenderer>(std::bind(&RNSkJsView::requestRedraw, this), context)) {}
-  
-  void updateTouchState(std::vector<RNSkTouchInfo>& touches) override {
-    std::static_pointer_cast<RNSkJsRenderer>(getRenderer())->getInfoObject()->updateTouches(touches);
+             std::shared_ptr<RNSkCanvasProvider> canvasProvider)
+      : RNSkView(context, canvasProvider,
+                 std::make_shared<RNSkJsRenderer>(
+                     std::bind(&RNSkJsView::requestRedraw, this), context)) {}
+
+  void updateTouchState(std::vector<RNSkTouchInfo> &touches) override {
+    std::static_pointer_cast<RNSkJsRenderer>(getRenderer())
+        ->getInfoObject()
+        ->updateTouches(touches);
     RNSkView::updateTouchState(touches);
   }
-  
-  void setJsiProperties(std::unordered_map<std::string, JsiValueWrapper> &props) override {
-    for(auto& prop: props) {
-      if(prop.first == "drawCallback") {
-        if(prop.second.isUndefinedOrNull()) {
+
+  void setJsiProperties(
+      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) override {
+    for (auto &prop : props) {
+      if (prop.first == "drawCallback") {
+        if (prop.second.isUndefinedOrNull()) {
           // Clear drawcallback
-          std::static_pointer_cast<RNSkJsRenderer>(getRenderer())->setDrawCallback(nullptr);
+          std::static_pointer_cast<RNSkJsRenderer>(getRenderer())
+              ->setDrawCallback(nullptr);
           return;
-        } else if (prop.second.getType() != JsiWrapperValueType::Function) {
+        } else if (prop.second.getType() !=
+                   RNJsi::JsiWrapperValueType::Function) {
           // We expect a function for the draw callback custom property
-          throw std::runtime_error("Expected a function for the drawCallback custom property.");
+          throw std::runtime_error(
+              "Expected a function for the drawCallback custom property.");
         }
 
         // Save callback
-        std::static_pointer_cast<RNSkJsRenderer>(getRenderer())->setDrawCallback(prop.second.getAsFunction());        
+        std::static_pointer_cast<RNSkJsRenderer>(getRenderer())
+            ->setDrawCallback(prop.second.getAsFunction());
 
         // Request redraw
         requestRedraw();