react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/android/consumer-rules.pro

@@ -0,0 +1,7 @@
+# tgfx's Android NativeCodec resolves this class through JNI FindClass, so
+# nothing in Java or Kotlin references it and R8 strips it from a minified
+# release build. It is what applies EXIF orientation on the platform decode
+# path, which is where anything the embedded codecs do not handle — HEIF, AVIF —
+# still goes: without this a release build draws those photos sideways while
+# debug draws them upright.
+-keep class androidx.exifinterface.media.ExifInterface { *; }

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroTgfx_kotlinVersion=2.1.21
+NitroTgfx_minSdkVersion=23
+NitroTgfx_targetSdkVersion=36
+NitroTgfx_compileSdkVersion=36
+NitroTgfx_ndkVersion=29.0.14206865

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/TgfxAndroid.cpp

@@ -0,0 +1,347 @@
+// JNI bridge for the Android tgfx view: an EGL tgfx::Window from the Java Surface.
+#include <android/native_window_jni.h>
+#include <jni.h>
+
+#include <memory>
+#include <span>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "Log.hpp"
+#include "Snapshot.hpp"
+#include "TgfxRenderer.hpp"
+#include "tgfx/core/Data.h"
+#include "tgfx/gpu/opengl/egl/EGLWindow.h"
+
+namespace {
+
+// A wake can originate on a camera or decode thread, neither of which is a Java thread.
+JavaVM* gVm = nullptr;
+
+JNIEnv* wakeEnv() {
+  JNIEnv* env = nullptr;
+  if (gVm == nullptr) {
+    return nullptr;
+  }
+  if (gVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_OK) {
+    return env;
+  }
+  // As a daemon, so a thread we do not own is not required to detach at exit.
+  return gVm->AttachCurrentThreadAsDaemon(&env, nullptr) == JNI_OK ? env : nullptr;
+}
+
+struct AndroidTgfxView {
+  tgfxrn::TgfxRenderer renderer;
+  ANativeWindow* nativeWindow = nullptr;
+
+  // The TgfxRenderTarget to post a draw on. Global: the wake is not from a Java thread.
+  jobject wakeTarget = nullptr;
+  jmethodID requestRender = nullptr;
+
+  void releaseWindow() {
+    renderer.releaseWindow();
+    if (nativeWindow != nullptr) {
+      ANativeWindow_release(nativeWindow);
+      nativeWindow = nullptr;
+    }
+  }
+};
+
+AndroidTgfxView* asView(jlong ptr) {
+  return reinterpret_cast<AndroidTgfxView*>(ptr);
+}
+
+std::string toString(JNIEnv* env, jstring value) {
+  if (value == nullptr) {
+    return "";
+  }
+  const char* chars = env->GetStringUTFChars(value, nullptr);
+  std::string result = chars != nullptr ? chars : "";
+  if (chars != nullptr) {
+    env->ReleaseStringUTFChars(value, chars);
+  }
+  return result;
+}
+
+class SnapshotSink {
+ public:
+  SnapshotSink(JNIEnv* env, jobject callback) {
+    env->GetJavaVM(&vm_);
+    callback_ = env->NewGlobalRef(callback);
+  }
+
+  ~SnapshotSink() {
+    if (callback_ == nullptr) {
+      return;
+    }
+    withEnv([this](JNIEnv* env) { env->DeleteGlobalRef(callback_); });
+  }
+
+  SnapshotSink(const SnapshotSink&) = delete;
+  SnapshotSink& operator=(const SnapshotSink&) = delete;
+
+  void deliver(const std::shared_ptr<tgfx::Data>& data, int width, int height,
+               const std::string& error) {
+    withEnv([&](JNIEnv* env) {
+      jobject buffer =
+          data != nullptr
+              ? env->NewDirectByteBuffer(const_cast<void*>(data->data()),
+                                         static_cast<jlong>(data->size()))
+              : nullptr;
+      jstring message = error.empty() ? nullptr : env->NewStringUTF(error.c_str());
+      jclass type = env->GetObjectClass(callback_);
+      jmethodID method = env->GetMethodID(
+          type, "onSnapshot", "(Ljava/nio/ByteBuffer;IILjava/lang/String;)V");
+      if (method != nullptr) {
+        env->CallVoidMethod(callback_, method, buffer, width, height, message);
+      }
+      env->DeleteLocalRef(type);
+      if (buffer != nullptr) {
+        env->DeleteLocalRef(buffer);
+      }
+      if (message != nullptr) {
+        env->DeleteLocalRef(message);
+      }
+    });
+  }
+
+ private:
+  template <typename Body>
+  void withEnv(Body&& body) {
+    if (vm_ == nullptr) {
+      return;
+    }
+    JNIEnv* env = nullptr;
+    bool attached = false;
+    if (vm_->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+      if (vm_->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+        return;
+      }
+      attached = true;
+    }
+    body(env);
+    if (attached) {
+      vm_->DetachCurrentThread();
+    }
+  }
+
+  JavaVM* vm_ = nullptr;
+  jobject callback_ = nullptr;
+};
+
+}  // namespace
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_create(JNIEnv*, jobject) {
+  return reinterpret_cast<jlong>(new AndroidTgfxView());
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_surfaceCreated(JNIEnv* env, jobject,
+                                                      jlong ptr,
+                                                      jobject surface) {
+  auto* view = asView(ptr);
+  if (view == nullptr || surface == nullptr) {
+    return;
+  }
+  if (view->nativeWindow != nullptr) {
+    view->renderer.releaseWindow();
+    ANativeWindow_release(view->nativeWindow);
+    view->nativeWindow = nullptr;
+  }
+  view->nativeWindow = ANativeWindow_fromSurface(env, surface);
+  if (view->nativeWindow == nullptr) {
+    return;
+  }
+  auto window = tgfx::EGLWindow::MakeFrom(view->nativeWindow);
+  view->renderer.setWindow(window);
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_surfaceChanged(JNIEnv*, jobject,
+                                                      jlong ptr, jint, jint) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->renderer.onResize();
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_surfaceDestroyed(JNIEnv*, jobject,
+                                                        jlong ptr) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->releaseWindow();
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_setPixelRatio(JNIEnv*, jobject, jlong ptr,
+                                                     jfloat ratio) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->renderer.setPixelRatio(static_cast<float>(ratio));
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_setScene(JNIEnv* env, jobject, jlong ptr,
+                                                jobject sceneBuffer,
+                                                jobjectArray stringTable) {
+  auto* view = asView(ptr);
+  if (view == nullptr || sceneBuffer == nullptr) {
+    return;
+  }
+  // The ArrayBuffer is only valid for this call, so the renderer copies the words.
+  auto* words = static_cast<const double*>(
+      env->GetDirectBufferAddress(sceneBuffer));
+  auto bytes = env->GetDirectBufferCapacity(sceneBuffer);
+  if (words == nullptr || bytes <= 0) {
+    // Drops the string-table delta too, which JS cannot resend; do not add a third early return.
+    return;
+  }
+  std::vector<std::string> strings;
+  if (stringTable != nullptr) {
+    jsize count = env->GetArrayLength(stringTable);
+    strings.reserve(static_cast<size_t>(count));
+    for (jsize i = 0; i < count; i++) {
+      auto item = reinterpret_cast<jstring>(
+          env->GetObjectArrayElement(stringTable, i));
+      const char* chars = item != nullptr
+                              ? env->GetStringUTFChars(item, nullptr)
+                              : nullptr;
+      strings.emplace_back(chars != nullptr ? chars : "");
+      if (chars != nullptr) {
+        env->ReleaseStringUTFChars(item, chars);
+      }
+      env->DeleteLocalRef(item);
+    }
+  }
+  view->renderer.setScene(
+      std::span<const double>(words, static_cast<size_t>(bytes) / sizeof(double)),
+      strings);
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_setOpaque(JNIEnv*, jobject, jlong ptr,
+                                                 jboolean opaque) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->renderer.setOpaque(opaque == JNI_TRUE);
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_clearScene(JNIEnv*, jobject, jlong ptr) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->renderer.clearScene();
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_setValues(JNIEnv* env, jobject, jlong ptr,
+                                                 jdoubleArray arr) {
+  auto* view = asView(ptr);
+  if (view == nullptr || arr == nullptr) {
+    return;
+  }
+  jsize len = env->GetArrayLength(arr);
+  std::vector<double> values(static_cast<size_t>(len));
+  if (len > 0) {
+    env->GetDoubleArrayRegion(arr, 0, len, values.data());
+  }
+  view->renderer.setValues(values);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_draw(JNIEnv*, jobject, jlong ptr) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    return view->renderer.draw() ? JNI_TRUE : JNI_FALSE;
+  }
+  return JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_setWakeTarget(JNIEnv* env, jobject, jlong ptr,
+                                                     jobject target) {
+  auto* view = asView(ptr);
+  if (view == nullptr || target == nullptr) {
+    return;
+  }
+  env->GetJavaVM(&gVm);
+  view->wakeTarget = env->NewGlobalRef(target);
+  jclass cls = env->GetObjectClass(target);
+  view->requestRender = env->GetMethodID(cls, "requestRender", "()V");
+  env->DeleteLocalRef(cls);
+  if (view->requestRender == nullptr) {
+    // A pending NoSuchMethodError would abort the next JNI call instead.
+    env->ExceptionClear();
+    TGFXRN_LOGW("TgfxRenderTarget.requestRender() not found; a swapped hardware "
+                "buffer will not schedule a draw");
+    return;
+  }
+  view->renderer.setWakeCallback([view] {
+    JNIEnv* wake = wakeEnv();
+    if (wake != nullptr) {
+      wake->CallVoidMethod(view->wakeTarget, view->requestRender);
+    }
+  });
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_snapshot(
+    JNIEnv* env, jobject, jlong ptr, jstring format, jint quality, jfloat x,
+    jfloat y, jfloat width, jfloat height, jfloat scale, jstring path,
+    jobject callback) {
+  auto* view = asView(ptr);
+  if (callback == nullptr) {
+    return;
+  }
+  auto sink = std::make_shared<SnapshotSink>(env, callback);
+  if (view == nullptr) {
+    sink->deliver(nullptr, 0, 0, "[tgfx] snapshot: the canvas is no longer mounted");
+    return;
+  }
+  tgfxrn::SnapshotRequest request;
+  request.format = toString(env, format);
+  request.quality = quality;
+  request.x = x;
+  request.y = y;
+  request.width = width;
+  request.height = height;
+  request.scale = scale;
+  request.path = toString(env, path);
+  view->renderer.requestSnapshot(
+      request, [sink](std::shared_ptr<tgfx::Data> data, int w, int h,
+                      const std::string& error) {
+        sink->deliver(data, w, h, error);
+      });
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_hasPendingSnapshot(JNIEnv*, jobject,
+                                                          jlong ptr) {
+  auto* view = asView(ptr);
+  return view != nullptr && view->renderer.snapshotPending() ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_com_margelo_nitro_tgfx_TgfxNative_destroy(JNIEnv* env, jobject, jlong ptr) {
+  auto* view = asView(ptr);
+  if (view != nullptr) {
+    view->renderer.setWakeCallback(nullptr);
+    if (view->wakeTarget != nullptr) {
+      env->DeleteGlobalRef(view->wakeTarget);
+      view->wakeTarget = nullptr;
+    }
+    view->releaseWindow();
+    delete view;
+  }
+}
+
+}  // extern "C"

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,11 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <tgfx/platform/android/JNIEnvironment.h>
+#include "NitroTgfxOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, [vm]() {
+    tgfx::JNIEnvironment::SetJavaVM(vm);
+    margelo::nitro::tgfx::registerAllNatives();
+  });
+}

package/android/src/main/java/com/margelo/nitro/tgfx/HybridTgfxView.kt

@@ -0,0 +1,139 @@
+package com.margelo.nitro.tgfx
+
+import android.content.Context
+import android.graphics.Canvas
+import android.view.TextureView
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.views.RecyclableView
+
+private class HostLayout(context: Context) : FrameLayout(context) {
+  fun setCanvas(child: View) {
+    removeAllViews()
+    addView(
+      child,
+      LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+    )
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    getChildAt(0)?.measure(
+      MeasureSpec.makeMeasureSpec(r - l, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(b - t, MeasureSpec.EXACTLY)
+    )
+    super.onLayout(changed, l, t, r, b)
+  }
+
+  /** A non-accelerated canvas is a window screenshot; TextureView.draw renders nothing there. */
+  override fun dispatchDraw(canvas: Canvas) {
+    val child = getChildAt(0)
+    if (!canvas.isHardwareAccelerated && child is TextureView && child.isAvailable) {
+      val frame = child.bitmap
+      if (frame != null) {
+        canvas.drawBitmap(frame, 0f, 0f, null)
+        return
+      }
+    }
+    super.dispatchDraw(canvas)
+  }
+}
+
+@Keep
+@DoNotStrip
+class HybridTgfxView(private val context: ThemedReactContext) :
+  HybridTgfxViewSpec(), RecyclableView {
+
+  private val target = TgfxRenderTarget()
+  private val host = HostLayout(context)
+  override val view: FrameLayout = host
+
+  init {
+    applyCanvas()
+  }
+
+  private fun applyCanvas() {
+    val canvas =
+      if (inHierarchy) {
+        TgfxTextureView(context, target).also { it.setOpaqueSurface(opaque) }
+      } else {
+        TgfxSurfaceView(context, target).also { it.setOpaqueSurface(opaque) }
+      }
+    host.setCanvas(canvas)
+  }
+
+  /** Swaps the canvas view. Fabric applies props before attach, so a later change re-creates it. */
+  override var inHierarchy: Boolean = false
+    set(value) {
+      if (field == value) {
+        return
+      }
+      field = value
+      applyCanvas()
+    }
+
+  override var opaque: Boolean = false
+    set(value) {
+      if (field == value) {
+        return
+      }
+      field = value
+      target.setOpaque(value)
+      // A SurfaceView's pixel format only takes on a fresh surface, so recreate rather than set.
+      applyCanvas()
+    }
+
+  override fun setScene(scene: ArrayBuffer, strings: Array<String>) {
+    target.setScene(scene.getBuffer(false), strings)
+  }
+
+  override fun invalidate() {
+    target.requestRender()
+  }
+
+  override fun setValues(values: DoubleArray) {
+    target.setValues(values)
+  }
+
+  override fun snapshot(options: NativeSnapshotOptions): Promise<NativeSnapshot> {
+    val promise = Promise<NativeSnapshot>()
+    target.snapshot(options, "") { data, width, height, error ->
+      when {
+        error != null -> promise.reject(RuntimeException(error))
+        data == null ->
+          promise.reject(RuntimeException("[tgfx] snapshot: the readback produced no bytes"))
+        // The direct buffer is only valid for this call, so the bytes go into a Nitro-owned one.
+        else -> promise.resolve(
+          NativeSnapshot(
+            ArrayBuffer.copy(data),
+            width.toDouble(),
+            height.toDouble(),
+            options.format
+          )
+        )
+      }
+    }
+    return promise
+  }
+
+  override fun save(path: String, options: NativeSnapshotOptions): Promise<Unit> {
+    val promise = Promise<Unit>()
+    target.snapshot(options, path) { _, _, _, error ->
+      if (error != null) promise.reject(RuntimeException(error)) else promise.resolve(Unit)
+    }
+    return promise
+  }
+
+  override fun prepareForRecycle() {
+    target.clearScene()
+  }
+
+  override fun onDropView() {
+    target.release()
+  }
+}

package/android/src/main/java/com/margelo/nitro/tgfx/NitroTgfxPackage.kt

@@ -0,0 +1,24 @@
+package com.margelo.nitro.tgfx
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.tgfx.views.HybridTgfxViewManager
+
+class NitroTgfxPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> = listOf(HybridTgfxViewManager())
+
+    companion object {
+        init {
+            NitroTgfxOnLoad.initializeNative()
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/tgfx/TgfxNative.kt

@@ -0,0 +1,49 @@
+package com.margelo.nitro.tgfx
+
+import android.view.Surface
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.nio.ByteBuffer
+
+/** JNI bridge to libNitroTgfx; every method takes a native `TgfxRenderer` pointer from [create]. */
+internal object TgfxNative {
+  init {
+    System.loadLibrary("NitroTgfx")
+  }
+
+  external fun create(): Long
+
+  external fun setWakeTarget(ptr: Long, target: TgfxRenderTarget)
+  external fun surfaceCreated(ptr: Long, surface: Surface)
+  external fun surfaceChanged(ptr: Long, width: Int, height: Int)
+  external fun surfaceDestroyed(ptr: Long)
+  external fun setPixelRatio(ptr: Long, ratio: Float)
+  external fun setScene(ptr: Long, scene: ByteBuffer, strings: Array<String>)
+  external fun clearScene(ptr: Long)
+  external fun setOpaque(ptr: Long, opaque: Boolean)
+  external fun setValues(ptr: Long, values: DoubleArray)
+  external fun draw(ptr: Long): Boolean
+
+  /** Called once per [snapshot] on a native worker, never the render thread. [data] is call-scoped. */
+  @Keep
+  @DoNotStrip
+  fun interface SnapshotCallback {
+    fun onSnapshot(data: ByteBuffer?, width: Int, height: Int, error: String?)
+  }
+
+  external fun snapshot(
+    ptr: Long,
+    format: String,
+    quality: Int,
+    x: Float,
+    y: Float,
+    width: Float,
+    height: Float,
+    scale: Float,
+    path: String,
+    callback: SnapshotCallback
+  )
+
+  external fun hasPendingSnapshot(ptr: Long): Boolean
+  external fun destroy(ptr: Long)
+}