@pompadour/react-native-skia 1.4.0

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

@@ -0,0 +1,310 @@
+#pragma once
+
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+#include <atomic>
+
+#include "RNSkLog.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/GrDirectContext.h"
+#include "include/gpu/ganesh/gl/GrGLDirectContext.h"
+#include "include/gpu/gl/GrGLInterface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ * Singleton holding the default display and shared eglContext that will be the
+ * first context we create so that we can share data between contexts.
+ */
+class OpenGLResourceHolder {
+private:
+  OpenGLResourceHolder() {
+    // Initialize OpenGL
+    glDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (glDisplay == EGL_NO_DISPLAY) {
+      RNSkLogger::logToConsole("eglGetDisplay failed : %i", glGetError());
+      return;
+    }
+
+    EGLint major;
+    EGLint minor;
+    if (eglInitialize(glDisplay, &major, &minor) != EGL_TRUE) {
+      RNSkLogger::logToConsole("eglInitialize failed : %i", glGetError());
+      return;
+    }
+
+    // Create a default shared context
+    glConfig = getConfig(glDisplay);
+
+    // Create OpenGL context attributes
+    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+
+    // Initialize the offscreen context for this thread
+    glContext =
+        eglCreateContext(glDisplay, glConfig, glContext, contextAttribs);
+    if (glContext == EGL_NO_CONTEXT) {
+      RNSkLogger::logToConsole("eglCreateContext failed : %i", glGetError());
+    }
+  }
+
+  ~OpenGLResourceHolder() {
+    if (glContext != EGL_NO_CONTEXT) {
+      eglDestroyContext(glDisplay, glContext);
+      glContext = EGL_NO_CONTEXT;
+    }
+
+    if (glDisplay != EGL_NO_DISPLAY) {
+      eglTerminate(glDisplay);
+      glDisplay = EGL_NO_DISPLAY;
+    }
+  }
+  /* Explicitly disallow copying. */
+  OpenGLResourceHolder(const OpenGLResourceHolder &) = delete;
+  OpenGLResourceHolder &operator=(const OpenGLResourceHolder &) = delete;
+
+public:
+  static OpenGLResourceHolder &getInstance() {
+    static OpenGLResourceHolder Instance;
+    return Instance;
+  }
+
+  /**
+   * The first context created will be considered the parent / shared context
+   * and will be used as the parent / shareable context when creating subsequent
+   * contexts.
+   */
+  std::atomic<EGLContext> glContext = EGL_NO_CONTEXT;
+  /**
+   * Shared egl display
+   */
+  std::atomic<EGLDisplay> glDisplay = EGL_NO_DISPLAY;
+
+  /**
+   * Shared eglConfig
+   */
+  std::atomic<EGLConfig> glConfig = 0;
+
+private:
+  /**
+   * Finds the correct EGL Config for the given parameters
+   * @param glDisplay
+   * @return Config or zero if no matching context could be found.
+   */
+  static EGLConfig getConfig(EGLDisplay glDisplay) {
+
+    EGLint att[] = {EGL_RENDERABLE_TYPE,
+                    EGL_OPENGL_ES2_BIT,
+                    EGL_ALPHA_SIZE,
+                    8,
+                    EGL_BLUE_SIZE,
+                    8,
+                    EGL_GREEN_SIZE,
+                    8,
+                    EGL_RED_SIZE,
+                    8,
+                    EGL_DEPTH_SIZE,
+                    0,
+                    EGL_STENCIL_SIZE,
+                    0,
+                    EGL_SAMPLE_BUFFERS,
+                    0,
+                    EGL_NONE};
+
+    EGLint numConfigs;
+    EGLConfig glConfig = 0;
+    if (eglChooseConfig(glDisplay, att, &glConfig, 1, &numConfigs) !=
+            EGL_TRUE ||
+        numConfigs == 0) {
+      RNSkLogger::logToConsole(
+          "Failed to choose a config for %s surface. Error code: %d\n",
+          eglGetError());
+      return 0;
+    }
+
+    return glConfig;
+  }
+};
+
+struct SkiaOpenGLContext {
+  SkiaOpenGLContext() {
+    glContext = EGL_NO_CONTEXT;
+    gl1x1Surface = EGL_NO_SURFACE;
+    directContext = nullptr;
+  }
+  ~SkiaOpenGLContext() {
+    if (gl1x1Surface != EGL_NO_SURFACE) {
+      eglDestroySurface(OpenGLResourceHolder::getInstance().glDisplay,
+                        gl1x1Surface);
+      gl1x1Surface = EGL_NO_SURFACE;
+    }
+
+    if (directContext) {
+      directContext->releaseResourcesAndAbandonContext();
+      directContext = nullptr;
+    }
+
+    if (glContext != EGL_NO_CONTEXT) {
+      eglDestroyContext(OpenGLResourceHolder::getInstance().glDisplay,
+                        glContext);
+      glContext = EGL_NO_CONTEXT;
+    }
+  }
+  EGLContext glContext;
+  EGLSurface gl1x1Surface;
+  sk_sp<GrDirectContext> directContext;
+};
+
+class SkiaOpenGLHelper {
+public:
+  /**
+   * Calls eglMakeCurrent on the surface provided using the provided
+   * thread context.
+   * @param context Skia OpenGL context to use
+   * @param surface Surface to set as current
+   * @return true if eglMakeCurrent was successfull
+   */
+  static bool makeCurrent(SkiaOpenGLContext *context, EGLSurface glSurface) {
+    // We don't need to call make current if we already are current:
+    if (eglGetCurrentSurface(EGL_DRAW) != glSurface ||
+        eglGetCurrentSurface(EGL_READ) != glSurface ||
+        eglGetCurrentContext() != context->glContext) {
+
+      // Make current!
+      if (eglMakeCurrent(OpenGLResourceHolder::getInstance().glDisplay,
+                         glSurface, glSurface,
+                         context->glContext) != EGL_TRUE) {
+        RNSkLogger::logToConsole("eglMakeCurrent failed: %d\n", eglGetError());
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Creates a new windowed surface
+   * @param window ANativeWindow to create surface in
+   * @return EGLSurface or EGL_NO_SURFACE if the call failed
+   */
+  static EGLSurface createWindowedSurface(ANativeWindow *window) {
+    const EGLint attribs[] = {EGL_NONE};
+    return eglCreateWindowSurface(OpenGLResourceHolder::getInstance().glDisplay,
+                                  OpenGLResourceHolder::getInstance().glConfig,
+                                  window, attribs);
+  }
+
+  /**
+   * Destroys an egl surface
+   * @param glSurface
+   * @return
+   */
+  static bool destroySurface(EGLSurface glSurface) {
+    if (eglMakeCurrent(OpenGLResourceHolder::getInstance().glDisplay,
+                       EGL_NO_SURFACE, EGL_NO_SURFACE,
+                       EGL_NO_CONTEXT) != EGL_TRUE) {
+      RNSkLogger::logToConsole(
+          "destroySurface: Could not clear selected surface");
+      return false;
+    }
+    return eglDestroySurface(OpenGLResourceHolder::getInstance().glDisplay,
+                             glSurface) == EGL_TRUE;
+  }
+
+  /**
+   * Calls the eglSwapBuffer in the current thread with the provided surface
+   * @param context Thread context
+   * @param glSurface surface to present
+   * @return true if eglSwapBuffers succeeded.
+   */
+  static bool swapBuffers(SkiaOpenGLContext *context, EGLSurface glSurface) {
+    if (eglSwapBuffers(OpenGLResourceHolder::getInstance().glDisplay,
+                       glSurface) != EGL_TRUE) {
+      RNSkLogger::logToConsole("eglSwapBuffers failed: %d\n", eglGetError());
+      return false;
+    }
+    return true;
+  }
+
+  /***
+   * Creates a new Skia direct context backed by the provided eglContext in the
+   * SkiaOpenGLContext.
+   * @param context Context to store results in
+   * @param sharedContext Shared Context
+   * @return true if the call to create a skia direct context suceeded.
+   */
+  static bool createSkiaDirectContextIfNecessary(SkiaOpenGLContext *context) {
+    if (context->directContext == nullptr) {
+
+      // Create OpenGL context
+      createOpenGLContext(context);
+
+      // Create attributes for a simple 1x1 pbuffer surface that we can
+      // use to activate and create Skia direct context for
+      const EGLint offScreenSurfaceAttribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1,
+                                                EGL_NONE};
+
+      context->gl1x1Surface =
+          eglCreatePbufferSurface(OpenGLResourceHolder::getInstance().glDisplay,
+                                  OpenGLResourceHolder::getInstance().glConfig,
+                                  offScreenSurfaceAttribs);
+
+      if (context->gl1x1Surface == EGL_NO_SURFACE) {
+        RNSkLogger::logToConsole("Failed creating a 1x1 pbuffer surface");
+        return false;
+      }
+
+      // Activate
+      if (!makeCurrent(context, context->gl1x1Surface)) {
+        return false;
+      }
+
+      // Create the Skia context
+      auto backendInterface = GrGLMakeNativeInterface();
+      context->directContext = GrDirectContexts::MakeGL(backendInterface);
+
+      if (context->directContext == nullptr) {
+        RNSkLogger::logToConsole("GrDirectContexts::MakeGL failed");
+        return false;
+      }
+    }
+
+    // It all went well!
+    return true;
+  }
+
+private:
+  /**
+   * Creates a new GLContext.
+   * @param context Context to save results in
+   * @return True if the call to eglCreateContext returned a valid OpenGL
+   * Context or if the context already is setup.
+   */
+  static bool createOpenGLContext(SkiaOpenGLContext *context) {
+    // Create OpenGL context attributes
+    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+
+    // Initialize the offscreen context for this thread
+    context->glContext = eglCreateContext(
+        OpenGLResourceHolder::getInstance().glDisplay,
+        OpenGLResourceHolder::getInstance().glConfig,
+        OpenGLResourceHolder::getInstance().glContext, contextAttribs);
+
+    if (context->glContext == EGL_NO_CONTEXT) {
+      RNSkLogger::logToConsole("eglCreateContext failed: %d\n", eglGetError());
+      return EGL_NO_CONTEXT;
+    }
+
+    return true;
+  }
+};
+} // namespace RNSkia

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

@@ -0,0 +1,221 @@
+#include "SkiaOpenGLSurfaceFactory.h"
+#include "GrAHardwareBufferUtils.h"
+#include "SkiaOpenGLHelper.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 {
+
+thread_local SkiaOpenGLContext ThreadContextHolder::ThreadSkiaOpenGLContext;
+
+sk_sp<SkImage>
+SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(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;
+  UpdateImageProc updateImageProc = nullptr;
+  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 = MakeGLBackendTexture(
+      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
+      const_cast<AHardwareBuffer *>(hardwareBuffer), description.width,
+      description.height, &deleteImageProc, &updateImageProc, &deleteImageCtx,
+      false, format, false);
+  if (!backendTex.isValid()) {
+    RNSkLogger::logToConsole(
+        "Failed to convert HardwareBuffer to OpenGL Texture!");
+    return nullptr;
+  }
+  sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
+      ThreadContextHolder::ThreadSkiaOpenGLContext.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
+}
+
+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;
+  }
+
+  auto colorType = kN32_SkColorType;
+
+  SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+  if (!SkiaOpenGLHelper::makeCurrent(
+          &ThreadContextHolder::ThreadSkiaOpenGLContext,
+          ThreadContextHolder::ThreadSkiaOpenGLContext.gl1x1Surface)) {
+    RNSkLogger::logToConsole(
+        "Could not create EGL Surface from native window / surface. Could "
+        "not set new surface as current surface.");
+    return nullptr;
+  }
+
+  // Create texture
+  auto texture =
+      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+          ->createBackendTexture(width, height, colorType,
+                                 skgpu::Mipmapped::kNo, GrRenderable::kYes);
+
+  if (!texture.isValid()) {
+    RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
+                             height);
+  }
+
+  struct ReleaseContext {
+    SkiaOpenGLContext *context;
+    GrBackendTexture texture;
+  };
+
+  auto releaseCtx = new ReleaseContext(
+      {&ThreadContextHolder::ThreadSkiaOpenGLContext, texture});
+
+  // Create a SkSurface from the GrBackendTexture
+  return SkSurfaces::WrapBackendTexture(
+      ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(), texture,
+      kTopLeft_GrSurfaceOrigin, 0, colorType, nullptr, &props,
+      [](void *addr) {
+        auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+
+        releaseCtx->context->directContext->deleteBackendTexture(
+            releaseCtx->texture);
+      },
+      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;
+}
+
+} // namespace RNSkia

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

@@ -0,0 +1,168 @@
+#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 "SkiaOpenGLHelper.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/GrBackendSurface.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/gpu/gl/GrGLInterface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ * Holder of the thread local SkiaOpenGLContext member
+ */
+class ThreadContextHolder {
+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;
+};
+
+class SkiaOpenGLSurfaceFactory {
+public:
+  /**
+   * Creates a new Skia surface that is backed by a texture.
+   * @param width Width of surface
+   * @param height Height of surface
+   * @return An SkSurface backed by a texture.
+   */
+  static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
+
+  static sk_sp<SkImage>
+  makeImageFromHardwareBuffer(void *buffer, bool requireKnownFormat = false);
+
+  /**
+   * 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);
+  }
+};
+
+} // namespace RNSkia

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<!-- AndroidManifest.xml -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.shopify.reactnative.skia">
+
+</manifest>