@shopify/react-native-skia 1.12.0 → 1.12.2

package/apple/SkiaUIView.mm

@@ -0,0 +1,172 @@
+#import <React/RCTBridge.h>
+
+#import "RNSkiaModule.h"
+#import "SkiaUIView.h"
+
+#include <utility>
+#include <vector>
+
+#import "RNSkManager.h"
+
+@implementation SkiaUIView {
+  std::shared_ptr<RNSkBaseAppleView> _impl;
+  RNSkia::RNSkManager *_manager;
+  std::function<std::shared_ptr<RNSkBaseAppleView>(
+      std::shared_ptr<RNSkia::RNSkPlatformContext>)>
+      _factory;
+  bool _debugMode;
+  bool _opaque;
+  size_t _nativeId;
+}
+
+#pragma mark Initialization and destruction
+
+- (instancetype)initWithManager:(RNSkia::RNSkManager *)manager
+                        factory:
+                            (std::function<std::shared_ptr<RNSkBaseAppleView>(
+                                 std::shared_ptr<RNSkia::RNSkPlatformContext>)>)
+                                factory {
+  self = [super init];
+  if (self) {
+    [self initCommon:manager factory:factory];
+  }
+  // Listen to notifications about module invalidation
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(willInvalidateModules)
+             name:RCTBridgeWillInvalidateModulesNotification
+           object:nil];
+  return self;
+}
+
+- (void)initCommon:(RNSkia::RNSkManager *)manager
+           factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
+                        std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory {
+  _manager = manager;
+  _nativeId = 0;
+  _debugMode = false;
+  _factory = factory;
+}
+
+- (void)willInvalidateModules {
+  _impl = nullptr;
+  _manager = nullptr;
+}
+
+#pragma mark Lifecycle
+
+#if !TARGET_OS_OSX
+- (void)willMoveToSuperview:(UIView *)newSuperView {
+#else
+- (void)viewWillMoveToSuperview:(NSView *)newSuperView {
+#endif // !TARGET_OS_OSX
+  if (newSuperView != nullptr) {
+    // Create implementation view when the parent view is set
+    if (_impl == nullptr && _manager != nullptr) {
+      _impl = _factory(_manager->getPlatformContext());
+      if (_impl == nullptr) {
+        throw std::runtime_error(
+            "Expected Skia view implementation, got nullptr.");
+      }
+      [self.layer addSublayer:_impl->getLayer()];
+      if (_nativeId != 0) {
+        _manager->setSkiaView(_nativeId, _impl->getDrawView());
+      }
+      _impl->getDrawView()->setShowDebugOverlays(_debugMode);
+    }
+  }
+}
+
+- (void)removeFromSuperview {
+  // Cleanup when removed from view hierarchy
+  if (_impl != nullptr) {
+    [_impl->getLayer() removeFromSuperlayer];
+
+    if (_nativeId != 0 && _manager != nullptr) {
+      _manager->setSkiaView(_nativeId, nullptr);
+    }
+
+    _impl = nullptr;
+  }
+
+  [super removeFromSuperview];
+}
+
+- (void)dealloc {
+  [self unregisterView];
+  [[NSNotificationCenter defaultCenter]
+      removeObserver:self
+                name:RCTBridgeWillInvalidateModulesNotification
+              object:nil];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self unregisterView];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+  if (updateMask == RNComponentViewUpdateMaskAll) {
+    // this flag is only set when the view is inserted and we want to set the
+    // manager here since the view could be recycled or the app could be
+    // refreshed and we would have a stale manager then
+    _manager = [SkiaManager latestActiveSkManager].get();
+  }
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (void)unregisterView {
+  if (_manager != nullptr && _nativeId != 0) {
+    _manager->unregisterSkiaView(_nativeId);
+  }
+}
+
+#pragma Render
+
+- (void)drawRect:(CGRect)rect {
+  // We override drawRect to ensure we to direct rendering when the
+  // underlying OS view needs to render:
+  if (_impl != nullptr) {
+    _impl->getDrawView()->redraw();
+  }
+}
+
+#pragma mark Layout
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (_impl != nullptr) {
+    _impl->setSize(self.bounds.size.width, self.bounds.size.height);
+  }
+}
+
+#pragma mark Properties
+
+- (void)setDebugMode:(bool)debugMode {
+  _debugMode = debugMode;
+  if (_impl != nullptr) {
+    _impl->getDrawView()->setShowDebugOverlays(debugMode);
+  }
+}
+
+- (void)setOpaque:(bool)opaque {
+  _opaque = opaque;
+}
+
+- (void)setNativeId:(size_t)nativeId {
+  _nativeId = nativeId;
+
+  if (_impl != nullptr) {
+    _manager->registerSkiaView(nativeId, _impl->getDrawView());
+  }
+}
+
+#pragma mark External API
+
+- (std::shared_ptr<RNSkBaseAppleView>)impl {
+  return _impl;
+}
+
+@end

package/apple/ViewScreenshotService.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import <CoreFoundation/CoreFoundation.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <Appkit/Appkit.h>
+#endif // !TARGET_OS_OSX
+
+#import <React/RCTUIManager.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkImage.h"
+
+#pragma clang diagnostic pop
+
+@interface ViewScreenshotService : NSObject {
+}
+
+- (instancetype)initWithUiManager:(RCTUIManager *)uiManager;
+- (sk_sp<SkImage>)screenshotOfViewWithTag:(NSNumber *)viewTag;
+
+@end

package/apple/ViewScreenshotService.mm

@@ -0,0 +1,89 @@
+#import "ViewScreenshotService.h"
+#import <QuartzCore/QuartzCore.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkData.h"
+
+#pragma clang diagnostic pop
+
+@implementation ViewScreenshotService {
+  RCTUIManager *_uiManager;
+}
+
+- (instancetype)initWithUiManager:(RCTUIManager *)uiManager {
+  if (self = [super init]) {
+    _uiManager = uiManager;
+  }
+  return self;
+}
+
+- (sk_sp<SkImage>)screenshotOfViewWithTag:(NSNumber *)viewTag {
+#if !TARGET_OS_OSX
+  // Find view corresponding to the tag
+  auto view = [_uiManager viewForReactTag:viewTag];
+  if (view == NULL) {
+    RCTFatal(RCTErrorWithMessage(@"Could not find view with tag"));
+    return nullptr;
+  }
+
+  // Get size
+  CGSize size = view.frame.size;
+
+  // Setup context
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.opaque = NO;
+  format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
+
+  UIGraphicsImageRenderer *renderer =
+      [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];
+
+  // Render to context - this is now the only part of this function that shows
+  // up in the profiler!
+  UIImage *image = [renderer
+      imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull context) {
+        [view drawViewHierarchyInRect:(CGRect){CGPointZero, size}
+                   afterScreenUpdates:YES];
+      }];
+
+  // Convert from UIImage -> CGImage -> SkImage
+  CGImageRef cgImage = image.CGImage;
+
+  // Get some info about the image
+  auto width = CGImageGetWidth(cgImage);
+  auto height = CGImageGetHeight(cgImage);
+  auto bytesPerRow = CGImageGetBytesPerRow(cgImage);
+
+  // Convert from UIImage -> SkImage, start by getting the pixels directly from
+  // the CGImage:
+  auto dataRef = CGDataProviderCopyData(CGImageGetDataProvider(cgImage));
+  auto length = CFDataGetLength(dataRef);
+  void *data = CFDataGetMutableBytePtr((CFMutableDataRef)dataRef);
+
+  // Now we'll capture the data in an SkData object and control releasing it:
+  auto skData = SkData::MakeWithProc(
+      data, length,
+      [](const void *ptr, void *context) {
+        CFDataRef dataRef = (CFDataRef)context;
+        CFRelease(dataRef);
+      },
+      (void *)dataRef);
+
+  // Make SkImageInfo
+  // We're using kBGRA_8888_SkColorType since this is what we get when the
+  // UIGraphicsImageRenderer uses the standard format (the extended is using
+  // 64bits so it is not suitable for us).
+  SkImageInfo info =
+      SkImageInfo::Make(static_cast<int>(width), static_cast<int>(height),
+                        kBGRA_8888_SkColorType, kPremul_SkAlphaType);
+
+  // ... and then create the SkImage itself!
+  return SkImages::RasterFromData(info, skData, bytesPerRow);
+#else
+  return nullptr;
+#endif // !TARGET_OS_OSX
+}
+
+@end

package/cpp/api/JsiSkContourMeasure.h

@@ -34,7 +34,7 @@ public:
     SkPoint tangent;
     auto result = getObject()->getPosTan(dist, &position, &tangent);
     if (!result) {
-      throw jsi::JSError(runtime, "getSegment() failed");
+      throw jsi::JSError(runtime, "getPosTan() failed");
     }
     auto posTan = jsi::Array(runtime, 2);
     auto pos = jsi::Object::createFromHostObject(

package/cpp/api/JsiSkHostObjects.h

@@ -54,20 +54,21 @@ public:
 
   /**
    * Returns the underlying object exposed by this host object. This object
-   * should be wrapped in a shared pointer of some kind
+   * should be wrapped in a shared pointer of some kind.
+   * Throws if the object has been disposed.
    * @return Underlying object
    */
-  T getObject() { return _object; }
-  const T getObject() const { return _object; }
+  T getObject() { return validateObject(); }
+  const T getObject() const { return validateObject(); }
 
   /**
-   Updates the inner object with a new version of the object.
+   * Updates the inner object with a new version of the object.
    */
   void setObject(T object) { _object = object; }
 
   /**
-   Dispose function that can be exposed to JS by using the JSI_API_TYPENAME
-   macro
+   * Dispose function that can be exposed to JS by using the JSI_API_TYPENAME
+   * macro.
    */
   JSI_HOST_FUNCTION(dispose) {
     safeDispose();
@@ -76,12 +77,22 @@ public:
 
 protected:
   /**
-   Override to implement disposale of allocated resources like smart pointers
-   etc. This method will only be called once for each instance of this class.
+   * Override to implement disposal of allocated resources like smart pointers.
+   * This method will only be called once for each instance of this class.
    */
   virtual void releaseResources() = 0;
 
 private:
+  /**
+   * Validates that _object was not disposed and returns it.
+   */
+  T validateObject() const {
+    if (_isDisposed) {
+      throw std::runtime_error("Attempted to access a disposed object.");
+    }
+    return _object;
+  }
+
   void safeDispose() {
     if (!_isDisposed) {
       _isDisposed = true;
@@ -90,12 +101,12 @@ private:
   }
 
   /**
-   * Wrapped object
+   * Wrapped object.
    */
   T _object;
 
   /**
-   Resource disposed flag
+   * Resource disposed flag.
    */
   std::atomic<bool> _isDisposed = {false};
 };

package/cpp/api/JsiSkParagraph.h

@@ -24,19 +24,19 @@
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
-
 namespace para = skia::textlayout;
 
 /**
- Implementation of the Paragraph object in JSI
+ * Implementation of the Paragraph object in JSI
  */
-class JsiSkParagraph : public JsiSkHostObject {
+class JsiSkParagraph
+    : public JsiSkWrappingSharedPtrHostObject<para::Paragraph> {
 public:
   EXPORT_JSI_API_TYPENAME(JsiSkParagraph, Paragraph)
 
   JSI_HOST_FUNCTION(layout) {
     auto width = getArgumentAsNumber(runtime, arguments, count, 0);
-    _paragraph->layout(width);
+    getObject()->layout(width);
     return jsi::Value::undefined();
   }
 
@@ -45,34 +45,34 @@ public:
         getArgumentAsHostObject<JsiSkCanvas>(runtime, arguments, count, 0);
     auto x = getArgumentAsNumber(runtime, arguments, count, 1);
     auto y = getArgumentAsNumber(runtime, arguments, count, 2);
-    _paragraph->paint(jsiCanvas->getCanvas(), x, y);
+    getObject()->paint(jsiCanvas->getCanvas(), x, y);
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(getHeight) {
-    return static_cast<double>(_paragraph->getHeight());
+    return static_cast<double>(getObject()->getHeight());
   }
 
   JSI_HOST_FUNCTION(getMaxWidth) {
-    return static_cast<double>(_paragraph->getMaxWidth());
+    return static_cast<double>(getObject()->getMaxWidth());
   }
 
   JSI_HOST_FUNCTION(getMaxIntrinsicWidth) {
-    return static_cast<double>(_paragraph->getMaxIntrinsicWidth());
+    return static_cast<double>(getObject()->getMaxIntrinsicWidth());
   }
 
   JSI_HOST_FUNCTION(getMinIntrinsicWidth) {
-    return static_cast<double>(_paragraph->getMinIntrinsicWidth());
+    return static_cast<double>(getObject()->getMinIntrinsicWidth());
   }
 
   JSI_HOST_FUNCTION(getLongestLine) {
-    return static_cast<double>(_paragraph->getLongestLine());
+    return static_cast<double>(getObject()->getLongestLine());
   }
 
   JSI_HOST_FUNCTION(getGlyphPositionAtCoordinate) {
     auto dx = getArgumentAsNumber(runtime, arguments, count, 0);
     auto dy = getArgumentAsNumber(runtime, arguments, count, 1);
-    auto result = _paragraph->getGlyphPositionAtCoordinate(dx, dy);
+    auto result = getObject()->getGlyphPositionAtCoordinate(dx, dy);
     return result.position;
   }
 
@@ -80,8 +80,8 @@ public:
     auto start = getArgumentAsNumber(runtime, arguments, count, 0);
     auto end = getArgumentAsNumber(runtime, arguments, count, 1);
     auto result =
-        _paragraph->getRectsForRange(start, end, para::RectHeightStyle::kTight,
-                                     para::RectWidthStyle::kTight);
+        getObject()->getRectsForRange(start, end, para::RectHeightStyle::kTight,
+                                      para::RectWidthStyle::kTight);
     auto returnValue = jsi::Array(runtime, result.size());
     for (size_t i = 0; i < result.size(); ++i) {
       returnValue.setValueAtIndex(
@@ -93,7 +93,7 @@ public:
 
   JSI_HOST_FUNCTION(getLineMetrics) {
     std::vector<para::LineMetrics> metrics;
-    _paragraph->getLineMetrics(metrics);
+    getObject()->getLineMetrics(metrics);
     auto returnValue = jsi::Array(runtime, metrics.size());
     auto height = 0;
     for (size_t i = 0; i < metrics.size(); ++i) {
@@ -110,7 +110,7 @@ public:
 
   JSI_HOST_FUNCTION(getRectsForPlaceholders) {
     std::vector<para::TextBox> placeholderInfos =
-        _paragraph->getRectsForPlaceholders();
+        getObject()->getRectsForPlaceholders();
     auto returnValue = jsi::Array(runtime, placeholderInfos.size());
     for (size_t i = 0; i < placeholderInfos.size(); ++i) {
       auto obj = jsi::Object(runtime);
@@ -124,12 +124,6 @@ public:
     return returnValue;
   }
 
-  JSI_HOST_FUNCTION(dispose) {
-    _paragraph = nullptr;
-
-    return jsi::Value::undefined();
-  }
-
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkParagraph, layout),
                        JSI_EXPORT_FUNC(JsiSkParagraph, paint),
                        JSI_EXPORT_FUNC(JsiSkParagraph, getMaxWidth),
@@ -146,12 +140,8 @@ public:
 
   explicit JsiSkParagraph(std::shared_ptr<RNSkPlatformContext> context,
                           para::ParagraphBuilder *paragraphBuilder)
-      : JsiSkHostObject(std::move(context)) {
-    _paragraph = paragraphBuilder->Build();
-  }
-
-public:
-  std::unique_ptr<para::Paragraph> _paragraph;
+      : JsiSkWrappingSharedPtrHostObject<para::Paragraph>(
+            std::move(context), std::move(paragraphBuilder->Build())) {}
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPathEffect.h

@@ -26,7 +26,7 @@ public:
                                                    std::move(pathEffect)) {}
 
   EXPORT_JSI_API_TYPENAME(JsiSkPathEffect, PathEffect)
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkColorFilter, dispose))
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPathEffect, dispose))
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkPictureFactory.h

@@ -45,7 +45,7 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkPictureFactory, MakePicture))
 
   explicit JsiSkPictureFactory(std::shared_ptr<RNSkPlatformContext> context)
-      : JsiSkHostObject(context) {}
+      : JsiSkHostObject(std::move(context)) {}
 };
 
 } // namespace RNSkia

package/cpp/api/recorder/Drawings.h

@@ -874,9 +874,10 @@ public:
   }
 
   void draw(DrawingCtx *ctx) {
-    if (props.paragraph && props.paragraph->_paragraph) {
-      props.paragraph->_paragraph->layout(props.width);
-      props.paragraph->_paragraph->paint(ctx->canvas, props.x, props.y);
+    if (props.paragraph) {
+      auto paragraph = props.paragraph->getObject();
+      paragraph->layout(props.width);
+      paragraph->paint(ctx->canvas, props.x, props.y);
     }
   }
 };

package/cpp/skia/include/codec/SkCodec.h

@@ -412,6 +412,9 @@ public:
      *  If a scanline decode is in progress, scanline mode will end, requiring the client to call
      *  startScanlineDecode() in order to return to decoding scanlines.
      *
+     *  For certain codecs, reading into a smaller bitmap than the original dimensions may not
+     *  produce correct results (e.g. animated webp).
+     *
      *  @return Result kSuccess, or another value explaining the type of failure.
      */
     Result getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, const Options*);
@@ -812,6 +815,7 @@ protected:
     }
 
     virtual bool onGetGainmapCodec(SkGainmapInfo*, std::unique_ptr<SkCodec>*) { return false; }
+    virtual bool onGetGainmapInfo(SkGainmapInfo*) { return false; }
 
     // TODO(issues.skia.org/363544350): This API only works for JPEG images. Remove this API once
     // it is no longer used.
@@ -1053,8 +1057,9 @@ private:
     friend class PNGCodecGM;    // for fillIncompleteImage
     friend class SkSampledCodec;
     friend class SkIcoCodec;
-    friend class SkAndroidCodec; // for fEncodedInfo
-    friend class SkPDFBitmap; // for fEncodedInfo
+    friend class SkPngCodec;     // for onGetGainmapCodec
+    friend class SkAndroidCodec;  // for handleFrameIndex
+    friend class SkCodecPriv;     // for fEncodedInfo
 };
 
 namespace SkCodecs {

package/cpp/skia/include/config/SkUserConfig.h

@@ -74,6 +74,12 @@
 */
 //#define SK_R32_SHIFT    16
 
+/*  This controls how much space should be pre-allocated in an SkCanvas object
+    to store the SkMatrix and clip via calls to SkCanvas::save() (and balanced with
+    SkCanvas::restore()).
+*/
+//#define SK_CANVAS_SAVE_RESTORE_PREALLOC_COUNT 32
+
 /* Determines whether to build code that supports the Ganesh GPU backend. Some classes
    that are not GPU-specific, such as SkShader subclasses, have optional code
    that is used allows them to interact with this GPU backend. If you'd like to
@@ -95,6 +101,11 @@
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
 //#define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 
+/*
+ * Skia can provide extensive logging of Graphite Pipeline lifetimes.
+ */
+//#define SK_PIPELINE_LIFETIME_LOGGING
+
 // To use smaller but slower mipmap builder
 //#define SK_USE_DRAWING_MIPMAP_DOWNSAMPLER
 

package/cpp/skia/include/core/SkCanvas.h

@@ -34,6 +34,7 @@
 #include "include/private/base/SkDeque.h"
 #include "include/private/base/SkTArray.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -2502,15 +2503,18 @@ private:
         void reset(SkDevice* device);
     };
 
-    // the first N recs that can fit here mean we won't call malloc
-    static constexpr int kMCRecSize      = 96; // most recent measurement
-    static constexpr int kMCRecCount     = 32; // common depth for save/restores
+#if defined(SK_CANVAS_SAVE_RESTORE_PREALLOC_COUNT)
+    static constexpr int kMCRecCount = SK_CANVAS_SAVE_RESTORE_PREALLOC_COUNT;
+#else
+    static constexpr int kMCRecCount = 32; // common depth for save/restores
+#endif
 
-    intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
+    // This stack allocation of memory will be used to house the first kMCRecCount
+    // layers without need to call malloc.
+    alignas(MCRec) std::byte fMCRecStorage[sizeof(MCRec) * kMCRecCount];
 
-    SkDeque     fMCStack;
-    // points to top of stack
-    MCRec*      fMCRec;
+    SkDeque     fMCStack; // uses the stack memory
+    MCRec*      fMCRec;   // points to top of stack for convenience
 
     // Installed via init()
     sk_sp<SkDevice> fRootDevice;

package/cpp/skia/include/core/SkColor.h

@@ -12,6 +12,7 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkTPin.h"
 
 #include <array>
 #include <cstdint>
@@ -415,6 +416,15 @@ struct SkRGBA4f {
     SkRGBA4f makeOpaque() const {
         return { fR, fG, fB, 1.0f };
     }
+
+    /**
+     Returns a copy of the SkRGBA4f but with the alpha component pinned to [0, 1].
+
+     @return          color with pinned alpha
+    */
+    SkRGBA4f pinAlpha() const {
+        return { fR, fG, fB, SkTPin(fA, 0.f, 1.f) };
+    }
 };
 
 /** \struct SkColor4f