@shopify/react-native-skia 1.5.3 → 1.5.4

package/android/CMakeLists.txt

@@ -3,8 +3,8 @@ cmake_minimum_required(VERSION 3.4.1)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_GL -DSK_GANESH -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
-
+set(SK_GRAPHITE OFF)
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
 set (PACKAGE_NAME "rnskia")
 set (SKIA_LIB "skia")
 set (SKIA_SVG_LIB "svg")
@@ -13,6 +13,7 @@ set (SKIA_SKPARAGRAPH_LIB "skparagraph")
 set (SKIA_SKUNICODE_CORE_LIB "skunicode_core")
 set (SKIA_SKUNICODE_ICU_LIB "skunicode_icu")
 
+
 # Clear some variables
 unset(LIBRN_DIR CACHE)
 unset(libfbjni_link_DIRS CACHE)
@@ -30,6 +31,34 @@ message("-- LIBRN   : " ${LIBRN_DIR})
 
 link_directories(../libs/android/${ANDROID_ABI}/)
 
+# Import prebuilt SKIA libraries
+set (SKIA_LIBS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../libs/android/${ANDROID_ABI}")
+
+if(SK_GRAPHITE)
+    add_definitions(-DSK_GRAPHITE)
+    set(DAWN_NATIVE_LIB "libdawn_native_static")
+    set(DAWN_PLATFORM_LIB "libdawn_platform_static")
+    set(DAWN_PROC_LIB "libdawn_proc_static")
+    set(BACKEND_SOURCES
+    #TODO: is this source needed to be added?
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/DawnWindowContext.cpp"
+    )
+    add_library(libdawn_native_static STATIC IMPORTED)
+    set_property(TARGET libdawn_native_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_native_static.a")
+
+    add_library(libdawn_platform_static STATIC IMPORTED)
+    set_property(TARGET libdawn_platform_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_platform_static.a")
+
+    add_library(libdawn_proc_static STATIC IMPORTED)
+    set_property(TARGET libdawn_proc_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_proc_static.a")
+else()
+    add_definitions(-DSK_GL -DSK_GANESH)
+    set(BACKEND_SOURCES
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/GrAHardwareBufferUtils.cpp"
+    )
+endif()
+
 if(${REACT_NATIVE_VERSION} LESS 66)
         file(
                 TO_CMAKE_PATH
@@ -46,8 +75,6 @@ add_library(
 
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/GrAHardwareBufferUtils.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"
 
@@ -66,9 +93,10 @@ add_library(
 
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/base64.cpp"
-
+        ${BACKEND_SOURCES}
 )
 
+
 target_include_directories(
         ${PACKAGE_NAME}
         PRIVATE
@@ -88,6 +116,7 @@ target_include_directories(
         # so "include/core/SkRef.h" instead of "SkRef.h", as otherwise
         # the prefab cannot be shipped.
         ../cpp/skia
+        ../cpp/dawn/include
 
         ../cpp/api
         ../cpp/jsi
@@ -102,9 +131,6 @@ target_include_directories(
         ${libfbjni_include_DIRS}
 )
 
-# Import prebuilt SKIA libraries
-set (SKIA_LIBS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../libs/android/${ANDROID_ABI}")
-
 add_library(skia STATIC IMPORTED)
 set_property(TARGET skia PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskia.a")
 
@@ -240,8 +266,7 @@ add_definitions(-DREACT_NATIVE_VERSION=${REACT_NATIVE_VERSION})
 
 # Link
 if(${REACT_NATIVE_VERSION} GREATER_EQUAL 76)
-    target_link_libraries(
-        ${PACKAGE_NAME}
+    set(COMMON_LIBS
         ${LOG_LIB}
         ${REACT_LIB}
         ${FBJNI_LIBRARY}
@@ -258,8 +283,7 @@ if(${REACT_NATIVE_VERSION} GREATER_EQUAL 76)
         -landroid
     )
 else()
-    target_link_libraries(
-        ${PACKAGE_NAME}
+    set(COMMON_LIBS
         ${LOG_LIB}
         ${FBJNI_LIBRARY}
         ${REACT_LIB}
@@ -278,4 +302,19 @@ else()
         -lEGL
         -landroid
     )
-endif()
+endif()
+
+if(SK_GRAPHITE)
+    target_link_libraries(${PACKAGE_NAME}
+        ${COMMON_LIBS}
+        ${DAWN_NATIVE_LIB}
+        ${DAWN_PLATFORM_LIB}
+        ${DAWN_PROC_LIB}
+    )
+else()
+    target_link_libraries(${PACKAGE_NAME}
+        ${COMMON_LIBS}
+        -lGLESv2
+        -lEGL
+    )
+endif()

package/android/build.gradle

@@ -330,6 +330,9 @@ if (ENABLE_PREFAB) {
             } else if (path.contains("skia/include") || path.contains("skia/modules") || path.contains("skia/src")) {
                 // Skip flattening Skia dir
                 path = path.substring("skia/".length())
+            } else if (path.startsWith("dawn/include/")) {
+                // Flatten dawn/include/dawn and dawn/include/webgpu
+                path = path.substring("dawn/include/".length())
             } else {
                 // flatten anything else
                 path = path.substring(path.lastIndexOf("/") + 1)

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -9,9 +9,14 @@
 #include <memory>
 #include <string>
 
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#else
+#include "OpenGLContext.h"
+#endif
+
 #include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
-#include "OpenGLContext.h"
 #include "RNSkAndroidVideo.h"
 #include "RNSkPlatformContext.h"
 
@@ -51,17 +56,29 @@ public:
   }
 
   sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override {
+#if defined(SK_GRAPHITE)
+    return DawnContext::getInstance().MakeOffscreen(width, height);
+#else
     return OpenGLContext::getInstance().MakeOffscreen(width, height);
+#endif
   }
 
   std::shared_ptr<WindowContext>
   makeContextFromNativeSurface(void *surface, int width, int height) override {
+#if defined(SK_GRAPHITE)
+    return DawnContext::getInstance().MakeWindow(surface, width, height);
+#else
     return OpenGLContext::getInstance().MakeWindow(
         reinterpret_cast<ANativeWindow *>(surface), width, height);
+#endif
   }
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
+#if defined(SK_GRAPHITE)
+    return DawnContext::getInstance().MakeImageFromBuffer(buffer);
+#else
     return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
+#endif
   }
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {

package/android/cpp/rnskia-android/RNSkAndroidVideo.cpp

@@ -5,6 +5,14 @@
 #include <android/hardware_buffer_jni.h>
 #endif
 
+#include "RNSkLog.h"
+
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#else
+#include "OpenGLContext.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -13,7 +21,6 @@
 
 #pragma clang diagnostic pop
 
-#include "OpenGLContext.h"
 #include "RNSkAndroidVideo.h"
 
 namespace RNSkia {
@@ -52,7 +59,11 @@ sk_sp<SkImage> RNSkAndroidVideo::nextImage(double *timeStamp) {
   // Convert jobject to AHardwareBuffer
   AHardwareBuffer *buffer =
       AHardwareBuffer_fromHardwareBuffer(env, jHardwareBuffer);
+#if defined(SK_GRAPHITE)
+  return DawnContext::getInstance().MakeImageFromBuffer(buffer);
+#else
   return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
+#endif
 #else
   return nullptr;
 #endif

package/android/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp

@@ -1,8 +1,17 @@
 #include "RNSkOpenGLCanvasProvider.h"
 
+#include <android/native_window_jni.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
 #include <memory>
 
+#include "RNSkLog.h"
+
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#else
 #include "OpenGLContext.h"
+#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -89,8 +98,12 @@ void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject jSurfaceTexture,
   env->DeleteLocalRef(jSurface);
   env->DeleteLocalRef(surfaceClass);
   env->DeleteLocalRef(surfaceTextureClass);
+#if defined(SK_GRAPHITE)
+  _surfaceHolder = DawnContext::getInstance().MakeWindow(window, width, height);
+#else
   _surfaceHolder =
       OpenGLContext::getInstance().MakeWindow(window, width, height);
+#endif
 
   // Post redraw request to ensure we paint in the next draw cycle.
   _requestRedraw();

package/android/src/main/java/com/shopify/reactnative/skia/SkiaBaseView.java

@@ -3,7 +3,6 @@ package com.shopify.reactnative.skia;
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
-import android.view.MotionEvent;
 import android.view.TextureView;
 
 import com.facebook.react.views.view.ReactViewGroup;

package/cpp/api/JsiSkImage.h

@@ -12,6 +12,11 @@
 
 #include "RNSkTypedArray.h"
 
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#include "include/gpu/graphite/Context.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -83,9 +88,13 @@ public:
                        ? arguments[1].asNumber()
                        : 100.0;
     auto image = getObject();
+#if defined(SK_GRAPHITE)
+    image = DawnContext::getInstance().MakeRasterImage(image);
+#else
     if (image->isTextureBacked()) {
       image = image->makeNonTextureImage();
     }
+#endif
     sk_sp<SkData> data;
 
     if (format == SkEncodedImageFormat::kJPEG) {
@@ -181,9 +190,13 @@ public:
   }
 
   JSI_HOST_FUNCTION(makeNonTextureImage) {
-    auto image = getObject()->makeNonTextureImage();
+#if defined(SK_GRAPHITE)
+    auto rasterImage = DawnContext::getInstance().MakeRasterImage(getObject());
+#else
+    auto rasterImage = getObject()->makeNonTextureImage();
+#endif
     return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+        runtime, std::make_shared<JsiSkImage>(getContext(), rasterImage));
   }
 
   EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)

package/cpp/api/JsiSkSurface.h

@@ -10,6 +10,10 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkImage.h"
 
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -44,21 +48,32 @@ public:
   }
 
   JSI_HOST_FUNCTION(flush) {
-    if (auto dContext = GrAsDirectContext(getObject()->recordingContext())) {
+    auto surface = getObject();
+#if defined(SK_GRAPHITE)
+    auto recording = surface->recorder()->snap();
+    DawnContext::getInstance().submitRecording(recording.get());
+#else
+    if (auto dContext = GrAsDirectContext(surface->recordingContext())) {
       dContext->flushAndSubmit();
     }
+#endif
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(makeImageSnapshot) {
+    auto surface = getObject();
     sk_sp<SkImage> image;
     if (count == 1) {
       auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-      image = getObject()->makeImageSnapshot(SkIRect::MakeXYWH(
+      image = surface->makeImageSnapshot(SkIRect::MakeXYWH(
           rect->x(), rect->y(), rect->width(), rect->height()));
     } else {
-      image = getObject()->makeImageSnapshot();
+      image = surface->makeImageSnapshot();
     }
+#if defined(SK_GRAPHITE)
+    auto recording = surface->recorder()->snap();
+    DawnContext::getInstance().submitRecording(recording.get());
+#endif
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }

package/cpp/rnskia/DawnContext.h

@@ -0,0 +1,241 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+
+#include "DawnUtils.h"
+#include "DawnWindowContext.h"
+#include "ImageProvider.h"
+
+#include "include/core/SkData.h"
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/Context.h"
+#include "include/gpu/graphite/ContextOptions.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/Surface.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+#include "include/gpu/graphite/dawn/DawnUtils.h"
+
+#include "src/gpu/graphite/ContextOptionsPriv.h"
+
+#ifdef __APPLE__
+#include <CoreVideo/CVPixelBuffer.h>
+#else
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
+#endif
+
+namespace RNSkia {
+
+struct AsyncContext {
+  bool fCalled = false;
+  std::unique_ptr<const SkSurface::AsyncReadResult> fResult;
+};
+
+struct SharedTextureContext {
+  wgpu::SharedTextureMemory sharedTextureMemory;
+  wgpu::Texture texture;
+};
+
+static void
+async_callback(void *c,
+               std::unique_ptr<const SkImage::AsyncReadResult> result) {
+  auto context = static_cast<AsyncContext *>(c);
+  context->fResult = std::move(result);
+  context->fCalled = true;
+}
+
+class DawnContext {
+public:
+  // TODO: remove
+  friend class RNSkiOSPlatformContext;
+
+  DawnContext(const DawnContext &) = delete;
+  DawnContext &operator=(const DawnContext &) = delete;
+
+  static DawnContext &getInstance() {
+    static DawnContext instance;
+    return instance;
+  }
+
+  sk_sp<SkImage> MakeRasterImage(sk_sp<SkImage> image) {
+    if (!image->isTextureBacked()) {
+      return image;
+    }
+    std::lock_guard<std::mutex> lock(_mutex);
+    AsyncContext asyncContext;
+    fGraphiteContext->asyncRescaleAndReadPixels(
+        image.get(), image->imageInfo(), image->imageInfo().bounds(),
+        SkImage::RescaleGamma::kSrc, SkImage::RescaleMode::kNearest,
+        async_callback, &asyncContext);
+    fGraphiteContext->submit();
+    while (!asyncContext.fCalled) {
+      tick();
+      fGraphiteContext->checkAsyncWorkCompletion();
+    }
+    auto bytesPerRow = asyncContext.fResult->rowBytes(0);
+    auto bufferSize = bytesPerRow * image->imageInfo().height();
+    auto data = SkData::MakeWithProc(
+        asyncContext.fResult->data(0), bufferSize,
+        [](const void *ptr, void *context) {
+          auto *result =
+              reinterpret_cast<const SkSurface::AsyncReadResult *>(context);
+          delete result;
+        },
+        reinterpret_cast<void *>(const_cast<SkSurface::AsyncReadResult *>(
+            asyncContext.fResult.release())));
+    auto rasterImage =
+        SkImages::RasterFromData(image->imageInfo(), data, bytesPerRow);
+    return rasterImage;
+  }
+
+  void submitRecording(
+      skgpu::graphite::Recording *recording,
+      skgpu::graphite::SyncToCpu syncToCpu = skgpu::graphite::SyncToCpu::kNo) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    skgpu::graphite::InsertRecordingInfo info;
+    info.fRecording = recording;
+    fGraphiteContext->insertRecording(info);
+    fGraphiteContext->submit(syncToCpu);
+  }
+
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+#ifdef __APPLE__
+    wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc;
+    auto ioSurface = CVPixelBufferGetIOSurface((CVPixelBufferRef)buffer);
+    platformDesc.ioSurface = ioSurface;
+    int width = static_cast<int>(IOSurfaceGetWidth(ioSurface));
+    int height = static_cast<int>(IOSurfaceGetHeight(ioSurface));
+#else
+    wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc;
+    auto ahb = (AHardwareBuffer *)buffer;
+    platformDesc.handle = ahb;
+    platformDesc.useExternalFormat = true;
+    AHardwareBuffer_Desc adesc;
+    AHardwareBuffer_describe(ahb, &adesc);
+    int width = adesc.width;
+    int height = adesc.height;
+#endif
+
+    wgpu::SharedTextureMemoryDescriptor desc = {};
+    desc.nextInChain = &platformDesc;
+    wgpu::SharedTextureMemory memory =
+        backendContext.fDevice.ImportSharedTextureMemory(&desc);
+
+    wgpu::TextureDescriptor textureDesc;
+    textureDesc.format = DawnUtils::PreferredTextureFormat;
+    textureDesc.dimension = wgpu::TextureDimension::e2D;
+    textureDesc.usage =
+        wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopySrc;
+    textureDesc.size = {static_cast<uint32_t>(width),
+                        static_cast<uint32_t>(height), 1};
+
+    wgpu::Texture texture = memory.CreateTexture(&textureDesc);
+
+    wgpu::SharedTextureMemoryBeginAccessDescriptor beginAccessDesc;
+    beginAccessDesc.initialized = true;
+    beginAccessDesc.fenceCount = 0;
+    bool success = memory.BeginAccess(texture, &beginAccessDesc);
+
+    if (success) {
+      skgpu::graphite::BackendTexture betFromView =
+          skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
+      auto result = SkImages::WrapTexture(
+          getRecorder(), betFromView, DawnUtils::PreferedColorType,
+          kPremul_SkAlphaType, nullptr,
+          [](void *context) {
+            auto ctx = static_cast<SharedTextureContext *>(context);
+            wgpu::SharedTextureMemoryEndAccessState endState = {};
+            ctx->sharedTextureMemory.EndAccess(ctx->texture, &endState);
+            delete ctx;
+          },
+          new SharedTextureContext{memory, texture});
+      return result;
+    }
+    if (!success) {
+      return nullptr;
+    }
+    return nullptr;
+  }
+
+  // Create offscreen surface
+  sk_sp<SkSurface> MakeOffscreen(int width, int height) {
+    SkImageInfo info = SkImageInfo::Make(
+        width, height, DawnUtils::PreferedColorType, kPremul_SkAlphaType);
+    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(getRecorder(), info);
+
+    if (!surface) {
+      throw std::runtime_error("Failed to create offscreen Skia surface.");
+    }
+
+    return surface;
+  }
+
+  // Create onscreen surface with window
+  std::unique_ptr<WindowContext> MakeWindow(void *window, int width,
+                                            int height) {
+    // 1. Create Surface
+    wgpu::SurfaceDescriptor surfaceDescriptor;
+#ifdef __APPLE__
+    wgpu::SurfaceDescriptorFromMetalLayer metalSurfaceDesc;
+    metalSurfaceDesc.layer = window;
+    surfaceDescriptor.nextInChain = &metalSurfaceDesc;
+#else
+    wgpu::SurfaceDescriptorFromAndroidNativeWindow androidSurfaceDesc;
+    androidSurfaceDesc.window = window;
+    surfaceDescriptor.nextInChain = &androidSurfaceDesc;
+#endif
+    auto surface =
+        wgpu::Instance(instance->Get()).CreateSurface(&surfaceDescriptor);
+    return std::make_unique<DawnWindowContext>(
+        getRecorder(), backendContext.fDevice, surface, width, height);
+  }
+
+private:
+  std::unique_ptr<dawn::native::Instance> instance;
+  std::unique_ptr<skgpu::graphite::Context> fGraphiteContext;
+  skgpu::graphite::DawnBackendContext backendContext;
+  std::mutex _mutex;
+
+  DawnContext() {
+    DawnProcTable backendProcs = dawn::native::GetProcs();
+    dawnProcSetProcs(&backendProcs);
+    WGPUInstanceDescriptor desc{};
+    desc.features.timedWaitAnyEnable = true;
+    instance = std::make_unique<dawn::native::Instance>(&desc);
+
+    backendContext = DawnUtils::createDawnBackendContext(instance.get());
+
+    skgpu::graphite::ContextOptions ctxOptions;
+    skgpu::graphite::ContextOptionsPriv contextOptionsPriv;
+    ctxOptions.fOptionsPriv = &contextOptionsPriv;
+    ctxOptions.fOptionsPriv->fStoreContextRefInRecorder = true;
+    fGraphiteContext =
+        skgpu::graphite::ContextFactory::MakeDawn(backendContext, ctxOptions);
+
+    if (!fGraphiteContext) {
+      throw std::runtime_error("Failed to create graphite context");
+    }
+  }
+
+  void tick() { backendContext.fTick(backendContext.fInstance); }
+
+  skgpu::graphite::Recorder *getRecorder() {
+    static thread_local skgpu::graphite::RecorderOptions recorderOptions;
+    if (!recorderOptions.fImageProvider) {
+      auto imageProvider = ImageProvider::Make();
+      recorderOptions.fImageProvider = imageProvider;
+    }
+    static thread_local auto recorder =
+        fGraphiteContext->makeRecorder(recorderOptions);
+    if (!recorder) {
+      throw std::runtime_error("Failed to create graphite context");
+    }
+    return recorder.get();
+  }
+};
+
+} // namespace RNSkia