@shopify/react-native-skia 1.5.0 → 1.5.2

package/android/cpp/jni/include/JniSkiaBaseView.h

@@ -29,7 +29,6 @@ public:
   }
 
 protected:
-
   virtual void surfaceAvailable(jobject surface, int width, int height) {
     _skiaAndroidView->surfaceAvailable(surface, width, height);
   }

package/android/cpp/jni/include/JniSkiaPictureView.h

@@ -49,7 +49,6 @@ public:
   }
 
 protected:
-
   void surfaceAvailable(jobject surface, int width, int height) override {
     JniSkiaBaseView::surfaceAvailable(surface, width, height);
   }

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);
   }
 };