@pompadour/react-native-skia 1.0.0

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

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+
+#include "JniSkiaBaseView.h"
+#include "JniSkiaManager.h"
+#include "RNSkAndroidView.h"
+#include "RNSkPictureView.h"
+
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+#include <fbjni/detail/Hybrid.h>
+
+namespace RNSkia {
+namespace jsi = facebook::jsi;
+namespace jni = facebook::jni;
+
+class JniSkiaPictureView : public jni::HybridClass<JniSkiaPictureView>,
+                           public JniSkiaBaseView {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/shopify/reactnative/skia/SkiaPictureView;";
+
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis,
+             jni::alias_ref<JniSkiaManager::javaobject> skiaManager) {
+    return makeCxxInstance(jThis, skiaManager);
+  }
+
+  static void registerNatives() {
+    registerHybrid(
+        {makeNativeMethod("initHybrid", JniSkiaPictureView::initHybrid),
+         makeNativeMethod("surfaceAvailable",
+                          JniSkiaPictureView::surfaceAvailable),
+         makeNativeMethod("surfaceDestroyed",
+                          JniSkiaPictureView::surfaceDestroyed),
+         makeNativeMethod("surfaceSizeChanged",
+                          JniSkiaPictureView::surfaceSizeChanged),
+         makeNativeMethod("setMode", JniSkiaPictureView::setMode),
+         makeNativeMethod("setDebugMode", JniSkiaPictureView::setDebugMode),
+         makeNativeMethod("updateTouchPoints",
+                          JniSkiaPictureView::updateTouchPoints),
+         makeNativeMethod("registerView", JniSkiaPictureView::registerView),
+         makeNativeMethod("unregisterView",
+                          JniSkiaPictureView::unregisterView)});
+  }
+
+protected:
+  void updateTouchPoints(jni::JArrayDouble touches) override {
+    JniSkiaBaseView::updateTouchPoints(touches);
+  }
+
+  void surfaceAvailable(jobject surface, int width, int height) override {
+    JniSkiaBaseView::surfaceAvailable(surface, width, height);
+  }
+
+  void surfaceSizeChanged(int width, int height) override {
+    JniSkiaBaseView::surfaceSizeChanged(width, height);
+  }
+
+  void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }
+
+  void setMode(std::string mode) override { JniSkiaBaseView::setMode(mode); }
+
+  void setDebugMode(bool show) override { JniSkiaBaseView::setDebugMode(show); }
+
+  void registerView(int nativeId) override {
+    JniSkiaBaseView::registerView(nativeId);
+  }
+
+  void unregisterView() override { JniSkiaBaseView::unregisterView(); }
+
+private:
+  friend HybridBase;
+
+  explicit JniSkiaPictureView(
+      jni::alias_ref<jhybridobject> jThis,
+      jni::alias_ref<JniSkiaManager::javaobject> skiaManager)
+      : JniSkiaBaseView(
+            skiaManager,
+            std::make_shared<RNSkAndroidView<RNSkia::RNSkPictureView>>(
+                skiaManager->cthis()->getPlatformContext())) {}
+
+  jni::global_ref<javaobject> javaPart_;
+};
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/AHardwareBufferUtils.cpp

@@ -0,0 +1,31 @@
+#if __ANDROID_API__ >= 26
+
+#include "AHardwareBufferUtils.h"
+#include <android/hardware_buffer.h>
+
+namespace RNSkia {
+
+uint32_t GetBufferFormatFromSkColorType(SkColorType bufferFormat) {
+  switch (bufferFormat) {
+  case kRGBA_8888_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+  case kRGB_888x_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM;
+  case kRGBA_F16_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
+  case kRGB_565_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
+  case kRGBA_1010102_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
+#if __ANDROID_API__ >= 33
+  case kAlpha_8_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8_UNORM;
+#endif
+  default:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+  }
+}
+
+} // namespace RNSkia
+
+#endif

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "include/core/SkColorType.h"
+
+#if __ANDROID_API__ >= 26
+
+namespace RNSkia {
+
+uint32_t GetBufferFormatFromSkColorType(SkColorType bufferFormat);
+
+} // namespace RNSkia
+
+#endif

package/android/cpp/rnskia-android/GrAHardwareBufferUtils.cpp

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrAHardwareBufferUtils.h"
+#if __ANDROID_API__ >= 26
+
+#define GL_GLEXT_PROTOTYPES
+#define EGL_EGLEXT_PROTOTYPES
+
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "include/gpu/gl/GrGLTypes.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
+// #include "src/gpu/ganesh/GrDirectContextPriv.h"
+// #include "src/gpu/ganesh/gl/GrGLUtil.h"
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+#include <android/hardware_buffer.h>
+
+#define PROT_CONTENT_EXT_STR "EGL_EXT_protected_content"
+#define EGL_PROTECTED_CONTENT_EXT 0x32C0
+
+namespace RNSkia {
+
+typedef EGLClientBuffer (*EGLGetNativeClientBufferANDROIDProc)(
+    const struct AHardwareBuffer *);
+typedef EGLImageKHR (*EGLCreateImageKHRProc)(EGLDisplay, EGLContext, EGLenum,
+                                             EGLClientBuffer, const EGLint *);
+typedef void (*EGLImageTargetTexture2DOESProc)(EGLenum, void *);
+
+GrBackendFormat GetGLBackendFormat(GrDirectContext *dContext,
+                                   uint32_t bufferFormat,
+                                   bool requireKnownFormat) {
+  GrBackendApi backend = dContext->backend();
+  if (backend != GrBackendApi::kOpenGL) {
+    return GrBackendFormat();
+  }
+  switch (bufferFormat) {
+  // TODO: find out if we can detect, which graphic buffers support
+  // GR_GL_TEXTURE_2D
+  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+    return GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+    return GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+    return GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+    return GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+    return GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
+#if __ANDROID_API__ >= 33
+  case AHARDWAREBUFFER_FORMAT_R8_UNORM:
+    return GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
+#endif
+  default:
+    if (requireKnownFormat) {
+      return GrBackendFormat();
+    } else {
+      return GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+    }
+  }
+  SkUNREACHABLE;
+}
+
+class GLTextureHelper {
+public:
+  GLTextureHelper(GrGLuint texID, EGLImageKHR image, EGLDisplay display,
+                  GrGLuint texTarget)
+      : fTexID(texID), fImage(image), fDisplay(display), fTexTarget(texTarget) {
+  }
+  ~GLTextureHelper() {
+    glDeleteTextures(1, &fTexID);
+    // eglDestroyImageKHR will remove a ref from the AHardwareBuffer
+    eglDestroyImageKHR(fDisplay, fImage);
+  }
+  void rebind(GrDirectContext *);
+
+private:
+  GrGLuint fTexID;
+  EGLImageKHR fImage;
+  EGLDisplay fDisplay;
+  GrGLuint fTexTarget;
+};
+
+void GLTextureHelper::rebind(GrDirectContext *dContext) {
+  glBindTexture(fTexTarget, fTexID);
+  GLenum status = GL_NO_ERROR;
+  if ((status = glGetError()) != GL_NO_ERROR) {
+    SkDebugf("glBindTexture(%#x, %d) failed (%#x)",
+             static_cast<int>(fTexTarget), static_cast<int>(fTexID),
+             static_cast<int>(status));
+    return;
+  }
+  glEGLImageTargetTexture2DOES(fTexTarget, fImage);
+  if ((status = glGetError()) != GL_NO_ERROR) {
+    SkDebugf("glEGLImageTargetTexture2DOES failed (%#x)",
+             static_cast<int>(status));
+    return;
+  }
+  dContext->resetContext(kTextureBinding_GrGLBackendState);
+}
+
+void delete_gl_texture(void *context) {
+  GLTextureHelper *cleanupHelper = static_cast<GLTextureHelper *>(context);
+  delete cleanupHelper;
+}
+
+void update_gl_texture(void *context, GrDirectContext *dContext) {
+  GLTextureHelper *cleanupHelper = static_cast<GLTextureHelper *>(context);
+  cleanupHelper->rebind(dContext);
+}
+
+static GrBackendTexture make_gl_backend_texture(
+    GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer, int width,
+    int height, DeleteImageProc *deleteProc, UpdateImageProc *updateProc,
+    TexImageCtx *imageCtx, bool isProtectedContent,
+    const GrBackendFormat &backendFormat, bool isRenderable) {
+  while (GL_NO_ERROR != glGetError()) {
+  } // clear GL errors
+
+  EGLGetNativeClientBufferANDROIDProc eglGetNativeClientBufferANDROID =
+      (EGLGetNativeClientBufferANDROIDProc)eglGetProcAddress(
+          "eglGetNativeClientBufferANDROID");
+  if (!eglGetNativeClientBufferANDROID) {
+    RNSkLogger::logToConsole(
+        "Failed to get the eglGetNativeClientBufferAndroid proc");
+    return GrBackendTexture();
+  }
+
+  EGLClientBuffer clientBuffer =
+      eglGetNativeClientBufferANDROID(hardwareBuffer);
+  EGLint attribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
+                      isProtectedContent ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
+                      isProtectedContent ? EGL_TRUE : EGL_NONE, EGL_NONE};
+  EGLDisplay display = eglGetCurrentDisplay();
+  // eglCreateImageKHR will add a ref to the AHardwareBuffer
+  EGLImageKHR image =
+      eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
+                        clientBuffer, attribs);
+  if (EGL_NO_IMAGE_KHR == image) {
+    SkDebugf("Could not create EGL image, err = (%#x)",
+             static_cast<int>(eglGetError()));
+    return GrBackendTexture();
+  }
+
+  GrGLuint texID;
+  glGenTextures(1, &texID);
+  if (!texID) {
+    eglDestroyImageKHR(display, image);
+    return GrBackendTexture();
+  }
+
+  GrGLuint target = isRenderable ? GR_GL_TEXTURE_2D : GR_GL_TEXTURE_EXTERNAL;
+
+  glBindTexture(target, texID);
+  GLenum status = GL_NO_ERROR;
+  if ((status = glGetError()) != GL_NO_ERROR) {
+    SkDebugf("glBindTexture failed (%#x)", static_cast<int>(status));
+    glDeleteTextures(1, &texID);
+    eglDestroyImageKHR(display, image);
+    return GrBackendTexture();
+  }
+  glEGLImageTargetTexture2DOES(target, image);
+  if ((status = glGetError()) != GL_NO_ERROR) {
+    SkDebugf("glEGLImageTargetTexture2DOES failed (%#x)",
+             static_cast<int>(status));
+    glDeleteTextures(1, &texID);
+    eglDestroyImageKHR(display, image);
+    return GrBackendTexture();
+  }
+  dContext->resetContext(kTextureBinding_GrGLBackendState);
+
+  GrGLTextureInfo textureInfo;
+  textureInfo.fID = texID;
+  SkASSERT(backendFormat.isValid());
+  textureInfo.fTarget = target;
+  textureInfo.fFormat = GrBackendFormats::AsGLFormatEnum(backendFormat);
+  textureInfo.fProtected = skgpu::Protected(isProtectedContent);
+
+  *deleteProc = delete_gl_texture;
+  *updateProc = update_gl_texture;
+  *imageCtx = new GLTextureHelper(texID, image, display, target);
+
+  return GrBackendTextures::MakeGL(width, height, skgpu::Mipmapped::kNo,
+                                   textureInfo);
+}
+
+static bool can_import_protected_content_eglimpl() {
+  EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  const char *exts = eglQueryString(dpy, EGL_EXTENSIONS);
+  size_t cropExtLen = strlen(PROT_CONTENT_EXT_STR);
+  size_t extsLen = strlen(exts);
+  bool equal = !strcmp(PROT_CONTENT_EXT_STR, exts);
+  bool atStart = !strncmp(PROT_CONTENT_EXT_STR " ", exts, cropExtLen + 1);
+  bool atEnd =
+      (cropExtLen + 1) < extsLen &&
+      !strcmp(" " PROT_CONTENT_EXT_STR, exts + extsLen - (cropExtLen + 1));
+  bool inMiddle = strstr(exts, " " PROT_CONTENT_EXT_STR " ");
+  return equal || atStart || atEnd || inMiddle;
+}
+
+static bool can_import_protected_content(GrDirectContext *dContext) {
+  SkASSERT(GrBackendApi::kOpenGL == dContext->backend());
+  // Only compute whether the extension is present once the first time this
+  // function is called.
+  static bool hasIt = can_import_protected_content_eglimpl();
+  return hasIt;
+}
+
+GrBackendTexture
+MakeGLBackendTexture(GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer,
+                     int width, int height, DeleteImageProc *deleteProc,
+                     UpdateImageProc *updateProc, TexImageCtx *imageCtx,
+                     bool isProtectedContent,
+                     const GrBackendFormat &backendFormat, bool isRenderable) {
+  SkASSERT(dContext);
+  if (!dContext || dContext->abandoned()) {
+    return GrBackendTexture();
+  }
+
+  if (GrBackendApi::kOpenGL != dContext->backend()) {
+    return GrBackendTexture();
+  }
+
+  if (isProtectedContent && !can_import_protected_content(dContext)) {
+    return GrBackendTexture();
+  }
+
+  return make_gl_backend_texture(
+      dContext, hardwareBuffer, width, height, deleteProc, updateProc, imageCtx,
+      isProtectedContent, backendFormat, isRenderable);
+}
+
+} // namespace RNSkia
+
+#endif

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "include/core/SkTypes.h"
+
+#include "RNSkLog.h"
+
+#if __ANDROID_API__ >= 26
+
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrTypes.h"
+
+class GrDirectContext;
+
+extern "C" {
+typedef struct AHardwareBuffer AHardwareBuffer;
+}
+
+namespace RNSkia {
+
+typedef void *TexImageCtx;
+typedef void (*DeleteImageProc)(TexImageCtx);
+typedef void (*UpdateImageProc)(TexImageCtx, GrDirectContext *);
+
+GrBackendTexture
+MakeGLBackendTexture(GrDirectContext *dContext, AHardwareBuffer *hardwareBuffer,
+                     int width, int height, DeleteImageProc *deleteProc,
+                     UpdateImageProc *updateProc, TexImageCtx *imageCtx,
+                     bool isProtectedContent,
+                     const GrBackendFormat &backendFormat, bool isRenderable);
+
+} // namespace RNSkia
+
+#endif

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

@@ -0,0 +1,152 @@
+#pragma once
+
+// TODO: Add android flags
+#if __ANDROID_API__ >= 26
+#include <android/hardware_buffer.h>
+#endif
+#include <exception>
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "AHardwareBufferUtils.h"
+#include "JniPlatformContext.h"
+#include "RNSkAndroidVideo.h"
+#include "RNSkPlatformContext.h"
+#include "SkiaOpenGLSurfaceFactory.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/ports/SkFontMgr_android.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+namespace jsi = facebook::jsi;
+
+class RNSkAndroidPlatformContext : public RNSkPlatformContext {
+public:
+  RNSkAndroidPlatformContext(
+      JniPlatformContext *jniPlatformContext, jsi::Runtime *runtime,
+      std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
+      : RNSkPlatformContext(runtime, jsCallInvoker,
+                            jniPlatformContext->getPixelDensity()),
+        _jniPlatformContext(jniPlatformContext) {
+    // Hook onto the notify draw loop callback in the platform context
+    jniPlatformContext->setOnNotifyDrawLoop(
+        [this]() { notifyDrawLoop(false); });
+  }
+
+  ~RNSkAndroidPlatformContext() { stopDrawLoop(); }
+
+  void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override {
+    _jniPlatformContext->performStreamOperation(sourceUri, op);
+  }
+
+  void raiseError(const std::exception &err) override {
+    _jniPlatformContext->raiseError(err);
+  }
+
+  sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override {
+    return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
+  }
+
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
+    return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
+  }
+
+  std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
+    auto jniVideo = _jniPlatformContext->createVideo(url);
+    return std::make_shared<RNSkAndroidVideo>(jniVideo);
+  }
+
+  void releaseNativeBuffer(uint64_t pointer) override {
+#if __ANDROID_API__ >= 26
+    AHardwareBuffer *buffer = reinterpret_cast<AHardwareBuffer *>(pointer);
+    AHardwareBuffer_release(buffer);
+#endif
+  }
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
+#if __ANDROID_API__ >= 26
+    auto bytesPerPixel = image->imageInfo().bytesPerPixel();
+    int bytesPerRow = image->width() * bytesPerPixel;
+    auto buf = SkData::MakeUninitialized(image->width() * image->height() *
+                                         bytesPerPixel);
+    SkImageInfo info =
+        SkImageInfo::Make(image->width(), image->height(), image->colorType(),
+                          image->alphaType());
+    image->readPixels(nullptr, info, const_cast<void *>(buf->data()),
+                      bytesPerRow, 0, 0);
+    const void *pixelData = buf->data();
+
+    // Define the buffer description
+    AHardwareBuffer_Desc desc = {};
+    // TODO: use image info here
+    desc.width = image->width();
+    desc.height = image->height();
+    desc.layers = 1; // Single image layer
+    desc.format = GetBufferFormatFromSkColorType(
+        image->colorType()); // Assuming the image
+                             // is in this format
+    desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
+                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    desc.stride = bytesPerRow; // Stride in pixels, not in bytes
+
+    // Allocate the buffer
+    AHardwareBuffer *buffer = nullptr;
+    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
+      // Handle allocation failure
+      return 0;
+    }
+
+    // Map the buffer to gain access to its memory
+    void *mappedBuffer = nullptr;
+    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1,
+                         nullptr, &mappedBuffer);
+    if (mappedBuffer == nullptr) {
+      // Handle mapping failure
+      AHardwareBuffer_release(buffer);
+      return 0;
+    }
+
+    // Copy the image data to the buffer
+    memcpy(mappedBuffer, pixelData, desc.height * bytesPerRow);
+
+    // Unmap the buffer
+    AHardwareBuffer_unlock(buffer, nullptr);
+
+    // Return the buffer pointer as a uint64_t. It's the caller's responsibility
+    // to manage this buffer.
+    return reinterpret_cast<uint64_t>(buffer);
+#else
+    return 0;
+#endif
+  }
+
+  sk_sp<SkFontMgr> createFontMgr() override {
+    return SkFontMgr_New_Android(nullptr);
+  }
+
+  void runOnMainThread(std::function<void()> task) override {
+    _jniPlatformContext->runTaskOnMainThread(task);
+  }
+
+  sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override {
+    return _jniPlatformContext->takeScreenshotFromViewTag(tag);
+  }
+
+  void startDrawLoop() override { _jniPlatformContext->startDrawLoop(); }
+
+  void stopDrawLoop() override { _jniPlatformContext->stopDrawLoop(); }
+
+private:
+  JniPlatformContext *_jniPlatformContext;
+};
+
+} // namespace RNSkia