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

package/android/src/main/java/com/apollohg/editor/viewer/ViewerImagePipeline.kt

@@ -0,0 +1,460 @@
+package com.apollohg.editor.viewer
+
+import android.graphics.Rect
+import com.apollohg.editor.DecodedBitmapBudget
+import com.apollohg.editor.DecodedBitmapLease
+import com.apollohg.editor.DecodedBitmapPriority
+import com.apollohg.editor.ImageLoadingPolicy
+import com.apollohg.editor.NativeImagePipeline
+import com.apollohg.editor.RenderImageLoader
+import com.apollohg.editor.viewer.ViewerInline.Atom
+import org.json.JSONObject
+
+/** Immutable attachment geometry emitted by preparation; bitmap state is not part of an artifact. */
+internal data class ViewerImageAttachment(
+    val id: String,
+    val source: String,
+    val bounds: Rect,
+    val declaredSize: Pair<Int, Int>?,
+    /** Ordinal within the immutable prepared artifact; id is source-qualified cache identity. */
+    val ordinal: Int = -1
+) {
+    val hasDeclaredSize: Boolean get() = (declaredSize?.first ?: 0) > 0 &&
+        (declaredSize?.second ?: 0) > 0
+
+    companion object {
+        /** Compiler/admission ceiling; supports far more than the old 256 IDs. */
+        const val MAXIMUM_ADMITTED_ATTACHMENTS = 8_192
+        fun sourceAndDeclaredSize(block: ViewerBlock): Triple<String, String, Pair<Int, Int>?>? {
+            val atom =
+                block.inlines.filterIsInstance<Atom>().firstOrNull { it.nodeType == "image" }
+                    ?: return null
+            val attrs = runCatching { JSONObject(atom.attrsJson) }.getOrNull() ?: return null
+            val source = attrs.optString("src").takeIf(String::isNotEmpty) ?: return null
+            val width = attrs.optDouble("width", Double.NaN).takeIf {
+                it.isFinite() && it > 0
+            }?.toInt()
+            val height = attrs.optDouble("height", Double.NaN).takeIf {
+                it.isFinite() && it > 0
+            }?.toInt()
+            return Triple(
+                "${atom.docPos}:$source",
+                source,
+                if (width != null &&
+                    height != null
+                ) {
+                    width to height
+                } else {
+                    null
+                }
+            )
+        }
+    }
+}
+
+internal class ViewerImageIntrinsicStore(entryLimit: Int = 256) {
+    companion object {
+        val shared = ViewerImageIntrinsicStore()
+    }
+
+    private data class Entry(val size: Pair<Int, Int>, var access: Long)
+    private val lock = Any()
+    private var entryLimit = entryLimit.coerceAtLeast(1)
+    private val values = mutableMapOf<String, Entry>()
+    private var access = 0L
+
+    fun size(id: String): Pair<Int, Int>? {
+        val cached = synchronized(lock) {
+            values[id]?.also { entry ->
+                access += 1
+                entry.access = access
+            }?.size
+        }
+        // The global LRU is process-wide, but sidecar fallback must be the
+        // measurement owner's explicit local state. Never scan another host.
+        return cached
+            ?: FabricAttachmentSidecars.currentMeasurementState?.intrinsicSizeForSourceQualifiedId(
+                id
+            )
+    }
+
+    /** Test-only global-LRU inspection; [size] can consult its scoped owner. */
+    fun globalSize(id: String): Pair<Int, Int>? = synchronized(lock) { values[id]?.size }
+
+    /** Test-only seam for the actual process-global store, never a fixture-local LRU. */
+    internal fun clearAndSetEntryLimitForTesting(limit: Int = 256) = synchronized(lock) {
+        values.clear()
+        access = 0L
+        entryLimit = limit.coerceAtLeast(1)
+    }
+
+    fun store(id: String, size: Pair<Int, Int>) = synchronized(lock) {
+        if (size.first <= 0 || size.second <= 0) return@synchronized
+        access += 1
+        values[id] = Entry(size, access)
+        while (values.size > entryLimit) {
+            val oldest =
+                values.minWithOrNull(
+                    compareBy<Map.Entry<String, Entry>> {
+                        it.value.access
+                    }.thenBy { it.key }
+                )
+                    ?: break
+            values.remove(oldest.key)
+        }
+    }
+}
+
+/**
+ * Per-surface reflow-publication state. Compact ordinal metadata plus a
+ * bitset makes the global LRU an optimization; reset only for semantic
+ * replacement or recycle/teardown, never request cancellation.
+ */
+internal class ViewerAttachmentRevisionState {
+    companion object {
+        const val FIXED_RETAINED_BYTES = 160
+        const val COLLECTION_RETAINED_BYTES = 32
+    }
+    private val lock = Any()
+    private var publishedBits = ByteArray(0)
+    private var reportedErrorBits = ByteArray(0)
+    private var intrinsicWidths = IntArray(0)
+    private var intrinsicHeights = IntArray(0)
+    private var sourceQualifiedIds = arrayOfNulls<String>(0)
+    private var attachmentOrdinals = IntArray(0)
+    private var admittedAttachmentCount = 0
+    private var semanticGenerationIdentity: String? = null
+    var revision: Long = 0
+        private set
+
+    /** Exact mounted-sidecar state; immutable layout/cache bytes exclude this owner. */
+    val retainedPublicationBytesForTesting: Int get() = synchronized(lock) {
+        FIXED_RETAINED_BYTES +
+            COLLECTION_RETAINED_BYTES * 5 +
+            publishedBits.size + reportedErrorBits.size +
+            intrinsicWidths.size * Int.SIZE_BYTES +
+            intrinsicHeights.size * Int.SIZE_BYTES +
+            sourceQualifiedIds.size * Long.SIZE_BYTES +
+            attachmentOrdinals.size * Int.SIZE_BYTES +
+            sourceQualifiedIds.filterNotNull().sumOf { it.length * 2 } +
+            (semanticGenerationIdentity?.length ?: 0) * 2
+    }
+
+    /** Clears once for a true semantic replacement; revision-only reinstalls preserve state. */
+    fun beginSemanticGeneration(identity: String): Boolean {
+        val changed = synchronized(lock) {
+            if (semanticGenerationIdentity == identity) return@synchronized false
+            clearLocked()
+            semanticGenerationIdentity = identity
+            true
+        }
+        return changed
+    }
+
+    fun admit(attachmentCount: Int) {
+        val count = attachmentCount.coerceAtLeast(0)
+        synchronized(lock) {
+            if (admittedAttachmentCount == count) return@synchronized
+            admittedAttachmentCount = count
+            publishedBits = ByteArray((count + 7) / 8)
+            reportedErrorBits = ByteArray((count + 7) / 8)
+            intrinsicWidths = IntArray(count)
+            intrinsicHeights = IntArray(count)
+            sourceQualifiedIds = arrayOfNulls(count)
+            attachmentOrdinals = IntArray(count) { it }
+        }
+    }
+
+    fun reset() = synchronized(lock) {
+        clearLocked()
+        semanticGenerationIdentity = null
+    }
+
+    fun recordIntrinsicSize(
+        id: String,
+        ordinal: Int,
+        width: Int,
+        height: Int,
+        declaredSize: Pair<Int, Int>?
+    ): Boolean = synchronized(lock) {
+        if (declaredSize != null || width <= 0 || height <= 0 ||
+            ordinal !in 0 until admittedAttachmentCount
+        ) {
+            return@synchronized false
+        }
+        val byteIndex = ordinal / 8
+        val mask = 1 shl (ordinal % 8)
+        if ((publishedBits[byteIndex].toInt() and mask) != 0) return@synchronized false
+        publishedBits[byteIndex] = (publishedBits[byteIndex].toInt() or mask).toByte()
+        intrinsicWidths[ordinal] = width
+        intrinsicHeights[ordinal] = height
+        sourceQualifiedIds[ordinal] = id
+        ViewerImageIntrinsicStore.shared.store(id, width to height)
+        revision += 1
+        true
+    }
+
+    fun intrinsicSize(ordinal: Int): Pair<Int, Int>? = synchronized(lock) {
+        if (ordinal !in 0 until admittedAttachmentCount) return@synchronized null
+        val mask = 1 shl (ordinal % 8)
+        if ((publishedBits[ordinal / 8].toInt() and mask) == 0) {
+            null
+        } else {
+            intrinsicWidths[ordinal] to intrinsicHeights[ordinal]
+        }
+    }
+
+    fun recordResourceFailure(ordinal: Int): Boolean = synchronized(lock) {
+        if (ordinal !in 0 until admittedAttachmentCount) return@synchronized false
+        val byteIndex = ordinal / 8
+        val mask = 1 shl (ordinal % 8)
+        if ((reportedErrorBits[byteIndex].toInt() and mask) != 0) return@synchronized false
+        reportedErrorBits[byteIndex] = (reportedErrorBits[byteIndex].toInt() or mask).toByte()
+        true
+    }
+
+    fun intrinsicSizeForSourceQualifiedId(id: String): Pair<Int, Int>? = synchronized(lock) {
+        val index = sourceQualifiedIds.indexOfFirst { it == id }
+        if (index < 0) return@synchronized null
+        val ordinal = attachmentOrdinals[index]
+        val mask = 1 shl (ordinal % 8)
+        if ((publishedBits[ordinal / 8].toInt() and mask) == 0) {
+            null
+        } else {
+            intrinsicWidths[ordinal] to intrinsicHeights[ordinal]
+        }
+    }
+
+    private fun clearLocked() {
+        publishedBits = ByteArray(0)
+        reportedErrorBits = ByteArray(0)
+        intrinsicWidths = IntArray(0)
+        intrinsicHeights = IntArray(0)
+        sourceQualifiedIds = arrayOfNulls(0)
+        attachmentOrdinals = IntArray(0)
+        admittedAttachmentCount = 0
+        revision = 0
+    }
+}
+
+/**
+ * Viewport/generation facade over the editor's established bounded pipeline.
+ * `RenderImageLoader` remains the one owner of source admission, decode/fetch
+ * limits, byte-bounded cache, de-duplication, cancellation receipts and errors.
+ */
+internal class ViewerImagePipeline(
+    private val ownerId: Long = DecodedBitmapBudget.nextOwnerId(),
+    private val load: (
+        RenderImageLoader.PreparedSource,
+        Long,
+        DecodedBitmapPriority,
+        (DecodedBitmapLease?) -> Unit
+    ) -> RenderImageLoader.LoadHandle = { source, owner, priority, callback ->
+        NativeImagePipeline.load(source, owner, priority, callback)
+    }
+) {
+    companion object {
+        const val PREFETCH_MARGIN_PX = 480
+    }
+
+    private val lock = Any()
+    private var generation = ""
+    private var enabled = false
+    private var policy = ImageLoadingPolicy.DEFAULT
+    private val requested = mutableSetOf<String>()
+    private val requestPriorities = mutableMapOf<String, DecodedBitmapPriority>()
+    private val receipts = mutableMapOf<String, RenderImageLoader.LoadHandle>()
+    var requestCountForTesting: Int = 0
+        private set
+    var onPixels: ((ViewerImageAttachment, DecodedBitmapLease) -> Unit)? = null
+    var onPixelsReleased: ((Set<String>) -> Unit)? = null
+    var onIntrinsicMetadata: ((ViewerImageAttachment, Int, Int) -> Unit)? = null
+
+    /** Contains only the internal attachment token, never its source URL. */
+    var onResourceFailure: ((ViewerImageAttachment) -> Unit)? = null
+
+    fun begin(
+        generation: String,
+        imagesEnabled: Boolean,
+        policy: ImageLoadingPolicy = this.policy
+    ) {
+        val released = synchronized(lock) {
+            if (this.generation == generation && enabled == imagesEnabled &&
+                this.policy == policy
+            ) {
+                return@synchronized null
+            }
+            receipts.values.forEach(RenderImageLoader.LoadHandle::cancel)
+            receipts.clear()
+            requested.toSet().also {
+                requested.clear()
+                requestPriorities.clear()
+                requestCountForTesting = 0
+                this.generation = generation
+                this.enabled = imagesEnabled
+                this.policy = policy
+            }
+        } ?: return
+        DecodedBitmapBudget.shared().setOwnerPressureHandler(ownerId, ::releasePrefetchForPressure)
+        onPixelsReleased?.invoke(released)
+    }
+
+    fun cancel() {
+        val released = synchronized(lock) {
+            generation = ""
+            enabled = false
+            receipts.values.forEach(RenderImageLoader.LoadHandle::cancel)
+            receipts.clear()
+            requested.toSet().also {
+                requested.clear()
+                requestPriorities.clear()
+            }
+        }
+        DecodedBitmapBudget.shared().setOwnerPressureHandler(ownerId, null)
+        onPixelsReleased?.invoke(released)
+    }
+
+    fun acceptsCompletion(generation: String): Boolean = synchronized(lock) {
+        enabled && this.generation.isNotEmpty() && this.generation == generation
+    }
+
+    private fun acceptsCompletion(generation: String, id: String): Boolean = synchronized(lock) {
+        enabled && this.generation.isNotEmpty() && this.generation == generation && id in requested
+    }
+
+    fun updateVisibleRect(visible: Rect, attachments: List<ViewerImageAttachment>) {
+        val prefetched = if (visible.isEmpty) {
+            Rect()
+        } else {
+            Rect(visible).apply {
+                inset(-PREFETCH_MARGIN_PX, -PREFETCH_MARGIN_PX)
+            }
+        }
+        val eligibleIds = attachments.asSequence()
+            .filter {
+                it.ordinal >= 0 && it.source.isNotEmpty() &&
+                    Rect.intersects(it.bounds, prefetched)
+            }
+            .mapTo(mutableSetOf()) { it.id }
+        val visibleIds = attachments.asSequence()
+            .filter {
+                it.ordinal >= 0 && it.source.isNotEmpty() &&
+                    Rect.intersects(it.bounds, visible)
+            }
+            .mapTo(mutableSetOf()) { it.id }
+        val released = mutableSetOf<String>()
+        val start = synchronized(lock) {
+            if (!enabled || generation.isEmpty()) return
+            requested.filterTo(released) { it !in eligibleIds }
+            requested.filterTo(released) {
+                it in visibleIds && requestPriorities[it] == DecodedBitmapPriority.PREFETCH
+            }
+            released.forEach { id ->
+                requested.remove(id)
+                requestPriorities.remove(id)
+                receipts.remove(id)?.cancel()
+            }
+            attachments.asSequence()
+                .filter { it.id in eligibleIds && it.id !in requested }
+                .sortedBy { if (Rect.intersects(it.bounds, visible)) 0 else 1 }
+                .filter { requested.add(it.id) }
+                .toList()
+                .also { requestCountForTesting += it.size }
+                .map { attachment ->
+                    Triple(
+                        attachment,
+                        generation,
+                        if (Rect.intersects(attachment.bounds, visible)) {
+                            DecodedBitmapPriority.VISIBLE
+                        } else {
+                            DecodedBitmapPriority.PREFETCH
+                        }
+                    ).also { requestPriorities[attachment.id] = it.third }
+                }
+        }
+        if (released.isNotEmpty()) onPixelsReleased?.invoke(released)
+        start.forEach { (attachment, requestGeneration, priority) ->
+            if (!acceptsCompletion(requestGeneration, attachment.id)) return@forEach
+            val source = NativeImagePipeline.prepare(attachment.source, policy) ?: run {
+                reportFailure(attachment, requestGeneration)
+                return@forEach
+            }
+            PreparedProseInstrumentation.imageRequested()
+            val receipt = load(source, ownerId, priority) { lease ->
+                if (!acceptsCompletion(requestGeneration, attachment.id)) {
+                    lease?.close()
+                    return@load
+                }
+                val bitmap = lease?.bitmap
+                if (lease == null || bitmap == null || bitmap.width <= 0 || bitmap.height <= 0) {
+                    lease?.close()
+                    reportFailure(attachment, requestGeneration)
+                    return@load
+                }
+                PreparedProseInstrumentation.imageMetadataRead()
+                onIntrinsicMetadata?.invoke(attachment, bitmap.width, bitmap.height)
+                val delivered = synchronized(lock) {
+                    if (!enabled || generation != requestGeneration ||
+                        attachment.id !in requested
+                    ) {
+                        false
+                    } else {
+                        PreparedProseInstrumentation.imageDecoded()
+                        val callback = onPixels
+                        if (callback == null) {
+                            false
+                        } else {
+                            callback.invoke(attachment, lease)
+                            true
+                        }
+                    }
+                }
+                if (!delivered) {
+                    lease.close()
+                }
+            }
+            synchronized(lock) {
+                if (acceptsCompletion(requestGeneration) && attachment.id in requested) {
+                    receipts[attachment.id] = receipt
+                } else {
+                    receipt.cancel()
+                }
+            }
+            receipt.onFinished {
+                synchronized(lock) {
+                    if (receipts[attachment.id] === receipt) receipts.remove(attachment.id)
+                }
+            }
+        }
+    }
+
+    private fun releasePrefetchForPressure() {
+        val released = synchronized(lock) {
+            requestPriorities.asSequence()
+                .filter { it.value == DecodedBitmapPriority.PREFETCH }
+                .mapTo(mutableSetOf()) { it.key }
+                .also { ids ->
+                    ids.forEach { id ->
+                        requestPriorities.remove(id)
+                        requested.remove(id)
+                        receipts.remove(id)?.cancel()
+                    }
+                }
+        }
+        if (released.isNotEmpty()) onPixelsReleased?.invoke(released)
+    }
+
+    internal fun releasePrefetchForPressureForTesting() = releasePrefetchForPressure()
+
+    private fun reportFailure(attachment: ViewerImageAttachment, requestGeneration: String) {
+        val callback = synchronized(lock) {
+            if (!enabled || generation != requestGeneration) null else onResourceFailure
+        }
+        callback?.invoke(attachment)
+    }
+
+    internal fun reportFailureForTesting(attachment: ViewerImageAttachment) {
+        val current = synchronized(lock) { generation }
+        reportFailure(attachment, current)
+    }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,85 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL ReactNativeProseEditorSpec)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_COMMON_DIR ${LIB_ANDROID_DIR}/../common/cpp)
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS
+  ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
+  ${LIB_COMMON_DIR}/react/renderer/components/PreparedProseViewer/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS
+  ${LIB_ANDROID_GENERATED_JNI_DIR}/*.cpp
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED
+  ${LIB_CUSTOM_SRCS}
+  ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  .
+  ${LIB_COMMON_DIR}
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  fbjni
+  jsi
+  reactnative
+)
+
+# Available from React Native 0.81; retain compatibility with the 0.76 floor.
+if(COMMAND target_compile_reactnative_options)
+  target_compile_reactnative_options(${LIB_TARGET_NAME} PUBLIC)
+else()
+  # Match the React Native 0.76 application's C++ and Folly flags for
+  # codegen targets when the 0.81 helper is unavailable.
+  target_compile_options(
+    ${LIB_TARGET_NAME}
+    PUBLIC
+    -Wall
+    -Werror
+    -fexceptions
+    -frtti
+    -std=c++20
+    -DLOG_TAG=\"ReactNative\"
+    -DFOLLY_NO_CONFIG=1
+    -DFOLLY_HAVE_CLOCK_GETTIME=1
+    -DFOLLY_USE_LIBCPP=1
+    -DFOLLY_CFG_NO_COROUTINES=1
+    -DFOLLY_MOBILE=1
+    -DFOLLY_HAVE_RECVMMSG=1
+    -DFOLLY_HAVE_PTHREAD=1
+    -DFOLLY_HAVE_XSI_STRERROR_R=1
+  )
+  target_compile_definitions(
+    ${LIB_TARGET_NAME}
+    PUBLIC
+    RN_SERIALIZABLE_STATE
+  )
+endif()
+
+target_compile_options(
+  ${LIB_TARGET_NAME}
+  PRIVATE
+  -Wpedantic
+  -Wno-gnu-zero-variadic-macro-arguments
+  -Wno-dollar-in-identifier-extension
+)
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)