@shopify/react-native-skia 1.5.1 → 1.5.3

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "SkiaOpenGLSurfaceFactory.h"
+#include "WindowContext.h"
+
+#include "include/core/SkSurface.h"
+
+class OpenGLContext {
+public:
+  OpenGLContext(const OpenGLContext &) = delete;
+  OpenGLContext &operator=(const OpenGLContext &) = delete;
+
+  static OpenGLContext &getInstance() {
+    static thread_local OpenGLContext instance;
+    return instance;
+  }
+
+  sk_sp<SkSurface> MakeOffscreen(int width, int height) {
+    return RNSkia::SkiaOpenGLSurfaceFactory::makeOffscreenSurface(
+        &_context, width, height);
+  }
+
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+    return RNSkia::SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(
+        &_context, buffer);
+  }
+
+  std::unique_ptr<RNSkia::WindowContext> MakeWindow(ANativeWindow *window,
+                                                    int width, int height) {
+    return RNSkia::SkiaOpenGLSurfaceFactory::makeContext(&_context, window,
+                                                         width, height);
+  }
+
+private:
+  RNSkia::SkiaOpenGLContext _context;
+
+  OpenGLContext() {
+    RNSkia::SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(&_context);
+  }
+};

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

@@ -11,9 +11,9 @@
 
 #include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
+#include "OpenGLContext.h"
 #include "RNSkAndroidVideo.h"
 #include "RNSkPlatformContext.h"
-#include "SkiaOpenGLSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -51,17 +51,17 @@ public:
   }
 
   sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override {
-    return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
+    return OpenGLContext::getInstance().MakeOffscreen(width, height);
   }
 
-  std::shared_ptr<SkiaContext>
+  std::shared_ptr<WindowContext>
   makeContextFromNativeSurface(void *surface, int width, int height) override {
-    return SkiaOpenGLSurfaceFactory::makeContext(
+    return OpenGLContext::getInstance().MakeWindow(
         reinterpret_cast<ANativeWindow *>(surface), width, height);
   }
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
-    return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
+    return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
   }
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {

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

@@ -13,8 +13,8 @@
 
 #pragma clang diagnostic pop
 
+#include "OpenGLContext.h"
 #include "RNSkAndroidVideo.h"
-#include "SkiaOpenGLSurfaceFactory.h"
 
 namespace RNSkia {
 
@@ -52,7 +52,7 @@ sk_sp<SkImage> RNSkAndroidVideo::nextImage(double *timeStamp) {
   // Convert jobject to AHardwareBuffer
   AHardwareBuffer *buffer =
       AHardwareBuffer_fromHardwareBuffer(env, jHardwareBuffer);
-  return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
+  return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
 #else
   return nullptr;
 #endif

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

@@ -2,6 +2,8 @@
 
 #include <memory>
 
+#include "OpenGLContext.h"
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -20,33 +22,41 @@ RNSkOpenGLCanvasProvider::RNSkOpenGLCanvasProvider(
 RNSkOpenGLCanvasProvider::~RNSkOpenGLCanvasProvider() {}
 
 float RNSkOpenGLCanvasProvider::getScaledWidth() {
-  return _surfaceHolder ? _surfaceHolder->getWidth() : 0;
+  if (_surfaceHolder) {
+    return static_cast<float>(_surfaceHolder->getWidth());
+  }
+  return 0;
 }
 
 float RNSkOpenGLCanvasProvider::getScaledHeight() {
-  return _surfaceHolder ? _surfaceHolder->getHeight() : 0;
+  if (_surfaceHolder) {
+    return static_cast<float>(_surfaceHolder->getHeight());
+  }
+  return 0;
 }
 
 bool RNSkOpenGLCanvasProvider::renderToCanvas(
     const std::function<void(SkCanvas *)> &cb) {
-
+  JNIEnv *env = facebook::jni::Environment::current();
   if (_surfaceHolder != nullptr && cb != nullptr) {
     // Get the surface
     auto surface = _surfaceHolder->getSurface();
-    if (surface) {
-
-      // Ensure we are ready to render
-      if (!_surfaceHolder->makeCurrent()) {
-        return false;
-      }
-      _surfaceHolder->updateTexImage();
+    env->CallVoidMethod(_jSurfaceTexture, _updateTexImageMethod);
 
+    // Check for exceptions
+    if (env->ExceptionCheck()) {
+      RNSkLogger::logToConsole("updateAndRelease() failed. The exception above "
+                               "can safely be ignored");
+      env->ExceptionClear();
+    }
+    if (surface) {
       // Draw into canvas using callback
       cb(surface->getCanvas());
 
       // Swap buffers and show on screen
-      return _surfaceHolder->present();
+      _surfaceHolder->present();
 
+      return true;
     } else {
       // the render context did not provide a surface
       return false;
@@ -56,11 +66,31 @@ bool RNSkOpenGLCanvasProvider::renderToCanvas(
   return false;
 }
 
-void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject surface, int width,
-                                                int height) {
+void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject jSurfaceTexture,
+                                                int width, int height) {
   // Create renderer!
+  JNIEnv *env = facebook::jni::Environment::current();
+
+  _jSurfaceTexture = env->NewGlobalRef(jSurfaceTexture);
+  jclass surfaceClass = env->FindClass("android/view/Surface");
+  jmethodID surfaceConstructor = env->GetMethodID(
+      surfaceClass, "<init>", "(Landroid/graphics/SurfaceTexture;)V");
+  // Create a new Surface instance
+  jobject jSurface =
+      env->NewObject(surfaceClass, surfaceConstructor, jSurfaceTexture);
+
+  jclass surfaceTextureClass = env->GetObjectClass(_jSurfaceTexture);
+  _updateTexImageMethod =
+      env->GetMethodID(surfaceTextureClass, "updateTexImage", "()V");
+
+  // Acquire the native window from the Surface
+  auto window = ANativeWindow_fromSurface(env, jSurface);
+  // Clean up local references
+  env->DeleteLocalRef(jSurface);
+  env->DeleteLocalRef(surfaceClass);
+  env->DeleteLocalRef(surfaceTextureClass);
   _surfaceHolder =
-      SkiaOpenGLSurfaceFactory::makeWindowedSurface(surface, width, height);
+      OpenGLContext::getInstance().MakeWindow(window, width, height);
 
   // Post redraw request to ensure we paint in the next draw cycle.
   _requestRedraw();
@@ -69,6 +99,11 @@ void RNSkOpenGLCanvasProvider::surfaceDestroyed() {
   // destroy the renderer (a unique pointer so the dtor will be called
   // immediately.)
   _surfaceHolder = nullptr;
+  if (_jSurfaceTexture) {
+    JNIEnv *env = facebook::jni::Environment::current();
+    env->DeleteGlobalRef(_jSurfaceTexture);
+    _jSurfaceTexture = nullptr;
+  }
 }
 
 void RNSkOpenGLCanvasProvider::surfaceSizeChanged(int width, int height) {

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

@@ -5,7 +5,8 @@
 #include <memory>
 
 #include "RNSkView.h"
-#include "SkiaOpenGLSurfaceFactory.h"
+#include "WindowContext.h"
+
 #include <android/native_window.h>
 
 namespace RNSkia {
@@ -33,7 +34,9 @@ public:
   void surfaceSizeChanged(int width, int height);
 
 private:
-  std::unique_ptr<WindowSurfaceHolder> _surfaceHolder = nullptr;
+  std::unique_ptr<WindowContext> _surfaceHolder = nullptr;
   std::shared_ptr<RNSkPlatformContext> _platformContext;
+  jobject _jSurfaceTexture = nullptr;
+  jmethodID _updateTexImageMethod = nullptr;
 };
 } // namespace RNSkia

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp

@@ -13,17 +13,9 @@
 
 namespace RNSkia {
 
-thread_local SkiaOpenGLContext ThreadContextHolder::ThreadSkiaOpenGLContext;
-
-sk_sp<SkImage>
-SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer,
-                                                      bool requireKnownFormat) {
+sk_sp<SkImage> SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(
+    SkiaOpenGLContext *context, void *buffer, bool requireKnownFormat) {
 #if __ANDROID_API__ >= 26
-  // Setup OpenGL and Skia:
-  if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaOpenGLContext)) [[unlikely]] {
-    throw std::runtime_error("Failed to create Skia Context for this Thread!");
-  }
   const AHardwareBuffer *hardwareBuffer =
       static_cast<AHardwareBuffer *>(buffer);
   DeleteImageProc deleteImageProc = nullptr;
@@ -59,7 +51,7 @@ SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer,
   }
 
   auto backendTex = MakeGLBackendTexture(
-      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
+      context->directContext.get(),
       const_cast<AHardwareBuffer *>(hardwareBuffer), description.width,
       description.height, &deleteImageProc, &updateImageProc, &deleteImageCtx,
       false, format, false);
@@ -69,9 +61,9 @@ SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer,
     return nullptr;
   }
   sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
-      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
-      backendTex, kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType,
-      kOpaque_SkAlphaType, nullptr, deleteImageProc, deleteImageCtx);
+      context->directContext.get(), backendTex, kTopLeft_GrSurfaceOrigin,
+      kRGBA_8888_SkColorType, kOpaque_SkAlphaType, nullptr, deleteImageProc,
+      deleteImageCtx);
   return image;
 #else
   throw std::runtime_error(
@@ -80,25 +72,15 @@ SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer,
 #endif
 }
 
-sk_sp<SkSurface> SkiaOpenGLSurfaceFactory::makeOffscreenSurface(int width,
-                                                                int height) {
-  // Setup OpenGL and Skia:
-  if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
-
-    RNSkLogger::logToConsole(
-        "Could not create Skia Surface from native window / surface. "
-        "Failed creating Skia Direct Context");
-    return nullptr;
-  }
+sk_sp<SkSurface>
+SkiaOpenGLSurfaceFactory::makeOffscreenSurface(SkiaOpenGLContext *context,
+                                               int width, int height) {
 
   auto colorType = kN32_SkColorType;
 
   SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
 
-  if (!SkiaOpenGLHelper::makeCurrent(
-          &ThreadContextHolder::ThreadSkiaOpenGLContext,
-          ThreadContextHolder::ThreadSkiaOpenGLContext.gl1x1Surface)) {
+  if (!SkiaOpenGLHelper::makeCurrent(context, context->gl1x1Surface)) {
     RNSkLogger::logToConsole(
         "Could not create EGL Surface from native window / surface. Could "
         "not set new surface as current surface.");
@@ -106,10 +88,8 @@ sk_sp<SkSurface> SkiaOpenGLSurfaceFactory::makeOffscreenSurface(int width,
   }
 
   // Create texture
-  auto texture =
-      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
-          ->createBackendTexture(width, height, colorType,
-                                 skgpu::Mipmapped::kNo, GrRenderable::kYes);
+  auto texture = context->directContext->createBackendTexture(
+      width, height, colorType, skgpu::Mipmapped::kNo, GrRenderable::kYes);
 
   if (!texture.isValid()) {
     RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
@@ -121,13 +101,12 @@ sk_sp<SkSurface> SkiaOpenGLSurfaceFactory::makeOffscreenSurface(int width,
     GrBackendTexture texture;
   };
 
-  auto releaseCtx = new ReleaseContext(
-      {&ThreadContextHolder::ThreadSkiaOpenGLContext, texture});
+  auto releaseCtx = new ReleaseContext({context, texture});
 
   // Create a SkSurface from the GrBackendTexture
   return SkSurfaces::WrapBackendTexture(
-      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(), texture,
-      kTopLeft_GrSurfaceOrigin, 0, colorType, nullptr, &props,
+      context->directContext.get(), texture, kTopLeft_GrSurfaceOrigin, 0,
+      colorType, nullptr, &props,
       [](void *addr) {
         auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
 
@@ -137,99 +116,9 @@ sk_sp<SkSurface> SkiaOpenGLSurfaceFactory::makeOffscreenSurface(int width,
       releaseCtx);
 }
 
-sk_sp<SkSurface> WindowSurfaceHolder::getSurface() {
-  if (_skSurface == nullptr) {
-
-    // Setup OpenGL and Skia
-    if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
-            &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
-      RNSkLogger::logToConsole(
-          "Could not create Skia Surface from native window / surface. "
-          "Failed creating Skia Direct Context");
-      return nullptr;
-    }
-
-    // Now we can create a surface
-    _glSurface = SkiaOpenGLHelper::createWindowedSurface(_window);
-    if (_glSurface == EGL_NO_SURFACE) {
-      RNSkLogger::logToConsole(
-          "Could not create EGL Surface from native window / surface.");
-      return nullptr;
-    }
-
-    // Now make this one current
-    if (!SkiaOpenGLHelper::makeCurrent(
-            &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface)) {
-      RNSkLogger::logToConsole(
-          "Could not create EGL Surface from native window / surface. Could "
-          "not set new surface as current surface.");
-      return nullptr;
-    }
-
-    // Set up parameters for the render target so that it
-    // matches the underlying OpenGL context.
-    GrGLFramebufferInfo fboInfo;
-
-    // We pass 0 as the framebuffer id, since the
-    // underlying Skia GrGlGpu will read this when wrapping the context in the
-    // render target and the GrGlGpu object.
-    fboInfo.fFBOID = 0;
-    fboInfo.fFormat = 0x8058; // GL_RGBA8
-
-    GLint stencil;
-    glGetIntegerv(GL_STENCIL_BITS, &stencil);
-
-    GLint samples;
-    glGetIntegerv(GL_SAMPLES, &samples);
-
-    auto colorType = kN32_SkColorType;
-
-    auto maxSamples =
-        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
-            ->maxSurfaceSampleCountForColorType(colorType);
-
-    if (samples > maxSamples) {
-      samples = maxSamples;
-    }
-
-    auto renderTarget = GrBackendRenderTargets::MakeGL(_width, _height, samples,
-                                                       stencil, fboInfo);
-
-    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-
-    struct ReleaseContext {
-      EGLSurface glSurface;
-    };
-
-    auto releaseCtx = new ReleaseContext({_glSurface});
-
-    // Create surface object
-    _skSurface = SkSurfaces::WrapBackendRenderTarget(
-        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
-        renderTarget, kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
-        [](void *addr) {
-          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
-          SkiaOpenGLHelper::destroySurface(releaseCtx->glSurface);
-          delete releaseCtx;
-        },
-        reinterpret_cast<void *>(releaseCtx));
-  }
-
-  return _skSurface;
-}
-
 sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
   if (_skSurface == nullptr) {
 
-    // Setup OpenGL and Skia
-    if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
-            &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
-      RNSkLogger::logToConsole(
-          "Could not create Skia Surface from native window / surface. "
-          "Failed creating Skia Direct Context");
-      return nullptr;
-    }
-
     // Now we can create a surface
     _glSurface = SkiaOpenGLHelper::createWindowedSurface(_window);
     if (_glSurface == EGL_NO_SURFACE) {
@@ -239,8 +128,7 @@ sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
     }
 
     // Now make this one current
-    if (!SkiaOpenGLHelper::makeCurrent(
-            &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface)) {
+    if (!SkiaOpenGLHelper::makeCurrent(_context, _glSurface)) {
       RNSkLogger::logToConsole(
           "Could not create EGL Surface from native window / surface. Could "
           "not set new surface as current surface.");
@@ -266,8 +154,7 @@ sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
     auto colorType = kN32_SkColorType;
 
     auto maxSamples =
-        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
-            ->maxSurfaceSampleCountForColorType(colorType);
+        _context->directContext->maxSurfaceSampleCountForColorType(colorType);
 
     if (samples > maxSamples) {
       samples = maxSamples;
@@ -286,8 +173,8 @@ sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
 
     // Create surface object
     _skSurface = SkSurfaces::WrapBackendRenderTarget(
-        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
-        renderTarget, kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
+        _context->directContext.get(), renderTarget,
+        kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
         [](void *addr) {
           auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
           SkiaOpenGLHelper::destroySurface(releaseCtx->glSurface);
@@ -295,7 +182,6 @@ sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
         },
         reinterpret_cast<void *>(releaseCtx));
   }
-
   return _skSurface;
 }
 

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

@@ -13,8 +13,8 @@
 #include <thread>
 #include <unordered_map>
 
-#include "SkiaContext.h"
 #include "SkiaOpenGLHelper.h"
+#include "WindowContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -31,145 +31,45 @@
 
 namespace RNSkia {
 
-/**
- * Holder of the thread local SkiaOpenGLContext member
- */
-class ThreadContextHolder {
+class AndroidSkiaContext : public WindowContext {
 public:
-  static thread_local SkiaOpenGLContext ThreadSkiaOpenGLContext;
-};
-
-/**
- * Holder of the Windowed SkSurface with support for making current
- * and presenting to screen
- */
-class WindowSurfaceHolder {
-public:
-  WindowSurfaceHolder(jobject jSurfaceTexture, int width, int height)
-      : _width(width), _height(height) {
-    JNIEnv *env = facebook::jni::Environment::current();
-    _jSurfaceTexture = env->NewGlobalRef(jSurfaceTexture);
-    jclass surfaceClass = env->FindClass("android/view/Surface");
-    jmethodID surfaceConstructor = env->GetMethodID(
-        surfaceClass, "<init>", "(Landroid/graphics/SurfaceTexture;)V");
-    // Create a new Surface instance
-    jobject jSurface =
-        env->NewObject(surfaceClass, surfaceConstructor, jSurfaceTexture);
-
-    jclass surfaceTextureClass = env->GetObjectClass(_jSurfaceTexture);
-    _updateTexImageMethod =
-        env->GetMethodID(surfaceTextureClass, "updateTexImage", "()V");
-
-    // Acquire the native window from the Surface
-    _window = ANativeWindow_fromSurface(env, jSurface);
-    // Clean up local references
-    env->DeleteLocalRef(jSurface);
-    env->DeleteLocalRef(surfaceClass);
-    env->DeleteLocalRef(surfaceTextureClass);
-  }
-
-  ~WindowSurfaceHolder() {
-    JNIEnv *env = facebook::jni::Environment::current();
-    env->DeleteGlobalRef(_jSurfaceTexture);
-    ANativeWindow_release(_window);
-  }
-
-  int getWidth() { return _width; }
-  int getHeight() { return _height; }
-
-  /*
-   * Ensures that the holder has a valid surface and returns the surface.
-   */
-  sk_sp<SkSurface> getSurface();
-
-  void updateTexImage() {
-    JNIEnv *env = facebook::jni::Environment::current();
-
-    // Call updateTexImage on the SurfaceTexture object
-    env->CallVoidMethod(_jSurfaceTexture, _updateTexImageMethod);
-
-    // Check for exceptions
-    if (env->ExceptionCheck()) {
-      RNSkLogger::logToConsole("updateAndRelease() failed. The exception above "
-                               "can safely be ignored");
-      env->ExceptionClear();
-    }
-  }
-
-  /**
-   * Resizes the surface
-   * @param width
-   * @param height
-   */
-  void resize(int width, int height) {
-    _width = width;
-    _height = height;
-    _skSurface = nullptr;
-  }
-
-  /**
-   * Sets the current surface as the active surface
-   * @return true if make current succeeds
-   */
-  bool makeCurrent() {
-    return SkiaOpenGLHelper::makeCurrent(
-        &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface);
-  }
-
-  /**
-   * Presents the current drawing operations by swapping buffers
-   * @return true if make current succeeds
-   */
-  bool present() {
-    // Flush and submit the direct context
-    ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
-        ->flushAndSubmit();
-
-    // Swap buffers
-    return SkiaOpenGLHelper::swapBuffers(
-        &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface);
-  }
-
-private:
-  ANativeWindow *_window;
-  sk_sp<SkSurface> _skSurface = nullptr;
-  jobject _jSurfaceTexture = nullptr;
-  EGLSurface _glSurface = EGL_NO_SURFACE;
-  jmethodID _updateTexImageMethod = nullptr;
-  int _width = 0;
-  int _height = 0;
-};
+  AndroidSkiaContext(SkiaOpenGLContext *context, ANativeWindow *window,
+                     int width, int height)
+      : _context(context), _window(window), _width(width), _height(height) {}
 
-class AndroidSkiaContext : public SkiaContext {
-public:
-  AndroidSkiaContext(ANativeWindow *window, int width, int height)
-      : _window(window), _width(width), _height(height) {}
-
-  ~AndroidSkiaContext() {}
+  ~AndroidSkiaContext() { ANativeWindow_release(_window); }
 
   sk_sp<SkSurface> getSurface() override;
 
   void present() override {
-    if (!SkiaOpenGLHelper::makeCurrent(
-            &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface)) {
+    if (!SkiaOpenGLHelper::makeCurrent(_context, _glSurface)) {
       RNSkLogger::logToConsole(
           "Could not create EGL Surface from native window / surface. Could "
           "not set new surface as current surface.");
       return;
     }
     // Flush and submit the direct context
-    ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
-        ->flushAndSubmit();
+    _context->directContext->flushAndSubmit();
 
     // Swap buffers
-    SkiaOpenGLHelper::swapBuffers(&ThreadContextHolder::ThreadSkiaOpenGLContext,
-                                  _glSurface);
+    SkiaOpenGLHelper::swapBuffers(_context, _glSurface);
   }
 
+  void resize(int width, int height) override {
+    _skSurface = nullptr;
+    _width = width;
+    _height = height;
+  }
+
+  int getWidth() override { return _width; };
+
+  int getHeight() override { return _height; };
+
 private:
   ANativeWindow *_window;
   sk_sp<SkSurface> _skSurface = nullptr;
   EGLSurface _glSurface = EGL_NO_SURFACE;
+  SkiaOpenGLContext *_context;
   int _width = 0;
   int _height = 0;
 };
@@ -182,26 +82,18 @@ public:
    * @param height Height of surface
    * @return An SkSurface backed by a texture.
    */
-  static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
+  static sk_sp<SkSurface> makeOffscreenSurface(SkiaOpenGLContext *context,
+                                               int width, int height);
 
   static sk_sp<SkImage>
-  makeImageFromHardwareBuffer(void *buffer, bool requireKnownFormat = false);
-
-  static std::shared_ptr<AndroidSkiaContext>
-  makeContext(ANativeWindow *surface, int width, int height) {
-    return std::make_shared<AndroidSkiaContext>(surface, width, height);
-  }
-
-  /**
-   * Creates a windowed Skia Surface holder.
-   * @param width Initial width of surface
-   * @param height Initial height of surface
-   * @param window Window coming from Java
-   * @return A Surface holder
-   */
-  static std::unique_ptr<WindowSurfaceHolder>
-  makeWindowedSurface(jobject window, int width, int height) {
-    return std::make_unique<WindowSurfaceHolder>(window, width, height);
+  makeImageFromHardwareBuffer(SkiaOpenGLContext *context, void *buffer,
+                              bool requireKnownFormat = false);
+
+  static std::unique_ptr<AndroidSkiaContext>
+  makeContext(SkiaOpenGLContext *context, ANativeWindow *surface, int width,
+              int height) {
+    return std::make_unique<AndroidSkiaContext>(context, surface, width,
+                                                height);
   }
 };
 

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -40,7 +40,7 @@ public:
     sk_sp<SkTypeface> typeface =
         JsiSkTypeface::fromValue(runtime, arguments[0]);
     SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
-    auto result = getObject()->registerTypeface(typeface, familyName);
+    getObject()->registerTypeface(typeface, familyName);
     return jsi::Value::undefined();
   }
 

package/cpp/api/JsiSkiaContext.h

@@ -14,7 +14,7 @@
 #include "JsiSkRect.h"
 #include "JsiSkTypeface.h"
 
-#include "SkiaContext.h"
+#include "WindowContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -28,12 +28,15 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-class JsiSkiaContext : public JsiSkWrappingSharedPtrHostObject<SkiaContext> {
+class JsiSkiaContext : public JsiSkWrappingSharedPtrHostObject<WindowContext> {
 public:
   EXPORT_JSI_API_TYPENAME(JsiSkiaContext, SkiaContext)
 
   JSI_HOST_FUNCTION(getSurface) {
     auto surface = getObject()->getSurface();
+    if (surface == nullptr) {
+      return jsi::Value::null();
+    }
     return jsi::Object::createFromHostObject(
         runtime,
         std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
@@ -48,7 +51,7 @@ public:
                        JSI_EXPORT_FUNC(JsiSkiaContext, present))
 
   JsiSkiaContext(std::shared_ptr<RNSkPlatformContext> context,
-                 std::shared_ptr<SkiaContext> ctx)
+                 std::shared_ptr<WindowContext> ctx)
       : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(ctx)) {}
 
   /**

package/cpp/jsi/JsiValue.cpp

@@ -55,9 +55,8 @@ double JsiValue::getAsNumber() const {
 
 const std::string &JsiValue::getAsString() const {
   if (_type == PropType::Number) {
-    return std::move(std::to_string(_numberValue));
+    return std::to_string(_numberValue);
   }
-
   if (_type != PropType::String) {
     throw std::runtime_error("Expected type string, got " +
                              getTypeAsString(_type));

package/cpp/rnskia/RNSkPlatformContext.h

@@ -11,7 +11,7 @@
 
 #include "RNSkDispatchQueue.h"
 #include "RNSkVideo.h"
-#include "SkiaContext.h"
+#include "WindowContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -135,7 +135,7 @@ public:
    */
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
 
-  virtual std::shared_ptr<SkiaContext>
+  virtual std::shared_ptr<WindowContext>
   makeContextFromNativeSurface(void *surface, int width, int height) = 0;
 
   /**

package/cpp/rnskia/{SkiaContext.h → WindowContext.h}

@@ -12,11 +12,14 @@
 
 namespace RNSkia {
 
-class SkiaContext {
+class WindowContext {
 public:
-  virtual ~SkiaContext() = default;
+  virtual ~WindowContext() = default;
   virtual sk_sp<SkSurface> getSurface() = 0;
   virtual void present() = 0;
+  virtual void resize(int width, int height) = 0;
+  virtual int getWidth() = 0;
+  virtual int getHeight() = 0;
 };
 
 } // namespace RNSkia

package/ios/RNSkia-iOS/MetalContext.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "SkiaMetalSurfaceFactory.h"
+#include "WindowContext.h"
+
+#include "include/core/SkSurface.h"
+
+namespace RNSkia {
+class RNSkiOSPlatformContext;
+}
+
+class MetalContext {
+
+public:
+  MetalContext(const MetalContext &) = delete;
+  MetalContext &operator=(const MetalContext &) = delete;
+
+  static MetalContext &getInstance() {
+    static thread_local MetalContext instance;
+    return instance;
+  }
+
+  sk_sp<SkSurface> MakeOffscreen(int width, int height) {
+    return SkiaMetalSurfaceFactory::makeOffscreenSurface(_device, &_context,
+                                                         width, height);
+  }
+
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+    CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
+    return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(&_context,
+                                                                 sampleBuffer);
+  }
+
+  std::unique_ptr<RNSkia::WindowContext> MakeWindow(CALayer *window, int width,
+                                                    int height) {
+    return SkiaMetalSurfaceFactory::makeContext(&_context, window, width,
+                                                height);
+  }
+
+private:
+  friend class RNSkia::RNSkiOSPlatformContext;
+  id<MTLDevice> _device;
+  SkiaMetalContext _context;
+
+  MetalContext();
+};

package/ios/RNSkia-iOS/MetalContext.mm

@@ -0,0 +1,33 @@
+#include "MetalContext.h"
+
+#import <MetalKit/MetalKit.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
+#import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlTypes.h>
+#import <include/gpu/ganesh/mtl/SkSurfaceMetal.h>
+
+#pragma clang diagnostic pop
+
+MetalContext::MetalContext() {
+  _device = MTLCreateSystemDefaultDevice();
+  _context.commandQueue =
+      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[_device newCommandQueue]));
+
+  GrMtlBackendContext backendContext = {};
+  backendContext.fDevice.reset((__bridge void *)_device);
+  backendContext.fQueue.reset((__bridge void *)_context.commandQueue);
+  GrContextOptions grContextOptions; // set different options here.
+
+  // Create the Skia Direct Context
+  _context.skContext = GrDirectContexts::MakeMetal(backendContext);
+  if (_context.skContext == nullptr) {
+    RNSkia::RNSkLogger::logToConsole("Couldn't create a Skia Metal Context");
+  }
+}

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.mm

@@ -1,6 +1,6 @@
 #import "RNSkMetalCanvasProvider.h"
+#include "MetalContext.h"
 #import "RNSkLog.h"
-#import "SkiaMetalSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -23,12 +23,6 @@ RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   _layer = [CAMetalLayer layer];
 #pragma clang diagnostic pop
-  _layer.framebufferOnly = NO;
-  _layer.device = MTLCreateSystemDefaultDevice();
-  _layer.opaque = false;
-  _layer.contentsScale = _context->getPixelDensity();
-  _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
-  _layer.contentsGravity = kCAGravityBottomLeft;
 }
 
 RNSkMetalCanvasProvider::~RNSkMetalCanvasProvider() {}
@@ -36,16 +30,12 @@ RNSkMetalCanvasProvider::~RNSkMetalCanvasProvider() {}
 /**
  Returns the scaled width of the view
  */
-float RNSkMetalCanvasProvider::getScaledWidth() {
-  return _width * _context->getPixelDensity();
-};
+float RNSkMetalCanvasProvider::getScaledWidth() { return _width; };
 
 /**
  Returns the scaled height of the view
  */
-float RNSkMetalCanvasProvider::getScaledHeight() {
-  return _height * _context->getPixelDensity();
-};
+float RNSkMetalCanvasProvider::getScaledHeight() { return _height; };
 
 /**
  Render to a canvas
@@ -80,11 +70,8 @@ bool RNSkMetalCanvasProvider::renderToCanvas(
     if (currentDrawable == nullptr) {
       return false;
     }
-
-    auto skSurface = SkiaMetalSurfaceFactory::makeWindowedSurface(
-        currentDrawable.texture, _layer.drawableSize.width,
-        _layer.drawableSize.height);
-
+    auto ctx = MetalContext::getInstance().MakeWindow(_layer, _width, _height);
+    auto skSurface = ctx->getSurface();
     SkCanvas *canvas = skSurface->getCanvas();
     cb(canvas);
 
@@ -92,22 +79,15 @@ bool RNSkMetalCanvasProvider::renderToCanvas(
       dContext->flushAndSubmit();
     }
 
-    id<MTLCommandBuffer> commandBuffer(
-        [ThreadContextHolder::ThreadSkiaMetalContext
-                .commandQueue commandBuffer]);
-    [commandBuffer presentDrawable:currentDrawable];
-    [commandBuffer commit];
+    ctx->present();
   }
   return true;
 };
 
 void RNSkMetalCanvasProvider::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());
-
+  _width = width * _context->getPixelDensity();
+  _height = height * _context->getPixelDensity();
   _requestRedraw();
 }
 

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -67,7 +67,7 @@ public:
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
 
-  std::shared_ptr<SkiaContext>
+  std::shared_ptr<WindowContext>
   makeContextFromNativeSurface(void *surface, int width, int height) override;
 
   virtual void performStreamOperation(

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -5,13 +5,13 @@
 #include <thread>
 #include <utility>
 
+#include "MetalContext.h"
 #include "RNSkiOSVideo.h"
-#import "SkiaCVPixelBufferUtils.h"
-#import "SkiaMetalSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
+#import "include/core/SkColorSpace.h"
 #include "include/core/SkFontMgr.h"
 #include "include/core/SkSurface.h"
 
@@ -71,7 +71,7 @@ uint64_t RNSkiOSPlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
   if (image->colorType() != kBGRA_8888_SkColorType) {
     // on iOS, 32_BGRA is the only supported RGB format for CVPixelBuffers.
     image = image->makeColorTypeAndColorSpace(
-        ThreadContextHolder::ThreadSkiaMetalContext.skContext.get(),
+        MetalContext::getInstance()._context.skContext.get(),
         kBGRA_8888_SkColorType, SkColorSpace::MakeSRGB());
     if (image == nullptr) {
       throw std::runtime_error(
@@ -149,11 +149,11 @@ RNSkiOSPlatformContext::createVideo(const std::string &url) {
   return std::make_shared<RNSkiOSVideo>(url, this);
 }
 
-std::shared_ptr<SkiaContext>
+std::shared_ptr<WindowContext>
 RNSkiOSPlatformContext::makeContextFromNativeSurface(void *surface, int width,
                                                      int height) {
-  return SkiaMetalSurfaceFactory::makeContext((__bridge CALayer *)surface,
-                                              width, height);
+  return MetalContext::getInstance().MakeWindow((__bridge CALayer *)surface,
+                                                width, height);
 }
 
 void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
@@ -162,12 +162,11 @@ void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
 
 sk_sp<SkSurface> RNSkiOSPlatformContext::makeOffscreenSurface(int width,
                                                               int height) {
-  return SkiaMetalSurfaceFactory::makeOffscreenSurface(width, height);
+  return MetalContext::getInstance().MakeOffscreen(width, height);
 }
 
 sk_sp<SkImage> RNSkiOSPlatformContext::makeImageFromNativeBuffer(void *buffer) {
-  CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
-  return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(sampleBuffer);
+  return MetalContext::getInstance().MakeImageFromBuffer(buffer);
 }
 
 sk_sp<SkFontMgr> RNSkiOSPlatformContext::createFontMgr() {

package/ios/RNSkia-iOS/RNSkiOSView.mm

@@ -1,5 +1,3 @@
-#pragma once
-
 #import <memory>
 
 #import "RNSkMetalCanvasProvider.h"

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.h

@@ -1,9 +1,11 @@
+#pragma once
+
 #import <MetalKit/MetalKit.h>
 
 #include <memory>
 
 #include "RNSkLog.h"
-#include "SkiaContext.h"
+#include "WindowContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -20,35 +22,31 @@ using SkiaMetalContext = struct SkiaMetalContext {
   sk_sp<GrDirectContext> skContext = nullptr;
 };
 
-class ThreadContextHolder {
-public:
-  static thread_local SkiaMetalContext ThreadSkiaMetalContext;
-};
-
 class SkiaMetalSurfaceFactory {
   friend class IOSSkiaContext;
 
 public:
-  static sk_sp<SkSurface> makeWindowedSurface(id<MTLTexture> texture, int width,
+  static sk_sp<SkSurface> makeWindowedSurface(SkiaMetalContext *context,
+                                              id<MTLTexture> texture, int width,
                                               int height);
-  static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
+  static sk_sp<SkSurface> makeOffscreenSurface(id<MTLDevice> device,
+                                               SkiaMetalContext *context,
+                                               int width, int height);
 
   static sk_sp<SkImage>
-  makeTextureFromCVPixelBuffer(CVPixelBufferRef pixelBuffer);
-
-  static std::shared_ptr<RNSkia::SkiaContext>
-  makeContext(CALayer *texture, int width, int height);
+  makeTextureFromCVPixelBuffer(SkiaMetalContext *context,
+                               CVPixelBufferRef pixelBuffer);
 
-private:
-  static id<MTLDevice> device;
-  static bool
-  createSkiaDirectContextIfNecessary(SkiaMetalContext *threadContext);
+  static std::unique_ptr<RNSkia::WindowContext>
+  makeContext(SkiaMetalContext *context, CALayer *texture, int width,
+              int height);
 };
 
-class IOSSkiaContext : public RNSkia::SkiaContext {
+class IOSSkiaContext : public RNSkia::WindowContext {
 public:
-  IOSSkiaContext(CALayer *layer, int width, int height) {
-    auto pd = 3;
+  IOSSkiaContext(SkiaMetalContext *context, CALayer *layer, int width,
+                 int height)
+      : _context(context) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
     _layer = (CAMetalLayer *)layer;
@@ -56,12 +54,10 @@ public:
     _layer.framebufferOnly = NO;
     _layer.device = MTLCreateSystemDefaultDevice();
     _layer.opaque = false;
-    _layer.contentsScale = pd;
+    _layer.contentsScale = [UIScreen mainScreen].scale;
     _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
     _layer.contentsGravity = kCAGravityBottomLeft;
-
-    _layer.frame = CGRectMake(0, 0, width, height);
-    _layer.drawableSize = CGSizeMake(width * pd, height * pd);
+    _layer.drawableSize = CGSizeMake(width, height);
   }
 
   ~IOSSkiaContext() {}
@@ -70,11 +66,6 @@ public:
     if (_skSurface) {
       return _skSurface;
     }
-    // Create the Skia Direct Context if it doesn't exist
-    if (!SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-            &ThreadContextHolder::ThreadSkiaMetalContext)) {
-      return nullptr;
-    }
 
     // Get the next drawable from the CAMetalLayer
     _currentDrawable = [_layer nextDrawable];
@@ -86,7 +77,7 @@ public:
 
     // Get the texture from the drawable
     _skSurface = SkiaMetalSurfaceFactory::makeWindowedSurface(
-        _currentDrawable.texture, _layer.drawableSize.width,
+        _context, _currentDrawable.texture, _layer.drawableSize.width,
         _layer.drawableSize.height);
     return _skSurface;
   }
@@ -96,15 +87,20 @@ public:
       dContext->flushAndSubmit();
     }
 
-    id<MTLCommandBuffer> commandBuffer(
-        [ThreadContextHolder::ThreadSkiaMetalContext
-                .commandQueue commandBuffer]);
+    id<MTLCommandBuffer> commandBuffer([_context->commandQueue commandBuffer]);
     [commandBuffer presentDrawable:_currentDrawable];
     [commandBuffer commit];
     _skSurface = nullptr;
   }
 
+  void resize(int width, int height) override { _skSurface = nullptr; }
+
+  int getWidth() override { return _layer.frame.size.width; };
+
+  int getHeight() override { return _layer.frame.size.height; };
+
 private:
+  SkiaMetalContext *_context;
   sk_sp<SkSurface> _skSurface = nullptr;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.mm

@@ -21,8 +21,6 @@
 
 #pragma clang diagnostic pop
 
-thread_local SkiaMetalContext ThreadContextHolder::ThreadSkiaMetalContext;
-
 struct OffscreenRenderContext {
   id<MTLTexture> texture;
 
@@ -42,43 +40,14 @@ struct OffscreenRenderContext {
   }
 };
 
-id<MTLDevice> SkiaMetalSurfaceFactory::device = MTLCreateSystemDefaultDevice();
-
-bool SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-    SkiaMetalContext *skiaMetalContext) {
-  if (skiaMetalContext->skContext == nullptr) {
-    skiaMetalContext->commandQueue =
-        id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
-
-    GrMtlBackendContext backendContext = {};
-    backendContext.fDevice.reset((__bridge void *)device);
-    backendContext.fQueue.reset(
-        (__bridge void *)skiaMetalContext->commandQueue);
-    GrContextOptions grContextOptions; // set different options here.
-
-    // Create the Skia Direct Context
-    skiaMetalContext->skContext = GrDirectContexts::MakeMetal(backendContext);
-    if (skiaMetalContext->skContext == nullptr) {
-      RNSkia::RNSkLogger::logToConsole("Couldn't create a Skia Metal Context");
-      return false;
-    }
-  }
-  return true;
-}
-
-std::shared_ptr<RNSkia::SkiaContext>
-SkiaMetalSurfaceFactory::makeContext(CALayer *texture, int width, int height) {
-  return std::make_shared<IOSSkiaContext>(texture, width, height);
+std::unique_ptr<RNSkia::WindowContext>
+SkiaMetalSurfaceFactory::makeContext(SkiaMetalContext *context,
+                                     CALayer *texture, int width, int height) {
+  return std::make_unique<IOSSkiaContext>(context, texture, width, height);
 }
 
-sk_sp<SkSurface>
-SkiaMetalSurfaceFactory::makeWindowedSurface(id<MTLTexture> texture, int width,
-                                             int height) {
-  // Get render context for current thread
-  if (!SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaMetalContext)) {
-    return nullptr;
-  }
+sk_sp<SkSurface> SkiaMetalSurfaceFactory::makeWindowedSurface(
+    SkiaMetalContext *context, id<MTLTexture> texture, int width, int height) {
   GrMtlTextureInfo fbInfo;
   fbInfo.fTexture.retain((__bridge void *)texture);
 
@@ -86,8 +55,8 @@ SkiaMetalSurfaceFactory::makeWindowedSurface(id<MTLTexture> texture, int width,
       GrBackendRenderTargets::MakeMtl(width, height, fbInfo);
 
   auto skSurface = SkSurfaces::WrapBackendRenderTarget(
-      ThreadContextHolder::ThreadSkiaMetalContext.skContext.get(), backendRT,
-      kTopLeft_GrSurfaceOrigin, kBGRA_8888_SkColorType, nullptr, nullptr);
+      context->skContext.get(), backendRT, kTopLeft_GrSurfaceOrigin,
+      kBGRA_8888_SkColorType, nullptr, nullptr);
 
   if (skSurface == nullptr || skSurface->getCanvas() == nullptr) {
     RNSkia::RNSkLogger::logToConsole(
@@ -97,15 +66,11 @@ SkiaMetalSurfaceFactory::makeWindowedSurface(id<MTLTexture> texture, int width,
   return skSurface;
 }
 
-sk_sp<SkSurface> SkiaMetalSurfaceFactory::makeOffscreenSurface(int width,
-                                                               int height) {
-  if (!SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaMetalContext)) {
-    return nullptr;
-  }
-  auto ctx = new OffscreenRenderContext(
-      device, ThreadContextHolder::ThreadSkiaMetalContext.skContext,
-      ThreadContextHolder::ThreadSkiaMetalContext.commandQueue, width, height);
+sk_sp<SkSurface> SkiaMetalSurfaceFactory::makeOffscreenSurface(
+    id<MTLDevice> device, SkiaMetalContext *context, int width, int height) {
+
+  auto ctx = new OffscreenRenderContext(device, context->skContext,
+                                        context->commandQueue, width, height);
 
   // Create a GrBackendTexture from the Metal texture
   GrMtlTextureInfo info;
@@ -115,34 +80,27 @@ sk_sp<SkSurface> SkiaMetalSurfaceFactory::makeOffscreenSurface(int width,
 
   // Create a SkSurface from the GrBackendTexture
   auto surface = SkSurfaces::WrapBackendTexture(
-      ThreadContextHolder::ThreadSkiaMetalContext.skContext.get(),
-      backendTexture, kTopLeft_GrSurfaceOrigin, 0, kBGRA_8888_SkColorType,
-      nullptr, nullptr,
+      context->skContext.get(), backendTexture, kTopLeft_GrSurfaceOrigin, 0,
+      kBGRA_8888_SkColorType, nullptr, nullptr,
       [](void *addr) { delete (OffscreenRenderContext *)addr; }, ctx);
 
   return surface;
 }
 
 sk_sp<SkImage> SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(
-    CVPixelBufferRef pixelBuffer) {
-  if (!SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaMetalContext)) [[unlikely]] {
-    throw std::runtime_error("Failed to create Skia Context for this Thread!");
-  }
-  const SkiaMetalContext &context = ThreadContextHolder::ThreadSkiaMetalContext;
-
+    SkiaMetalContext *context, CVPixelBufferRef pixelBuffer) {
   SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat format =
       SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(pixelBuffer);
   switch (format) {
   case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::rgb: {
     // CVPixelBuffer is in any RGB format, single-plane
     return SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
-        context.skContext.get(), pixelBuffer);
+        context->skContext.get(), pixelBuffer);
   }
   case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::yuv: {
     // CVPixelBuffer is in any YUV format, multi-plane
     return SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
-        context.skContext.get(), pixelBuffer);
+        context->skContext.get(), pixelBuffer);
   }
   default:
     [[unlikely]] {

package/ios/RNSkia-iOS/SkiaUIView.h

@@ -14,8 +14,6 @@
 #import <React/RCTViewComponentView.h>
 #endif // RCT_NEW_ARCH_ENABLED
 
-class RNSkiOSJsView;
-
 @interface SkiaUIView :
 #if RCT_NEW_ARCH_ENABLED
     RCTViewComponentView

package/ios/RNSkia-iOS/ViewScreenshotService.mm

@@ -34,14 +34,7 @@
   UIGraphicsImageRendererFormat *format =
       [UIGraphicsImageRendererFormat defaultFormat];
   format.opaque = NO;
-
-  // Explicitly ask for the standard format to get ARGB 32bits and not 64bits.
-  if (@available(iOS 12.0, *)) {
-    format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
-  } else {
-    // Fallback on earlier versions
-    format.prefersExtendedRange = false;
-  }
+  format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
 
   UIGraphicsImageRenderer *renderer =
       [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];

package/package.json

@@ -7,7 +7,7 @@
     "setup-skia-web": "./scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",