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

package/android/src/main/java/com/apollohg/editor/NativeEditorViewRegistry.kt

@@ -0,0 +1,372 @@
+package com.apollohg.editor
+
+import android.os.Handler
+import android.os.Looper
+import java.lang.ref.WeakReference
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
+import org.json.JSONObject
+
+private const val DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS = 250L
+
+internal enum class NativeEditorDestroyReservationResult {
+    RESERVED,
+    ALREADY_IN_PROGRESS,
+    UNAVAILABLE
+}
+
+private class WeakNativeEditorExpoView private constructor(
+    val view: WeakReference<NativeEditorExpoView?>
+) {
+    constructor(view: NativeEditorExpoView) : this(WeakReference(view))
+
+    companion object {
+        fun cleared(): WeakNativeEditorExpoView =
+            WeakNativeEditorExpoView(WeakReference<NativeEditorExpoView?>(null))
+    }
+}
+
+internal object NativeEditorViewRegistry {
+    private data class CommandPreparationSnapshot(
+        val view: NativeEditorExpoView?,
+        val isDetached: Boolean,
+        val isDestroyed: Boolean
+    )
+
+    private val liveEditorIds = mutableSetOf<Long>()
+    private val viewsByEditorId = mutableMapOf<Long, MutableList<WeakNativeEditorExpoView>>()
+    private val inputViewsByEditorId =
+        mutableMapOf<Long, MutableList<WeakReference<EditorEditText>>>()
+    private val detachedEditorOwnersByEditorId = mutableMapOf<Long, WeakNativeEditorExpoView>()
+    private val destroyingEditorIds = mutableSetOf<Long>()
+    private val destroyReservationWasLive = mutableMapOf<Long, Boolean>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    @Volatile
+    internal var onFinalizeDestroyForTesting: ((Long) -> Unit)? = null
+
+    @Synchronized
+    fun markEditorCreated(editorId: Long) {
+        if (editorId == 0L) return
+        liveEditorIds.add(editorId)
+        destroyingEditorIds.remove(editorId)
+        destroyReservationWasLive.remove(editorId)
+    }
+
+    @Synchronized
+    fun register(editorId: Long, view: NativeEditorExpoView): Boolean {
+        if (editorId == 0L) return false
+        if (destroyingEditorIds.contains(editorId)) return false
+        val isKnownDetachedOwner = detachedEditorOwnersByEditorId[editorId]?.view?.get() === view
+        if (
+            !liveEditorIds.contains(editorId) &&
+            !isKnownDetachedOwner &&
+            !rustEditorExists(editorId)
+        ) {
+            return false
+        }
+        val views = viewsByEditorId.getOrPut(editorId) { mutableListOf() }
+        views.removeAll { it.view.get() == null || it.view.get() === view }
+        views += WeakNativeEditorExpoView(view)
+        detachedEditorOwnersByEditorId.remove(editorId)
+        return true
+    }
+
+    @Synchronized
+    fun unregister(
+        editorId: Long,
+        view: NativeEditorExpoView,
+        blockCommandsUntilRegistered: Boolean = false
+    ) {
+        if (editorId == 0L) return
+        val registeredViews = viewsByEditorId[editorId]
+        val wasRegistered = registeredViews?.any { it.view.get() === view } == true
+        registeredViews?.removeAll { it.view.get() == null || it.view.get() === view }
+        if (registeredViews?.isEmpty() == true) viewsByEditorId.remove(editorId)
+        if (blockCommandsUntilRegistered) {
+            detachedEditorOwnersByEditorId[editorId] = WeakNativeEditorExpoView(view)
+        } else {
+            val detachedOwner = detachedEditorOwnersByEditorId[editorId]?.view?.get()
+            if (wasRegistered || detachedOwner === view) {
+                detachedEditorOwnersByEditorId.remove(editorId)
+            }
+        }
+    }
+
+    @Synchronized
+    fun isDestroyed(editorId: Long): Boolean = destroyingEditorIds.contains(editorId)
+
+    @Synchronized
+    internal fun retainedDestroyedIdCountForTests(): Int = destroyingEditorIds.size
+
+    @Synchronized
+    internal fun forceDetachedOwnerClearedForTesting(editorId: Long) {
+        detachedEditorOwnersByEditorId[editorId] = WeakNativeEditorExpoView.cleared()
+    }
+
+    @Synchronized
+    internal fun forceRegisteredViewsClearedForTesting(editorId: Long) {
+        viewsByEditorId[editorId] = mutableListOf(WeakNativeEditorExpoView.cleared())
+    }
+
+    @Synchronized
+    internal fun boundViewReferenceCountForTests(editorId: Long): Int =
+        viewsByEditorId[editorId]?.size ?: 0
+
+    @Synchronized
+    private fun liveViewsFor(editorId: Long): List<NativeEditorExpoView> =
+        viewsByEditorId[editorId]?.mapNotNull { it.view.get() }.orEmpty()
+
+    fun rebaseAfterRemoteCommit(handle: String) {
+        val viewToken = EditorV2Registry.viewTokenForHandle(handle) ?: return
+        liveViewsFor(viewToken).forEach { view ->
+            if (view.markRemoteCommitRebaseScheduled(viewToken)) {
+                mainHandler.post { view.applyRemoteCommitRefresh(viewToken) }
+            }
+        }
+    }
+
+    @Synchronized
+    fun registerInputView(editorId: Long, view: EditorEditText) {
+        if (editorId == 0L || destroyingEditorIds.contains(editorId)) return
+        if (!liveEditorIds.contains(editorId) && !rustEditorExists(editorId)) return
+        val views = inputViewsByEditorId.getOrPut(editorId) { mutableListOf() }
+        views.removeAll { it.get() == null || it.get() === view }
+        views += WeakReference(view)
+    }
+
+    @Synchronized
+    fun acquireDestroyReservation(editorId: Long): NativeEditorDestroyReservationResult {
+        if (editorId == 0L) return NativeEditorDestroyReservationResult.UNAVAILABLE
+        if (destroyingEditorIds.contains(editorId)) {
+            return NativeEditorDestroyReservationResult.ALREADY_IN_PROGRESS
+        }
+        if (!liveEditorIds.contains(editorId) && !rustEditorExists(editorId)) {
+            return NativeEditorDestroyReservationResult.UNAVAILABLE
+        }
+        destroyingEditorIds.add(editorId)
+        destroyReservationWasLive[editorId] = liveEditorIds.remove(editorId)
+        return NativeEditorDestroyReservationResult.RESERVED
+    }
+
+    fun beginDestroy(editorId: Long): Boolean =
+        acquireDestroyReservation(editorId) == NativeEditorDestroyReservationResult.RESERVED
+
+    /** Undo an in-flight reservation after an FFI result that is retryable or malformed. */
+    @Synchronized
+    fun rollbackDestroy(editorId: Long) {
+        if (!destroyingEditorIds.remove(editorId)) return
+        if (destroyReservationWasLive.remove(editorId) == true) {
+            liveEditorIds.add(editorId)
+        }
+    }
+
+    fun invalidateDestroyedEditor(editorId: Long) {
+        if (!beginDestroy(editorId)) return
+        finalizeDestroy(editorId)
+    }
+
+    /**
+     * Finalize a reserved destroy. Off-main callers may time out while the
+     * main-thread invalidation is still queued, so completion is reported only
+     * after the reservation itself has been released.
+     */
+    fun finalizeDestroy(editorId: Long, onCompleted: (() -> Unit)? = null) {
+        val affectedViews = synchronized(this) {
+            if (!destroyingEditorIds.contains(editorId)) return@synchronized null
+            val views = listOfNotNull(
+                *viewsByEditorId.remove(editorId)
+                    .orEmpty()
+                    .mapNotNull { it.view.get() }
+                    .toTypedArray(),
+                detachedEditorOwnersByEditorId.remove(editorId)?.view?.get()
+            ).distinct()
+            val inputViews = inputViewsByEditorId.remove(editorId)
+                .orEmpty()
+                .mapNotNull { it.get() }
+                .distinct()
+            views to inputViews
+        }
+        if (affectedViews == null) {
+            onCompleted?.invoke()
+            return
+        }
+        fun releaseReservation() {
+            synchronized(this) {
+                destroyingEditorIds.remove(editorId)
+                destroyReservationWasLive.remove(editorId)
+            }
+            onCompleted?.invoke()
+        }
+        invokeDestroyTestingHook(onFinalizeDestroyForTesting, editorId)
+        if (affectedViews.first.isEmpty() && affectedViews.second.isEmpty()) {
+            releaseReservation()
+            return
+        }
+        val invalidate = Runnable {
+            try {
+                affectedViews.first.forEach { view ->
+                    view.handleEditorDestroyed(editorId)
+                }
+                affectedViews.second.forEach { view ->
+                    view.handleEditorDestroyedFromRegistry(editorId)
+                }
+            } finally {
+                releaseReservation()
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            invalidate.run()
+        } else {
+            val latch = CountDownLatch(1)
+            val posted = mainHandler.post {
+                try {
+                    invalidate.run()
+                } finally {
+                    latch.countDown()
+                }
+            }
+            if (!posted) {
+                releaseReservation()
+                return
+            }
+            try {
+                latch.await(DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+            } catch (_: InterruptedException) {
+                Thread.currentThread().interrupt()
+            } catch (_: Throwable) {
+                return
+            }
+        }
+    }
+
+    fun prepareForCommandJSON(editorId: Long): String {
+        val prepare = {
+            val snapshot = synchronized(this) {
+                val isDestroyed = destroyingEditorIds.contains(editorId)
+                if (isDestroyed) {
+                    return@synchronized CommandPreparationSnapshot(
+                        view = null,
+                        isDetached = false,
+                        isDestroyed = true
+                    )
+                }
+                val registeredViews = viewsByEditorId[editorId]
+                registeredViews?.removeAll { it.view.get() == null }
+                val candidate = registeredViews?.firstNotNullOfOrNull { it.view.get() }
+                if (registeredViews?.isEmpty() == true) {
+                    viewsByEditorId.remove(editorId)
+                }
+                val detachedOwner = detachedEditorOwnersByEditorId[editorId]?.view?.get()
+                val isDetached = if (detachedOwner == null) {
+                    detachedEditorOwnersByEditorId.remove(editorId)
+                    false
+                } else {
+                    true
+                }
+                val missingFromRust =
+                    !liveEditorIds.contains(editorId) &&
+                        candidate == null &&
+                        !isDetached &&
+                        !rustEditorExists(editorId)
+                CommandPreparationSnapshot(
+                    view = candidate,
+                    isDetached = isDetached,
+                    isDestroyed = missingFromRust
+                )
+            }
+            snapshot.view?.prepareForEditorCommandJSON()
+                ?: commandPreparationJSON(
+                    ready = !snapshot.isDetached && !snapshot.isDestroyed,
+                    blockedReason = if (snapshot.isDestroyed) {
+                        "destroyed"
+                    } else if (snapshot.isDetached) {
+                        "detached"
+                    } else {
+                        null
+                    }
+                )
+        }
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            return prepare()
+        }
+
+        val result =
+            AtomicReference(commandPreparationJSON(ready = false, blockedReason = "unknown"))
+        val state = AtomicInteger(PREFLIGHT_STATE_QUEUED)
+        val latch = CountDownLatch(1)
+        if (!mainHandler.post {
+                try {
+                    if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_RUNNING)) {
+                        result.set(prepare())
+                        state.set(PREFLIGHT_STATE_DONE)
+                    }
+                } finally {
+                    latch.countDown()
+                }
+            }
+        ) {
+            return commandPreparationJSON(ready = false, blockedReason = "unknown")
+        }
+        try {
+            if (!latch.await(DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+                if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_CANCELLED)) {
+                    return commandPreparationJSON(ready = false, blockedReason = "unknown")
+                }
+                if (state.get() == PREFLIGHT_STATE_RUNNING) {
+                    latch.await()
+                    return result.get()
+                }
+                return commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+        } catch (_: InterruptedException) {
+            var interrupted = true
+            if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_CANCELLED)) {
+                Thread.currentThread().interrupt()
+                return commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+            while (state.get() == PREFLIGHT_STATE_RUNNING) {
+                try {
+                    latch.await()
+                    break
+                } catch (_: InterruptedException) {
+                    interrupted = true
+                }
+            }
+            if (interrupted) {
+                Thread.currentThread().interrupt()
+            }
+            return if (state.get() == PREFLIGHT_STATE_DONE) {
+                result.get()
+            } else {
+                commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+        }
+        return result.get()
+    }
+
+    private fun rustEditorExists(viewToken: Long): Boolean =
+        EditorV2Registry.adapterForViewToken(viewToken) != null
+
+    fun commandPreparationJSON(
+        ready: Boolean,
+        updateJSON: String? = null,
+        blockedReason: String? = null
+    ): String = JSONObject().apply {
+        put("ready", ready)
+        if (updateJSON != null) {
+            put("updateJSON", updateJSON)
+        }
+        if (!ready && blockedReason != null) {
+            put("blockedReason", blockedReason)
+        }
+    }.toString()
+
+    private const val PREFLIGHT_STATE_QUEUED = 0
+    private const val PREFLIGHT_STATE_RUNNING = 1
+    private const val PREFLIGHT_STATE_CANCELLED = 2
+    private const val PREFLIGHT_STATE_DONE = 3
+}

package/android/src/main/java/com/apollohg/editor/NativeImagePipeline.kt

@@ -0,0 +1,22 @@
+package com.apollohg.editor
+
+/**
+ * Neutral editor/viewer facade over the shared bounded image loader.
+ * Keep viewer code out of the editor render bridge's dependency graph.
+ */
+internal object NativeImagePipeline {
+    fun prepare(source: String, policy: ImageLoadingPolicy): RenderImageLoader.PreparedSource? =
+        RenderImageLoader.prepare(source, policy)
+
+    fun load(
+        source: RenderImageLoader.PreparedSource,
+        ownerId: Long,
+        priority: DecodedBitmapPriority,
+        callback: (DecodedBitmapLease?) -> Unit
+    ): RenderImageLoader.LoadHandle = RenderImageLoader.loadLease(
+        source,
+        ownerId,
+        priority,
+        callback
+    )
+}

package/android/src/main/java/com/apollohg/editor/NativeToolbar.kt

@@ -0,0 +1,193 @@
+package com.apollohg.editor
+
+import kotlin.math.roundToInt
+import org.json.JSONObject
+
+internal fun physicalToolbarBorderWidth(widthDp: Float, density: Float): Int = when {
+    widthDp <= 0f -> 0
+    else -> maxOf(1, (widthDp * density).roundToInt())
+}
+
+internal data class NativeToolbarState(
+    val marks: Map<String, Boolean>,
+    val nodes: Map<String, Boolean>,
+    val commands: Map<String, Boolean>,
+    val allowedMarks: Set<String>,
+    val insertableNodes: Set<String>,
+    val canUndo: Boolean,
+    val canRedo: Boolean
+) {
+    companion object {
+        val empty = NativeToolbarState(
+            marks = emptyMap(),
+            nodes = emptyMap(),
+            commands = emptyMap(),
+            allowedMarks = emptySet(),
+            insertableNodes = emptySet(),
+            canUndo = false,
+            canRedo = false
+        )
+
+        fun fromUpdateJson(updateJson: String): NativeToolbarState? {
+            val root = try {
+                JSONObject(updateJson)
+            } catch (_: Exception) {
+                return null
+            }
+            val activeState = root.optJSONObject("activeState") ?: JSONObject()
+            val historyState = root.optJSONObject("historyState") ?: JSONObject()
+            return NativeToolbarState(
+                marks = boolMap(activeState.optJSONObject("marks")),
+                nodes = boolMap(activeState.optJSONObject("nodes")),
+                commands = boolMap(activeState.optJSONObject("commands")),
+                allowedMarks = stringSet(activeState.optJSONArray("allowedMarks")),
+                insertableNodes = stringSet(activeState.optJSONArray("insertableNodes")),
+                canUndo = historyState.optBoolean("canUndo", false),
+                canRedo = historyState.optBoolean("canRedo", false)
+            )
+        }
+
+        private fun boolMap(json: JSONObject?): Map<String, Boolean> {
+            json ?: return emptyMap()
+            val result = mutableMapOf<String, Boolean>()
+            val keys = json.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                result[key] = json.optBoolean(key, false)
+            }
+            return result
+        }
+
+        private fun stringSet(array: org.json.JSONArray?): Set<String> {
+            array ?: return emptySet()
+            val result = linkedSetOf<String>()
+            for (index in 0 until array.length()) {
+                array.optString(index, null)?.let { result.add(it) }
+            }
+            return result
+        }
+    }
+}
+
+internal enum class ToolbarCommand(val wireValue: String) {
+    INDENT_LIST("indentList"),
+    OUTDENT_LIST("outdentList"),
+    UNDO("undo"),
+    REDO("redo");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarCommand =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarCommand: $value")
+    }
+}
+
+internal object EditorNodeTypes {
+    fun listItemType(listType: String): String = when (listType) {
+        "bullet_list", "ordered_list" -> "list_item"
+        "task_list" -> "task_item"
+        "taskList" -> "taskItem"
+        else -> "listItem"
+    }
+
+    fun isHardBreak(nodeType: String?): Boolean =
+        nodeType == "hardBreak" || nodeType == "hard_break"
+
+    fun isHorizontalRule(nodeType: String?): Boolean =
+        nodeType == "horizontalRule" || nodeType == "horizontal_rule"
+
+    fun isListItem(nodeType: String): Boolean = nodeType == "listItem" || nodeType == "list_item" ||
+        nodeType == "taskItem" || nodeType == "task_item"
+
+    fun isListContainer(nodeType: String): Boolean =
+        nodeType == "bulletList" || nodeType == "bullet_list" ||
+            nodeType == "orderedList" || nodeType == "ordered_list" ||
+            nodeType == "taskList" || nodeType == "task_list"
+
+    fun preferredHardBreak(insertableNodes: Set<String>): String =
+        if (insertableNodes.contains("hard_break")) "hard_break" else "hardBreak"
+}
+
+internal enum class ToolbarListType(val wireValue: String) {
+    BULLET_LIST("bullet_list"),
+    ORDERED_LIST("ordered_list"),
+    CAMEL_CASE_BULLET_LIST("bulletList"),
+    CAMEL_CASE_ORDERED_LIST("orderedList");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarListType =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarListType: $value")
+    }
+}
+
+internal enum class ToolbarDefaultIconId(val wireValue: String) {
+    BOLD("bold"),
+    ITALIC("italic"),
+    UNDERLINE("underline"),
+    STRIKE("strike"),
+    LINK("link"),
+    IMAGE("image"),
+    H1("h1"),
+    H2("h2"),
+    H3("h3"),
+    H4("h4"),
+    H5("h5"),
+    H6("h6"),
+    BLOCKQUOTE("blockquote"),
+    BULLET_LIST("bulletList"),
+    ORDERED_LIST("orderedList"),
+    INDENT_LIST("indentList"),
+    OUTDENT_LIST("outdentList"),
+    LINE_BREAK("lineBreak"),
+    HORIZONTAL_RULE("horizontalRule"),
+    UNDO("undo"),
+    REDO("redo");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarDefaultIconId =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarDefaultIconId: $value")
+    }
+}
+
+internal enum class ToolbarItemKind(val wireValue: String) {
+    MARK("mark"),
+    HEADING("heading"),
+    BLOCKQUOTE("blockquote"),
+    LIST("list"),
+    COMMAND("command"),
+    NODE("node"),
+    ACTION("action"),
+    GROUP("group"),
+    SEPARATOR("separator");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarItemKind =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarItemKind: $value")
+    }
+}
+
+internal enum class ToolbarGroupPresentation(val wireValue: String) {
+    EXPAND("expand"),
+    MENU("menu");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarGroupPresentation =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarGroupPresentation: $value")
+    }
+}
+
+internal enum class ToolbarItemPlacement(val wireValue: String) {
+    START("start"),
+    SCROLL("scroll"),
+    END("end");
+
+    companion object {
+        fun fromWireValue(value: String): ToolbarItemPlacement =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException("Unknown ToolbarItemPlacement: $value")
+    }
+}