@shopify/react-native-skia 0.0.135

package/cpp/skia/modules/svg/include/SkSVGUse.h

@@ -0,0 +1,42 @@
+/*
+ * 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 SkSVGUse_DEFINED
+#define SkSVGUse_DEFINED
+
+#include "modules/svg/include/SkSVGTransformableNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+/**
+ * Implements support for <use> (reference) elements.
+ * (https://www.w3.org/TR/SVG11/struct.html#UseElement)
+ */
+class SkSVGUse final : public SkSVGTransformableNode {
+public:
+    static sk_sp<SkSVGUse> Make() { return sk_sp<SkSVGUse>(new SkSVGUse()); }
+
+    void appendChild(sk_sp<SkSVGNode>) override;
+
+    SVG_ATTR(X   , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Y   , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Href, SkSVGIRI   , SkSVGIRI())
+
+protected:
+    bool onPrepareToRender(SkSVGRenderContext*) const override;
+    void onRender(const SkSVGRenderContext&) const override;
+    SkPath onAsPath(const SkSVGRenderContext&) const override;
+    SkRect onObjectBoundingBox(const SkSVGRenderContext&) const override;
+
+private:
+    SkSVGUse();
+
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+    using INHERITED = SkSVGTransformableNode;
+};
+
+#endif // SkSVGUse_DEFINED

package/cpp/skia/modules/svg/include/SkSVGValue.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGValue_DEFINED
+#define SkSVGValue_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkNoncopyable.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+class SkSVGValue : public SkNoncopyable {
+public:
+    enum class Type {
+        kColor,
+        kFilter,
+        kLength,
+        kNumber,
+        kObjectBoundingBoxUnits,
+        kPreserveAspectRatio,
+        kStopColor,
+        kString,
+        kTransform,
+        kViewBox,
+    };
+
+    Type type() const { return fType; }
+
+    template <typename T>
+    const T* as() const {
+        return fType == T::TYPE ? static_cast<const T*>(this) : nullptr;
+    }
+
+protected:
+    SkSVGValue(Type t) : fType(t) { }
+
+private:
+    Type fType;
+
+    using INHERITED = SkNoncopyable;
+};
+
+template <typename T, SkSVGValue::Type ValueType>
+class SkSVGWrapperValue final : public SkSVGValue {
+public:
+    static constexpr Type TYPE = ValueType;
+
+    explicit SkSVGWrapperValue(const T& v)
+        : INHERITED(ValueType)
+        , fWrappedValue(v) { }
+
+    operator const T&() const { return fWrappedValue; }
+    const T* operator->() const { return &fWrappedValue; }
+
+private:
+    // Stack-only
+    void* operator new(size_t) = delete;
+    void* operator new(size_t, void*) = delete;
+
+    const T& fWrappedValue;
+
+    using INHERITED = SkSVGValue;
+};
+
+using SkSVGColorValue        = SkSVGWrapperValue<SkSVGColorType    , SkSVGValue::Type::kColor     >;
+using SkSVGLengthValue       = SkSVGWrapperValue<SkSVGLength       , SkSVGValue::Type::kLength    >;
+using SkSVGTransformValue    = SkSVGWrapperValue<SkSVGTransformType, SkSVGValue::Type::kTransform >;
+using SkSVGViewBoxValue      = SkSVGWrapperValue<SkSVGViewBoxType  , SkSVGValue::Type::kViewBox   >;
+using SkSVGNumberValue       = SkSVGWrapperValue<SkSVGNumberType   , SkSVGValue::Type::kNumber    >;
+using SkSVGStringValue       = SkSVGWrapperValue<SkSVGStringType   , SkSVGValue::Type::kString    >;
+using SkSVGStopColorValue    = SkSVGWrapperValue<SkSVGStopColor    , SkSVGValue::Type::kStopColor >;
+
+using SkSVGPreserveAspectRatioValue    = SkSVGWrapperValue<SkSVGPreserveAspectRatio,
+                                                           SkSVGValue::Type::kPreserveAspectRatio>;
+
+using SkSVGObjectBoundingBoxUnitsValue = SkSVGWrapperValue<SkSVGObjectBoundingBoxUnits,
+                                                           SkSVGValue::Type::kObjectBoundingBoxUnits>;
+
+#endif // SkSVGValue_DEFINED

package/cpp/skia/readme.txt

@@ -0,0 +1 @@
+Placeholder for the Skia include files.

package/cpp/utils/RNSkLog.h

@@ -0,0 +1,80 @@
+//
+// Created by Christian Falch on 26/08/2021.
+//
+
+#pragma once
+
+#include <string>
+#include <jsi/jsi.h>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+#ifdef TARGET_OS_IPHONE
+#include <syslog.h>
+#endif
+
+namespace RNSkia {
+
+using namespace facebook;
+
+class RNSkLogger {
+public:
+  /**
+   * Logs message to console
+   * @param message Message to be written out
+   */
+  static void logToConsole(std::string message) {
+#ifdef ANDROID
+    __android_log_write(ANDROID_LOG_INFO, "RNSkia", message.c_str());
+#endif
+
+#ifdef TARGET_OS_IPHONE
+    syslog(LOG_ERR, "%s\n", message.c_str());
+#endif
+  }
+
+  /**
+   * Logs to console
+   * @param fmt Format string
+   * @param ... Arguments to format string
+   */
+  static void logToConsole(const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+
+    static char buffer[512];
+    vsnprintf(buffer, 512, fmt, args);
+#ifdef ANDROID
+    __android_log_write(ANDROID_LOG_INFO, "RNSkia", buffer);
+#endif
+#ifdef TARGET_OS_IPHONE
+    syslog(LOG_ERR, "%s\n", buffer);
+#endif
+    va_end(args);
+  }
+  
+  static void logToJavascriptConsole(jsi::Runtime& runtime, const std::string& message) {
+    auto console = RNSkLogger::getJavascriptConsole(runtime).asObject(runtime);
+    auto log = console.getPropertyAsFunction(runtime, "log");
+    log.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+  
+  static void warnToJavascriptConsole(jsi::Runtime& runtime, const std::string& message) {
+    auto console = RNSkLogger::getJavascriptConsole(runtime).asObject(runtime);
+    auto warn = console.getPropertyAsFunction(runtime, "warn");
+    warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+  
+private:
+  static jsi::Value getJavascriptConsole(jsi::Runtime& runtime) {
+    auto console = runtime.global().getProperty(runtime, "console");
+    if(console.isUndefined() || console.isNull()) {
+      jsi::detail::throwJSError(runtime, "Could not find console object.");
+      return jsi::Value::undefined();
+    }
+    return console;
+  }
+};
+} // namespace RNSkia

package/cpp/utils/RNSkMeasureTime.h

@@ -0,0 +1,32 @@
+//
+// Created by Christian Falch on 24/08/2021.
+//
+
+#pragma once
+
+#include <chrono>
+#include <string>
+
+#include <RNSkLog.h>
+
+namespace RNSkia {
+
+using namespace std::chrono;
+
+class RNSkMeasureTime {
+public:
+  RNSkMeasureTime(const std::string &name)
+      : _name(name), _start(high_resolution_clock::now()){}
+
+  ~RNSkMeasureTime() {
+    auto stop = high_resolution_clock::now();
+    auto duration = duration_cast<milliseconds>(stop - _start).count();
+    RNSkLogger::logToConsole("%s: %lld ms\n", _name.c_str(), duration);
+  }
+
+private:
+  std::string _name;
+  time_point<steady_clock> _start;
+};
+
+}; // namespace RNSkia

package/cpp/utils/RNSkTimingInfo.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <RNSkLog.h>
+#include <chrono>
+
+#define NUMBER_OF_DURATION_SAMPLES 10
+
+namespace RNSkia {
+
+using namespace std::chrono;
+using frame = duration<int32_t, std::ratio<1, 60>>;
+using ms = duration<float, std::milli>;
+
+class RNSkTimingInfo {
+public:
+  RNSkTimingInfo(const std::string &name): _name(std::move(name)) {
+    reset();
+  }
+
+  ~RNSkTimingInfo() {}
+
+  void reset() {
+    _lastDurationIndex = 0;
+    _lastDurationsCount = 0;
+    _lastDuration = 0;
+    _prevFpsTimer = -1;
+    _frameCount = 0;
+    _lastFrameCount = -1;
+    _didSkip = false;
+  }
+  
+  void beginTiming() {
+    _start = high_resolution_clock::now();
+  }
+  
+  void stopTiming() {
+    time_point<steady_clock> stop = high_resolution_clock::now();
+    addLastDuration(duration_cast<milliseconds>(stop - _start).count());
+    tick(stop);
+    if(_didSkip) {
+      _didSkip = false;
+      RNSkLogger::logToConsole("%s: Skipped frame. Previous frame time: %lldms", _name.c_str(), _lastDuration);
+    }
+  }
+
+  void markSkipped() {
+    _didSkip = true;
+  }
+
+  long getAverage() { return static_cast<long>(_average); }
+  long getFps() { return _lastFrameCount; }
+
+  void addLastDuration(long duration) {
+    _lastDuration = duration;
+
+    // Average duration
+    _lastDurations[_lastDurationIndex++] = _lastDuration;
+
+    if (_lastDurationIndex == NUMBER_OF_DURATION_SAMPLES) {
+      _lastDurationIndex = 0;
+    }
+
+    if (_lastDurationsCount < NUMBER_OF_DURATION_SAMPLES) {
+      _lastDurationsCount++;
+    }
+
+    _average = 0;
+    for (size_t i = 0; i < _lastDurationsCount; i++) {
+      _average = _average + _lastDurations[i];
+    }
+    _average = _average / _lastDurationsCount;
+  }
+
+private:
+  
+  void tick(time_point<steady_clock> now) {
+    auto ms = duration_cast<milliseconds>(now.time_since_epoch()).count();
+    
+    if(_prevFpsTimer == -1) {
+      _prevFpsTimer = ms;
+    } else if(ms - _prevFpsTimer >= 1000) {
+      _lastFrameCount = _frameCount;
+      _prevFpsTimer = ms;
+      _frameCount = 0;
+    }
+    _frameCount++;
+  }
+  
+  double _lastTimeStamp;
+  long _lastDurations[NUMBER_OF_DURATION_SAMPLES];
+  int _lastDurationIndex;
+  int _lastDurationsCount;
+  long _lastDuration;
+  std::atomic<double> _average;
+  time_point<steady_clock> _start;
+  long _prevFpsTimer;
+  double _frameCount;
+  double _lastFrameCount;
+  double _didSkip;
+  std::string _name;
+};
+
+} // namespace RNSkia

package/ios/RNSkia-iOS/DisplayLink.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#import <CoreFoundation/CoreFoundation.h>
+#import <UIKit/UIKit.h>
+
+typedef void (^block_t)(double);
+@interface DisplayLink : NSObject {
+  CADisplayLink *_displayLink;
+}
+
+@property(nonatomic, copy) block_t updateBlock;
+
+- (void)start:(block_t)block;
+
+- (void)stop;
+
+@end

package/ios/RNSkia-iOS/DisplayLink.mm

@@ -0,0 +1,36 @@
+#import "DisplayLink.h"
+
+@implementation DisplayLink
+
+- (void)start:(block_t)block
+{
+    self.updateBlock = block;
+    // check whether the loop is already running
+    if(_displayLink == nil)
+    {
+        // specify update method
+        _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(update:)];
+
+        // add the display link to the main run loop
+        [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+    }
+}
+
+- (void)stop
+{
+    // check whether the loop is already stopped
+    if (_displayLink != nil) {
+        // if the display link is present, it gets invalidated (loop stops)
+        
+        [_displayLink invalidate];
+        _displayLink = nil;
+    }
+}
+
+- (void)update:(CADisplayLink *)sender
+{
+    double time = [sender timestamp];
+    _updateBlock(time);
+}
+
+@end

package/ios/RNSkia-iOS/PlatformContext.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#import <React/RCTBridge.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+#include <DisplayLink.h>
+#include <RNSkPlatformContext.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkStream.h>
+
+#pragma clang diagnostic pop
+
+#include <jsi/jsi.h>
+
+namespace facebook {
+  namespace react {
+    class CallInvoker;
+  }
+}
+
+namespace RNSkia {
+
+using namespace facebook;
+
+static void handleNotification(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo);
+
+class PlatformContext : public RNSkPlatformContext {
+public:
+  PlatformContext(jsi::Runtime *runtime,
+                  std::shared_ptr<react::CallInvoker> callInvoker)
+      : RNSkPlatformContext(runtime, callInvoker, [[UIScreen mainScreen] scale]) {
+        // We need to make sure we invalidate when modules are freed
+        CFNotificationCenterAddObserver(
+              CFNotificationCenterGetLocalCenter(),
+              this,
+              &handleNotification,
+              (__bridge CFStringRef)RCTBridgeWillInvalidateModulesNotification,
+              NULL,
+              CFNotificationSuspensionBehaviorDeliverImmediately
+          );
+      }
+
+  ~PlatformContext() {
+    CFNotificationCenterRemoveEveryObserver(CFNotificationCenterGetLocalCenter(), this);
+  }
+
+  void startDrawLoop() override;
+  void stopDrawLoop() override;
+
+  virtual void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;
+
+  void raiseError(const std::exception &err) override;
+  
+  void willInvalidateModules() {
+    // We need to do some house-cleaning here!
+    invalidate();
+  }
+    
+private:
+  DisplayLink *_displayLink;
+};
+
+static void handleNotification(CFNotificationCenterRef center, void *observer, CFStringRef name,
+                               const void *object, CFDictionaryRef userInfo) {
+  (static_cast<PlatformContext*>(observer))->willInvalidateModules();
+}
+
+} // namespace RNSkia

package/ios/RNSkia-iOS/PlatformContext.mm

@@ -0,0 +1,52 @@
+#include "PlatformContext.h"
+
+#import <React/RCTUtils.h>
+#include <thread>
+#include <utility>
+
+#include <RNSkMeasureTime.h>
+
+namespace RNSkia {
+
+  void PlatformContext::performStreamOperation(const std::string &sourceUri,
+                                              const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) {
+  
+    RNSkMeasureTime("PlatformContext::performStreamOperation");
+    auto loader = [=]() {
+      
+      NSURL* url = [[NSURL alloc] initWithString:[NSString stringWithUTF8String: sourceUri.c_str()]];
+      NSData* data = [NSData dataWithContentsOfURL:url];
+      
+      auto bytes = [data bytes];
+      auto skData = SkData::MakeWithCopy(bytes, [data length]);
+      auto stream = SkMemoryStream::Make(skData);
+      
+      op(std::move(stream));            
+    };
+    
+    // Fire and forget the thread - will be resolved on completion
+    std::thread(loader).detach();
+  }
+
+void PlatformContext::raiseError(const std::exception &err) {
+    RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
+}
+
+void PlatformContext::startDrawLoop() {
+  if(_displayLink == nullptr) {
+    _displayLink = [[DisplayLink alloc] init];
+    [_displayLink start:^(double time) {
+      notifyDrawLoop(false);
+    }];
+  }
+}
+
+void PlatformContext::stopDrawLoop() {
+  if(_displayLink != nullptr) {
+    [_displayLink stop];
+    _displayLink = nullptr;
+  }  
+}
+
+}
+

package/ios/RNSkia-iOS/RNSkDrawViewImpl.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#import "PlatformContext.h"
+#import "RNSKDrawView.h"
+#import <CoreFoundation/CoreFoundation.h>
+#import <UIKit/UIKit.h>
+
+#import <GrMtlBackendContext.h>
+#import <MetalKit/MetalKit.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <SkPicture.h>
+#import <SkRefCnt.h>
+#import <include/gpu/GrDirectContext.h>
+
+#pragma clang diagnostic pop
+
+class RNSkDrawViewImpl : public RNSkia::RNSkDrawView {
+public:
+  RNSkDrawViewImpl(std::shared_ptr<RNSkia::RNSkPlatformContext> context);
+  ~RNSkDrawViewImpl();
+  
+  CALayer* getLayer() { return _layer; }
+  
+  void setSize(int width, int height);
+
+protected:
+  float getScaledWidth() override { return _width * _context->getPixelDensity(); };
+  float getScaledHeight() override { return _height * _context->getPixelDensity(); };
+  
+private:
+  void drawPicture(const sk_sp<SkPicture> picture) override;
+  bool createSkiaSurface();
+
+  int _nativeId;
+  float _width = -1;
+  float _height = -1;
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  CAMetalLayer *_layer;
+#pragma clang diagnostic pop
+
+  static id<MTLCommandQueue> _commandQueue;
+  static id<MTLDevice> _device;
+  static sk_sp<GrDirectContext> _skContext;
+
+  std::shared_ptr<RNSkia::RNSkPlatformContext> _context;
+};

package/ios/RNSkia-iOS/RNSkDrawViewImpl.mm

@@ -0,0 +1,112 @@
+#import <RNSkDrawViewImpl.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <SkColorSpace.h>
+#import <SkSurface.h>
+#import <SkCanvas.h>
+
+#pragma clang diagnostic pop
+
+#import <SkiaDrawView.h>
+#import <RNSkLog.h>
+
+// These static class members are used by all Skia Views
+id<MTLDevice> RNSkDrawViewImpl::_device = MTLCreateSystemDefaultDevice();
+id<MTLCommandQueue> RNSkDrawViewImpl::_commandQueue = id<MTLCommandQueue>(CFRetain((GrMTLHandle)[_device newCommandQueue]));
+
+sk_sp<GrDirectContext> RNSkDrawViewImpl::_skContext = nullptr;
+
+RNSkDrawViewImpl::RNSkDrawViewImpl(std::shared_ptr<RNSkia::RNSkPlatformContext> context):
+  _context(context), RNSkia::RNSkDrawView(context) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  _layer = [CAMetalLayer layer];
+#pragma clang diagnostic pop
+    
+  _layer.framebufferOnly = NO;
+  _layer.device = _device;
+  _layer.opaque = false;
+  _layer.contentsScale = _context->getPixelDensity();
+  _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+}
+
+RNSkDrawViewImpl::~RNSkDrawViewImpl() {
+  if([[NSThread currentThread] isMainThread]) {
+    _layer = NULL;
+  } else {
+    __block auto tempLayer = _layer;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      // By using the tempLayer variable in the block we capture it and it will be
+      // released after the block has finished. This way the CAMetalLayer dealloc will
+      // only be called on the main thread. Problem: this destructor might be called from
+      // releasing the RNSkDrawViewImpl from a thread capture (after dtor has started),
+      // which would cause the CAMetalLayer dealloc to be called on another thread which
+      // causes a crash.
+      // https://github.com/Shopify/react-native-skia/issues/398
+      tempLayer = tempLayer;
+    });
+  }
+}
+
+void RNSkDrawViewImpl::setSize(int width, int height) {
+  _width = width;
+  _height = height;
+  _layer.frame = CGRectMake(0, 0, width, height);
+  _layer.drawableSize = CGSizeMake(width * _context->getPixelDensity(),
+                                   height* _context->getPixelDensity());
+  
+  requestRedraw();
+}
+
+void RNSkDrawViewImpl::drawPicture(const sk_sp<SkPicture> picture) {
+  if(_width == -1 && _height == -1) {
+    return;
+  }
+  
+  if(_skContext == nullptr) {
+    GrContextOptions grContextOptions;
+    _skContext = GrDirectContext::MakeMetal((__bridge void*)_device,
+                                            (__bridge void*)_commandQueue,
+                                            grContextOptions);
+  }
+  
+  // Wrap in auto release pool since we want the system to clean up after rendering
+  // and not wait until later - we've seen some example of memory usage growing very
+  // fast in the simulator without this.
+  @autoreleasepool
+  {
+    id<CAMetalDrawable> currentDrawable = [_layer nextDrawable];
+    if(currentDrawable == nullptr) {
+      return;
+    }
+    
+    GrMtlTextureInfo fbInfo;
+    fbInfo.fTexture.retain((__bridge void*)currentDrawable.texture);
+    
+    GrBackendRenderTarget backendRT(_layer.drawableSize.width,
+                                    _layer.drawableSize.height,
+                                    1,
+                                    fbInfo);
+
+    auto skSurface = SkSurface::MakeFromBackendRenderTarget(_skContext.get(),
+                                                            backendRT,
+                                                            kTopLeft_GrSurfaceOrigin,
+                                                            kBGRA_8888_SkColorType,
+                                                            nullptr,
+                                                            nullptr);
+    
+    if(skSurface == nullptr || skSurface->getCanvas() == nullptr) {
+      RNSkia::RNSkLogger::logToConsole("Skia surface could not be created from parameters.");
+      return;
+    }
+    
+    skSurface->getCanvas()->clear(SK_AlphaTRANSPARENT);
+    skSurface->getCanvas()->drawPicture(picture);
+    
+    id<MTLCommandBuffer> commandBuffer([_commandQueue commandBuffer]);
+    [commandBuffer presentDrawable:currentDrawable];
+    [commandBuffer commit];
+  }
+}