@apollohg/react-native-rich-text-editor 2.0.0

package/android/src/main/jni/PreparedProseViewerMeasurementsManager.cpp

@@ -0,0 +1,334 @@
+#include "reactnativeproseeditor.h"
+
+#include <fbjni/fbjni.h>
+#include <folly/dynamic.h>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/core/conversions.h>
+
+using namespace facebook::jni;
+
+namespace facebook::react {
+
+namespace {
+
+folly::dynamic optionalStringToDynamic(
+    const std::optional<std::string>& value) {
+  return value ? folly::dynamic(*value) : folly::dynamic(nullptr);
+}
+
+folly::dynamic toDynamic(const PreparedProseViewerProps& props) {
+  // The generated component props are deliberately copied into a ReadableMap
+  // for FabricUIManager.measure; the Java manager is the only Android layout
+  // boundary and owns DIP-to-pixel normalization.
+  return folly::dynamic::object
+      ("sourceKind", props.sourceKind == PreparedProseViewerSourceKind::Html ? "html" : "json")
+      ("source", props.source)
+      ("configJson", props.configJson)
+      ("themeJson", optionalStringToDynamic(props.themeJson))
+      ("imagePolicyJson", optionalStringToDynamic(props.imagePolicyJson))
+      ("imagesEnabled", props.imagesEnabled)
+      ("collapsesWhenEmpty", props.collapsesWhenEmpty)
+      ("enableLinkTaps", props.enableLinkTaps)
+      ("fontEnvironmentRevision", props.fontEnvironmentRevision);
+}
+
+folly::dynamic toState(
+    uint64_t attachmentRevision,
+    uint64_t nativeFontRevision,
+    double nativeFontScale,
+    uint64_t leaseHandle) {
+  return folly::dynamic::object
+      ("attachmentRevision", static_cast<int64_t>(attachmentRevision))
+      ("nativeFontRevision", static_cast<int64_t>(nativeFontRevision))
+      ("nativeFontScale", nativeFontScale)
+      ("leaseHandle", std::to_string(static_cast<int64_t>(leaseHandle)));
+}
+
+// Each C++ state-family owns one bridge while it is live. Terminal callbacks
+// can run on the final C++ state release rather than a Java-created thread, so
+// this must retain a JNI global reference instead of the local class lookup
+// that created it. The bridge owns no state-family object, avoiding a cycle.
+class AndroidLeaseLifecycleBridge final {
+ public:
+  static AndroidLeaseLifecycleBridge& processLifetime() {
+    // Intentionally process-lifetime: VM teardown can occur from an
+    // unattached native thread, where destroying a JNI global is unsafe.
+    static std::mutex mutex;
+    static AndroidLeaseLifecycleBridge* bridge = nullptr;
+    std::lock_guard<std::mutex> lock(mutex);
+    if (!bridge) {
+      bridge = new AndroidLeaseLifecycleBridge(
+          facebook::jni::make_global(facebook::jni::findClassStatic(
+              "com/apollohg/editor/viewer/FabricLeaseHandleBridge")));
+    }
+    return *bridge;
+  }
+
+  explicit AndroidLeaseLifecycleBridge(
+      facebook::jni::global_ref<facebook::jni::JClass> bridgeClass)
+      : bridgeClass_(std::move(bridgeClass)),
+        registerLease_(bridgeClass_->getStaticMethod<void(jint, jint, jlong)>(
+            "registerNativeLease")),
+        finalizeLease_(bridgeClass_->getStaticMethod<void(jint, jint, jlong)>(
+            "finalizeNativeLease")),
+        beginNativeMeasure_(
+            bridgeClass_->getStaticMethod<void(jlong)>("beginNativeMeasure")),
+        beginNativeFinalLayout_(bridgeClass_->getStaticMethod<void(jlong, jint, jint)>(
+            "beginNativeFinalLayout")),
+        endNativeMeasure_(
+            bridgeClass_->getStaticMethod<void()>("endNativeMeasure")) {}
+
+  void registerLease(SurfaceId surfaceId, Tag componentTag, uint64_t leaseHandle) const {
+    registerLease_(bridgeClass_, static_cast<jint>(surfaceId),
+                   static_cast<jint>(componentTag),
+                   static_cast<jlong>(leaseHandle));
+  }
+
+  void finalizeLease(SurfaceId surfaceId, Tag componentTag, uint64_t leaseHandle) const {
+    finalizeLease_(bridgeClass_, static_cast<jint>(surfaceId),
+                   static_cast<jint>(componentTag),
+                   static_cast<jlong>(leaseHandle));
+  }
+
+  void beginNativeMeasure(uint64_t leaseHandle) const {
+    beginNativeMeasure_(bridgeClass_, static_cast<jlong>(leaseHandle));
+  }
+
+  void beginNativeFinalLayout(
+      uint64_t leaseHandle,
+      int32_t contentOriginXPx,
+      int32_t contentOriginYPx) const {
+    beginNativeFinalLayout_(
+        bridgeClass_,
+        static_cast<jlong>(leaseHandle),
+        static_cast<jint>(contentOriginXPx),
+        static_cast<jint>(contentOriginYPx));
+  }
+
+  void endNativeMeasure() const {
+    endNativeMeasure_(bridgeClass_);
+  }
+
+ private:
+  facebook::jni::global_ref<facebook::jni::JClass> bridgeClass_;
+  facebook::jni::JStaticMethod<void(jint, jint, jlong)> registerLease_;
+  facebook::jni::JStaticMethod<void(jint, jint, jlong)> finalizeLease_;
+  facebook::jni::JStaticMethod<void(jlong)> beginNativeMeasure_;
+  facebook::jni::JStaticMethod<void(jlong, jint, jint)> beginNativeFinalLayout_;
+  facebook::jni::JStaticMethod<void()> endNativeMeasure_;
+};
+
+} // namespace
+
+void PreparedProseMeasurementsManager::bindLeaseLifecycle(
+    SurfaceId surfaceId,
+    Tag componentTag,
+    uint64_t leaseHandle,
+    const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& leaseLifecycle) const {
+  if (leaseHandle == 0 || !leaseLifecycle || !leaseLifecycle->isActive()) {
+    return;
+  }
+  // Yoga may run on a native worker rather than directly beneath a JNI entry
+  // point. ThreadScope gives the one-time class lookup an attached env and
+  // caches it for this native call without retaining the thread afterward.
+  if (!facebook::jni::Environment::isGlobalJvmAvailable()) {
+    return;
+  }
+  try {
+    facebook::jni::ThreadScope threadScope;
+    auto& bridge = AndroidLeaseLifecycleBridge::processLifetime();
+    bridge.registerLease(surfaceId, componentTag, leaseHandle);
+    leaseLifecycle->bindTerminalCleanup([surfaceId, componentTag, leaseHandle] {
+      // The class global is intentionally process-lifetime. Runtime-unavailable
+      // paths no-op; they never reset or destroy it without an attached env.
+      try {
+        if (!facebook::jni::Environment::isGlobalJvmAvailable()) {
+          return;
+        }
+        facebook::jni::ThreadScope threadScope;
+        try {
+          AndroidLeaseLifecycleBridge::processLifetime().finalizeLease(
+              surfaceId, componentTag, leaseHandle);
+        } catch (...) {
+          // The Java registry may already be gone during runtime teardown.
+        }
+      } catch (...) {
+        // A failed attach means VM teardown is already underway. The process
+        // lifetime bridge is deliberately left untouched.
+      }
+    });
+  } catch (...) {
+    // Runtime teardown may race a Yoga worker before it has an attached env.
+    // Do not bind a terminal Java callback from a partially destroyed VM.
+  }
+}
+
+Size PreparedProseMeasurementsManager::measure(
+    SurfaceId surfaceId,
+    Tag componentTag,
+    const PreparedProseViewerProps& props,
+    Float effectiveWidth,
+    Float /*pointScaleFactor*/,
+    uint64_t attachmentRevision,
+    uint64_t nativeFontRevision,
+    double nativeFontScale,
+    int32_t /*userInterfaceStyle*/,
+    int32_t /*accessibilityContrast*/,
+    uint64_t /*fontEnvironmentRevision*/,
+    uint64_t leaseHandle,
+    const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& /*leaseLifecycle*/) const {
+  // Every object allocation, class lookup, and Java invocation below can run
+  // from a Yoga worker.  It must live in this one attached scope; binding the
+  // lifecycle above is insufficient because its scope has already ended.
+  if (!facebook::jni::Environment::isGlobalJvmAvailable()) {
+    return {};
+  }
+  try {
+    facebook::jni::ThreadScope threadScope;
+    const auto& fabricUIManager =
+        contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
+    static auto measure = facebook::jni::findClassStatic(
+                              "com/facebook/react/fabric/FabricUIManager")
+                              ->getMethod<jlong(
+                                  jint,
+                                  jstring,
+                                  ReadableMap::javaobject,
+                                  ReadableMap::javaobject,
+                                  ReadableMap::javaobject,
+                                  jfloat,
+                                  jfloat,
+                                  jfloat,
+                                  jfloat)>("measure");
+    auto& leaseBridge = AndroidLeaseLifecycleBridge::processLifetime();
+    folly::dynamic localData = folly::dynamic::object
+        ("surfaceId", static_cast<int64_t>(surfaceId))
+        ("componentTag", static_cast<int64_t>(componentTag))
+        ("leaseHandle", std::to_string(static_cast<int64_t>(leaseHandle)));
+    auto propsDynamic = toDynamic(props);
+    auto stateDynamic = toState(
+        attachmentRevision,
+        nativeFontRevision,
+        nativeFontScale,
+        leaseHandle);
+    const auto localDataNative = ReadableNativeMap::newObjectCxxArgs(localData);
+    const auto propsNative = ReadableNativeMap::newObjectCxxArgs(propsDynamic);
+    const auto stateNative = ReadableNativeMap::newObjectCxxArgs(stateDynamic);
+    const auto localDataMap = make_local(reinterpret_cast<ReadableMap::javaobject>(localDataNative.get()));
+    const auto propsMap = make_local(reinterpret_cast<ReadableMap::javaobject>(propsNative.get()));
+    const auto stateMap = make_local(reinterpret_cast<ReadableMap::javaobject>(stateNative.get()));
+    const auto componentName = make_jstring("PreparedProseViewer");
+    const auto width = effectiveWidth;
+    leaseBridge.beginNativeMeasure(leaseHandle);
+    try {
+      const auto result = yogaMeassureToSize(measure(
+          fabricUIManager,
+          surfaceId,
+          componentName.get(),
+          localDataMap.get(),
+          propsMap.get(),
+          stateMap.get(),
+          0,
+          width,
+          0,
+          std::numeric_limits<Float>::infinity()));
+      leaseBridge.endNativeMeasure();
+      return result;
+    } catch (...) {
+      // Still inside ThreadScope, so this is the only safe place to clear the
+      // Java thread-local handoff after FabricUIManager.measure throws.
+      leaseBridge.endNativeMeasure();
+      return {};
+    }
+  } catch (...) {
+    // JVM shutdown and failed attach are terminal for this synchronous Yoga
+    // pass.  Returning an empty size is safe; never use a potentially
+    // destroyed JNIEnv to try to balance the Java thread-local callback.
+    return {};
+  }
+}
+
+void PreparedProseMeasurementsManager::prepareFinalLayout(
+    SurfaceId surfaceId,
+    Tag componentTag,
+    const PreparedProseViewerProps& props,
+    int32_t contentWidthPx,
+    int32_t contentOriginXPx,
+    int32_t contentOriginYPx,
+    Float /*pointScaleFactor*/,
+    uint64_t attachmentRevision,
+    uint64_t nativeFontRevision,
+    double nativeFontScale,
+    int32_t /*userInterfaceStyle*/,
+    int32_t /*accessibilityContrast*/,
+    uint64_t /*fontEnvironmentRevision*/,
+    uint64_t leaseHandle,
+    const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& /*leaseLifecycle*/) const {
+  if (!facebook::jni::Environment::isGlobalJvmAvailable() ||
+      leaseHandle == 0) {
+    return;
+  }
+  try {
+    facebook::jni::ThreadScope threadScope;
+    const auto& fabricUIManager =
+        contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
+    static auto measure = facebook::jni::findClassStatic(
+                              "com/facebook/react/fabric/FabricUIManager")
+                              ->getMethod<jlong(
+                                  jint,
+                                  jstring,
+                                  ReadableMap::javaobject,
+                                  ReadableMap::javaobject,
+                                  ReadableMap::javaobject,
+                                  jfloat,
+                                  jfloat,
+                                  jfloat,
+                                  jfloat)>("measure");
+    folly::dynamic localData = folly::dynamic::object
+        ("surfaceId", static_cast<int64_t>(surfaceId))
+        ("componentTag", static_cast<int64_t>(componentTag))
+        ("leaseHandle", std::to_string(static_cast<int64_t>(leaseHandle)));
+    auto propsDynamic = toDynamic(props);
+    auto stateDynamic = toState(
+        attachmentRevision,
+        nativeFontRevision,
+        nativeFontScale,
+        leaseHandle);
+    const auto localDataNative = ReadableNativeMap::newObjectCxxArgs(localData);
+    const auto propsNative = ReadableNativeMap::newObjectCxxArgs(propsDynamic);
+    const auto stateNative = ReadableNativeMap::newObjectCxxArgs(stateDynamic);
+    const auto localDataMap = make_local(
+        reinterpret_cast<ReadableMap::javaobject>(localDataNative.get()));
+    const auto propsMap = make_local(
+        reinterpret_cast<ReadableMap::javaobject>(propsNative.get()));
+    const auto stateMap = make_local(
+        reinterpret_cast<ReadableMap::javaobject>(stateNative.get()));
+    const auto componentName = make_jstring("PreparedProseViewer");
+    auto& leaseBridge = AndroidLeaseLifecycleBridge::processLifetime();
+    leaseBridge.beginNativeFinalLayout(
+        leaseHandle, contentOriginXPx, contentOriginYPx);
+    try {
+      measure(
+          fabricUIManager,
+          surfaceId,
+          componentName.get(),
+          localDataMap.get(),
+          propsMap.get(),
+          stateMap.get(),
+          static_cast<jfloat>(contentWidthPx),
+          static_cast<jfloat>(contentWidthPx),
+          0,
+          std::numeric_limits<Float>::infinity());
+      leaseBridge.endNativeMeasure();
+    } catch (...) {
+      leaseBridge.endNativeMeasure();
+    }
+  } catch (...) {
+  }
+}
+
+} // namespace facebook::react

package/android/src/main/jni/ReactNativeProseEditorSpec.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include <react/renderer/components/PreparedProseViewer/PreparedProseViewerComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> ReactNativeProseEditorSpec_ModuleProvider(
+    const std::string &moduleName,
+    const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook

package/android/src/main/jni/reactnativeproseeditor.h

@@ -0,0 +1,6 @@
+#pragma once
+
+// Narrow Android-only include boundary for the prepared prose Fabric adapter.
+// Keeping this separate prevents generated React Native headers from leaking into
+// the renderer-neutral registry and Kotlin facade.
+#include <react/renderer/components/PreparedProseViewer/PreparedProseMeasurementsManager.h>

package/android/src/main/res/values/attrs.xml

@@ -0,0 +1,6 @@
+<resources>
+    <declare-styleable name="EditorSelectionHandles">
+        <attr name="android:textSelectHandleLeft" />
+        <attr name="android:textSelectHandleRight" />
+    </declare-styleable>
+</resources>

package/android/src/release/java/com/apollohg/editor/viewer/PreparedProseDrawInstrumentation.kt

@@ -0,0 +1,9 @@
+package com.apollohg.editor.viewer
+
+/**
+ * Release deliberately inlines only the drawing block. This keeps collector
+ * calls and instrumentation branches out of the release drawing hot path.
+ */
+internal inline fun recordPreparedProseDraw(draw: () -> Int) {
+    draw()
+}

package/app.plugin.js

@@ -0,0 +1,62 @@
+const path = require('path');
+const { createRequire } = require('module');
+
+const pkg = require('./package.json');
+
+const PACKAGING_EXCLUDES_PROPERTY = 'android.packagingOptions.excludes';
+const LEGACY_JNA_ABI_EXCLUDES = [
+  '**/armeabi/libjnidispatch.so',
+  '**/mips/libjnidispatch.so',
+  '**/mips64/libjnidispatch.so',
+];
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
+    }
+
+    const appRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    return appRequire('expo/config-plugins');
+  }
+}
+
+function mergeCommaList(value, additions) {
+  const values = (value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  return Array.from(new Set([...values, ...additions])).join(',');
+}
+
+function withReactNativeProseEditor(config) {
+  const { withGradleProperties } = requireExpoConfigPlugins();
+
+  return withGradleProperties(config, (config) => {
+    const existing = config.modResults.find(
+      (property) => property.type === 'property' && property.key === PACKAGING_EXCLUDES_PROPERTY
+    );
+    const value = mergeCommaList(existing && existing.value, LEGACY_JNA_ABI_EXCLUDES);
+
+    if (existing) {
+      existing.value = value;
+    } else {
+      config.modResults.push({
+        type: 'property',
+        key: PACKAGING_EXCLUDES_PROPERTY,
+        value,
+      });
+    }
+
+    return config;
+  });
+}
+
+module.exports = requireExpoConfigPlugins().createRunOncePlugin(
+  withReactNativeProseEditor,
+  pkg.name,
+  pkg.version
+);

package/common/cpp/react/renderer/components/PreparedProseViewer/PreparedProseMeasurementsManager.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include <react/renderer/components/ReactNativeProseEditorSpec/Props.h>
+#include <react/renderer/components/PreparedProseViewer/PreparedProseViewerState.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+class PreparedProseMeasurementsManager {
+ public:
+  explicit PreparedProseMeasurementsManager(
+      const std::shared_ptr<const ContextContainer>& contextContainer)
+      : contextContainer_(contextContainer) {}
+
+  Size measure(
+      SurfaceId surfaceId,
+      Tag componentTag,
+      const PreparedProseViewerProps& props,
+      Float effectiveWidth,
+      Float pointScaleFactor,
+      uint64_t attachmentRevision,
+      uint64_t nativeFontRevision,
+      double nativeFontScale,
+      int32_t userInterfaceStyle,
+      int32_t accessibilityContrast,
+      uint64_t fontEnvironmentRevision,
+      uint64_t leaseHandle,
+      const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& leaseLifecycle) const;
+
+  void prepareFinalLayout(
+      SurfaceId surfaceId,
+      Tag componentTag,
+      const PreparedProseViewerProps& props,
+      int32_t contentWidthPx,
+      int32_t contentOriginXPx,
+      int32_t contentOriginYPx,
+      Float pointScaleFactor,
+      uint64_t attachmentRevision,
+      uint64_t nativeFontRevision,
+      double nativeFontScale,
+      int32_t userInterfaceStyle,
+      int32_t accessibilityContrast,
+      uint64_t fontEnvironmentRevision,
+      uint64_t leaseHandle,
+      const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& leaseLifecycle) const;
+
+  void bindLeaseLifecycle(
+      SurfaceId surfaceId,
+      Tag componentTag,
+      uint64_t leaseHandle,
+      const std::shared_ptr<PreparedProseViewerLeaseLifecycle>& leaseLifecycle) const;
+
+ private:
+  const std::shared_ptr<const ContextContainer> contextContainer_;
+};
+
+} // namespace facebook::react

package/common/cpp/react/renderer/components/PreparedProseViewer/PreparedProseViewerComponentDescriptor.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "PreparedProseMeasurementsManager.h"
+#include "PreparedProseViewerShadowNode.h"
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class PreparedProseViewerComponentDescriptor final
+    : public ConcreteComponentDescriptor<PreparedProseViewerShadowNode> {
+ public:
+  PreparedProseViewerComponentDescriptor(
+      const ComponentDescriptorParameters& parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<PreparedProseMeasurementsManager>(
+            contextContainer_)) {}
+
+  void adopt(ShadowNode& shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto& preparedProseViewerShadowNode =
+        static_cast<PreparedProseViewerShadowNode&>(shadowNode);
+    preparedProseViewerShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+ private:
+  const std::shared_ptr<PreparedProseMeasurementsManager> measurementsManager_;
+};
+
+} // namespace facebook::react