@shopify/react-native-skia 1.5.3 → 1.5.5

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/OpenGLWindowContext.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/GrAHardwareBufferUtils.cpp"
+    )
+endif()
+
 if(${REACT_NATIVE_VERSION} LESS 66)
         file(
                 TO_CMAKE_PATH
@@ -45,9 +74,8 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniSkiaManager.cpp"
 
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/opengl/Error.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 +94,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 +117,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 +132,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 +267,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 +284,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 +303,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/OpenGLContext.h

@@ -1,9 +1,18 @@
 #pragma once
 
-#include "SkiaOpenGLSurfaceFactory.h"
-#include "WindowContext.h"
+#include "GrAHardwareBufferUtils.h"
+#include "OpenGLWindowContext.h"
+#include "opengl/Display.h"
 
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
+#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "include/gpu/ganesh/gl/GrGLDirectContext.h"
+#include "include/gpu/ganesh/gl/GrGLInterface.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
 
 class OpenGLContext {
 public:
@@ -16,25 +25,127 @@ public:
   }
 
   sk_sp<SkSurface> MakeOffscreen(int width, int height) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeOffscreenSurface(
-        &_context, width, height);
+    auto colorType = kRGBA_8888_SkColorType;
+
+    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+    auto result = _ctx->makeCurrent(*_surface);
+    if (!result) {
+      return nullptr;
+    }
+
+    // Create texture
+    auto texture = _directContext->createBackendTexture(
+        width, height, colorType, skgpu::Mipmapped::kNo, GrRenderable::kYes);
+
+    if (!texture.isValid()) {
+      RNSkia::RNSkLogger::logToConsole(
+          "couldn't create offscreen texture %dx%d", width, height);
+    }
+
+    struct ReleaseContext {
+      GrDirectContext *directContext;
+      GrBackendTexture texture;
+    };
+
+    auto releaseCtx = new ReleaseContext{.directContext = _directContext.get(),
+                                         .texture = texture};
+
+    // Create a SkSurface from the GrBackendTexture
+    return SkSurfaces::WrapBackendTexture(
+        _directContext.get(), texture, kTopLeft_GrSurfaceOrigin, 0, colorType,
+        nullptr, &props,
+        [](void *addr) {
+          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+          releaseCtx->directContext->deleteBackendTexture(releaseCtx->texture);
+          delete releaseCtx;
+        },
+        releaseCtx);
   }
 
-  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(
-        &_context, buffer);
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer,
+                                     bool requireKnownFormat = false) {
+#if __ANDROID_API__ >= 26
+    const AHardwareBuffer *hardwareBuffer =
+        static_cast<AHardwareBuffer *>(buffer);
+    RNSkia::DeleteImageProc deleteImageProc = nullptr;
+    RNSkia::UpdateImageProc updateImageProc = nullptr;
+    RNSkia::TexImageCtx deleteImageCtx = nullptr;
+
+    AHardwareBuffer_Desc description;
+    AHardwareBuffer_describe(hardwareBuffer, &description);
+    GrBackendFormat format;
+    switch (description.format) {
+    // TODO: find out if we can detect, which graphic buffers support
+    // GR_GL_TEXTURE_2D
+    case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+      format = GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
+    case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
+#if __ANDROID_API__ >= 33
+    case AHARDWAREBUFFER_FORMAT_R8_UNORM:
+      format = GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
+#endif
+    default:
+      if (requireKnownFormat) {
+        format = GrBackendFormat();
+      } else {
+        format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+      }
+    }
+
+    auto backendTex = RNSkia::MakeGLBackendTexture(
+        _directContext.get(), const_cast<AHardwareBuffer *>(hardwareBuffer),
+        description.width, description.height, &deleteImageProc,
+        &updateImageProc, &deleteImageCtx, false, format, false);
+    if (!backendTex.isValid()) {
+      RNSkia::RNSkLogger::logToConsole(
+          "Failed to convert HardwareBuffer to OpenGL Texture!");
+      return nullptr;
+    }
+    sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
+        _directContext.get(), backendTex, kTopLeft_GrSurfaceOrigin,
+        kRGBA_8888_SkColorType, kOpaque_SkAlphaType, nullptr, deleteImageProc,
+        deleteImageCtx);
+    return image;
+#else
+    throw std::runtime_error(
+        "HardwareBuffers are only supported on Android API 26 or higher! Set "
+        "your minSdk to 26 (or higher) and try again.");
+#endif
   }
 
   std::unique_ptr<RNSkia::WindowContext> MakeWindow(ANativeWindow *window,
                                                     int width, int height) {
-    return RNSkia::SkiaOpenGLSurfaceFactory::makeContext(&_context, window,
-                                                         width, height);
+    return std::make_unique<RNSkia::OpenGLWindowContext>(
+        _config, _display.get(), _ctx.get(), _directContext.get(), window,
+        width, height);
   }
 
 private:
-  RNSkia::SkiaOpenGLContext _context;
+  EGLConfig _config;
+  std::unique_ptr<RNSkia::Display> _display;
+  std::unique_ptr<RNSkia::Context> _ctx;
+  std::unique_ptr<RNSkia::Surface> _surface;
+  sk_sp<GrDirectContext> _directContext;
 
   OpenGLContext() {
-    RNSkia::SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(&_context);
+    _display = std::make_unique<RNSkia::Display>();
+    _config = _display->chooseConfig();
+    _ctx = _display->makeContext(_config, nullptr);
+    _surface = _display->makePixelBufferSurface(_config, 1, 1);
+    _ctx->makeCurrent(*_surface);
+    auto backendInterface = GrGLMakeNativeInterface();
+    _directContext = GrDirectContexts::MakeGL(backendInterface);
+
+    if (_directContext == nullptr) {
+      throw std::runtime_error("GrDirectContexts::MakeGL failed");
+    }
   }
 };

package/android/cpp/rnskia-android/OpenGLWindowContext.cpp

@@ -0,0 +1,73 @@
+#include "OpenGLWindowContext.h"
+#include "GrAHardwareBufferUtils.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+sk_sp<SkSurface> OpenGLWindowContext::getSurface() {
+  if (_skSurface == nullptr) {
+
+    struct ReleaseContext {
+      std::unique_ptr<Surface> surface = nullptr;
+    };
+
+    auto releaseCtx = new ReleaseContext();
+    releaseCtx->surface = _display->makeWindowSurface(_config, _window);
+    _surface = releaseCtx->surface.get();
+  
+    // Now make this one current
+    _context->makeCurrent(*releaseCtx->surface);
+
+    // 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 =
+        _directContext->maxSurfaceSampleCountForColorType(colorType);
+
+    if (samples > maxSamples) {
+      samples = maxSamples;
+    }
+
+    auto renderTarget = GrBackendRenderTargets::MakeGL(_width, _height, samples,
+                                                       stencil, fboInfo);
+
+    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+  
+    // Create surface object
+    _skSurface = SkSurfaces::WrapBackendRenderTarget(
+        _directContext, renderTarget, kBottomLeft_GrSurfaceOrigin, colorType,
+        nullptr, &props,
+        [](void *addr) {
+          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+          delete releaseCtx;
+        },
+        reinterpret_cast<void *>(releaseCtx));
+  }
+  return _skSurface;
+}
+
+} // namespace RNSkia

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

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "RNSkLog.h"
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include <android/native_window_jni.h>
+#include <android/surface_texture.h>
+#include <android/surface_texture_jni.h>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <unordered_map>
+
+#include "WindowContext.h"
+#include "opengl/Display.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/gpu/ganesh/gl/GrGLInterface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class OpenGLWindowContext : public WindowContext {
+public:
+  OpenGLWindowContext(EGLConfig &config, Display *display, Context *context,
+                      GrDirectContext *directContext, ANativeWindow *window,
+                      int width, int height)
+      : _config(config), _display(display), _directContext(directContext),
+        _context(context), _window(window), _width(width), _height(height) {}
+
+  ~OpenGLWindowContext() { ANativeWindow_release(_window); }
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override {
+    _context->makeCurrent(*_surface);
+    _directContext->flushAndSubmit();
+    _surface->Present();
+  }
+
+  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;
+  EGLConfig _config;
+  Context *_context;
+  Surface* _surface;
+  Display *_display;
+  GrDirectContext *_directContext;
+  int _width = 0;
+  int _height = 0;
+};
+
+} // namespace RNSkia

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"
@@ -62,7 +71,6 @@ bool RNSkOpenGLCanvasProvider::renderToCanvas(
       return false;
     }
   }
-
   return false;
 }
 
@@ -89,8 +97,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/cpp/rnskia-android/opengl/Context.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "opengl/Error.h"
+#include "opengl/Surface.h"
+
+namespace RNSkia {
+
+class Surface;
+class Display;
+
+class Context {
+public:
+  ~Context() {
+    if (_context != EGL_NO_CONTEXT) {
+      if (eglDestroyContext(_display, _context) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() const { return _context != EGL_NO_CONTEXT; }
+
+  const EGLContext &getHandle() const { return _context; }
+
+  bool makeCurrent(const Surface &surface) const {
+    if (_context == EGL_NO_CONTEXT) {
+      return false;
+    }
+    const auto result =
+        eglMakeCurrentIfNecessary(_display, surface.getHandle(),
+                                  surface.getHandle(), _context) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+  bool clearCurrent() const {
+    const auto result =
+        eglMakeCurrentIfNecessary(_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                                  EGL_NO_CONTEXT) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+  bool isCurrent() const { return eglGetCurrentContext() == _context; }
+
+private:
+  friend class Display;
+
+  EGLDisplay _display = EGL_NO_DISPLAY;
+  EGLContext _context = EGL_NO_CONTEXT;
+
+  static EGLBoolean eglMakeCurrentIfNecessary(EGLDisplay display,
+                                              EGLSurface draw, EGLSurface read,
+                                              EGLContext context) {
+    if (display != eglGetCurrentDisplay() ||
+        draw != eglGetCurrentSurface(EGL_DRAW) ||
+        read != eglGetCurrentSurface(EGL_READ) ||
+        context != eglGetCurrentContext()) {
+      return eglMakeCurrent(display, draw, read, context);
+    }
+
+    return EGL_TRUE;
+  }
+
+  Context(EGLDisplay display, EGLContext context)
+      : _display(display), _context(context) {}
+
+  Context(const Context &) = delete;
+
+  Context &operator=(const Context &) = delete;
+};
+
+} // namespace RNSkia