@shopify/react-native-skia 2.2.18 → 2.2.20

package/android/CMakeLists.txt

@@ -126,6 +126,8 @@ add_library(
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/base64.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/SkottieUtils.cpp"
+
+        "${PROJECT_SOURCE_DIR}/../cpp/api/JsiSkDispatcher.cpp"
         ${BACKEND_SOURCES}
 )
 

package/cpp/api/JsiSkCanvas.h

@@ -34,6 +34,7 @@
 #include "include/core/SkRegion.h"
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
 
 #pragma clang diagnostic pop
 
@@ -68,6 +69,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImage) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     std::shared_ptr<SkPaint> paint;
@@ -80,6 +82,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRect) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
@@ -92,6 +95,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     float B = arguments[3].asNumber();
@@ -108,6 +112,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -124,6 +129,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageNine) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto center = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -140,6 +146,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRectCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     float B = arguments[3].asNumber();
@@ -159,6 +166,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRectOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto filter = (SkFilterMode)arguments[3].asNumber();
@@ -695,6 +703,20 @@ public:
   SkCanvas *getCanvas() { return _canvas; }
 
 private:
+  void validateImageForDrawing(jsi::Runtime &runtime,
+                               const sk_sp<SkImage> image) {
+#if !defined(SK_GRAPHITE)
+    auto ctx = getContext()->getDirectContext();
+    if (!ctx) {
+      throw jsi::JSError(runtime, "No GPU context available");
+    }
+    if (image && !image->isValid(ctx->asRecorder())) {
+      throw jsi::JSError(
+          runtime, "image used in drawImage() does not belong to this context");
+    }
+#endif
+  }
+
   SkCanvas *_canvas;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkDispatcher.cpp

@@ -0,0 +1,9 @@
+#include "JsiSkDispatcher.h"
+
+namespace RNSkia {
+
+// Thread-local storage definition
+thread_local std::shared_ptr<Dispatcher::DispatcherData>
+    Dispatcher::_threadDispatcher;
+
+} // namespace RNSkia

package/cpp/api/JsiSkDispatcher.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <unordered_map>
+
+namespace RNSkia {
+
+/**
+ * Thread-local dispatcher for managing deferred operations.
+ * Each thread gets its own dispatcher instance for queueing operations
+ * to be executed on that specific thread.
+ */
+class Dispatcher {
+private:
+  using Operation = std::function<void()>;
+
+  struct DispatcherData {
+    std::queue<Operation> operationQueue;
+    std::mutex queueMutex;
+  };
+
+  // Thread-local storage for dispatcher data
+  static thread_local std::shared_ptr<DispatcherData> _threadDispatcher;
+
+  // Global registry of all dispatchers by thread ID
+  static inline std::mutex _registryMutex;
+  static inline std::unordered_map<std::thread::id,
+                                   std::weak_ptr<DispatcherData>>
+      _dispatcherRegistry;
+
+  std::shared_ptr<DispatcherData> _data;
+  std::thread::id _threadId;
+
+public:
+  Dispatcher() : _threadId(std::this_thread::get_id()) {
+    // Get or create dispatcher data for current thread
+    if (!_threadDispatcher) {
+      _threadDispatcher = std::make_shared<DispatcherData>();
+
+      // Register in global registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry[_threadId] = _threadDispatcher;
+    }
+    _data = _threadDispatcher;
+  }
+
+  /**
+   * Get the dispatcher for the current thread.
+   * Creates one if it doesn't exist.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher() {
+    return std::make_shared<Dispatcher>();
+  }
+
+  /**
+   * Get the dispatcher for a specific thread.
+   * Returns nullptr if that thread doesn't have a dispatcher.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _dispatcherRegistry.find(threadId);
+    if (it != _dispatcherRegistry.end()) {
+      if (auto data = it->second.lock()) {
+        auto dispatcher = std::make_shared<Dispatcher>();
+        dispatcher->_data = data;
+        dispatcher->_threadId = threadId;
+        return dispatcher;
+      }
+    }
+    return nullptr;
+  }
+
+  /**
+   * Queue an operation to be executed on the dispatcher's thread.
+   * The operation will be executed when processQueue() is called on that
+   * thread.
+   */
+  void run(Operation op) {
+    if (!_data)
+      return;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    _data->operationQueue.push(std::move(op));
+  }
+
+  /**
+   * Process all pending operations for the current thread.
+   * Must be called from the thread that owns this dispatcher.
+   * Returns the number of operations processed.
+   */
+  size_t processQueue() {
+    if (!_data)
+      return 0;
+
+    // Only process if we're on the correct thread
+    if (std::this_thread::get_id() != _threadId) {
+      return 0;
+    }
+
+    std::queue<Operation> operations;
+    {
+      std::lock_guard<std::mutex> lock(_data->queueMutex);
+      operations.swap(_data->operationQueue);
+    }
+
+    size_t count = operations.size();
+    while (!operations.empty()) {
+      auto &op = operations.front();
+      op();
+      operations.pop();
+    }
+
+    return count;
+  }
+
+  /**
+   * Get the number of pending operations.
+   */
+  size_t getPendingCount() const {
+    if (!_data)
+      return 0;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    return _data->operationQueue.size();
+  }
+
+  /**
+   * Clean up dispatcher for a thread that's shutting down.
+   */
+  static void cleanup() {
+    if (_threadDispatcher) {
+      // Process any remaining operations
+      auto dispatcher = getDispatcher();
+      dispatcher->processQueue();
+
+      // Remove from registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry.erase(std::this_thread::get_id());
+
+      _threadDispatcher.reset();
+    }
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -4,11 +4,11 @@
 #include <string>
 #include <utility>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkShader.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "third_party/base64.h"
 
 #include "JsiTextureInfo.h"
@@ -63,7 +63,7 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
 
 class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
 private:
-  ThreadSafeDeletion<SkImage> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   // TODO-API: Properties?
@@ -258,6 +258,10 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
+  JSI_HOST_FUNCTION(isTextureBacked) {
+    return jsi::Value(getObject()->isTextureBacked());
+  }
+
   EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
@@ -270,27 +274,41 @@ public:
                        JSI_EXPORT_FUNC(JsiSkImage, readPixels),
                        JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
                        JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
+                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
                        JSI_EXPORT_FUNC(JsiSkImage, dispose))
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
       : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
                                               std::move(image)) {
-    // Drain any pending deletions when creating new images
-    ThreadSafeDeletion<SkImage>::drainDeletionQueue();
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkImage() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto image = getObject();
+    if (image && _dispatcher) {
+      _dispatcher->run([image]() {
+        // Image will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }
 
   size_t getMemoryPressure() const override {
     auto image = getObject();
-    return image ? image->imageInfo().computeMinByteSize() : 0;
+    if (image) {
+      if (image->isTextureBacked()) {
+        return image->textureSize();
+      } else {
+        return image->imageInfo().computeMinByteSize();
+      }
+    }
+    return 0;
   }
 };
 

package/cpp/api/JsiSkPicture.h

@@ -3,6 +3,7 @@
 #include <memory>
 
 #include "JsiSkData.h"
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkRect.h"
@@ -20,10 +21,30 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkPicture : public JsiSkWrappingSkPtrHostObject<SkPicture> {
+private:
+  std::shared_ptr<Dispatcher> _dispatcher;
+
 public:
   JsiSkPicture(std::shared_ptr<RNSkPlatformContext> context,
                const sk_sp<SkPicture> picture)
-      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {}
+      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
+  }
+
+  ~JsiSkPicture() override {
+    // Queue deletion on the creation thread if needed
+    auto picture = getObject();
+    if (picture && _dispatcher) {
+      _dispatcher->run([picture]() {
+        // Picture will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
+    setObject(nullptr);
+  }
 
   JSI_HOST_FUNCTION(makeShader) {
     auto tmx = (SkTileMode)arguments[0].asNumber();

package/cpp/api/JsiSkSurface.h

@@ -5,8 +5,8 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "JsiTextureInfo.h"
 
 #include "JsiSkCanvas.h"
@@ -30,23 +30,28 @@ namespace jsi = facebook::jsi;
 
 class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
 private:
-  ThreadSafeDeletion<SkSurface> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkSurface> surface)
       : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context),
-                                                std::move(surface)),
-        _deletionHandler() {
-    // Drain any pending deletions when creating new surfaces
-    ThreadSafeDeletion<SkSurface>::drainDeletionQueue();
+                                                std::move(surface)) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkSurface() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto surface = getObject();
+    if (surface && _dispatcher) {
+      _dispatcher->run([surface]() {
+        // Surface will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }