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

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

@@ -0,0 +1,316 @@
+package com.apollohg.editor
+
+import android.os.Build
+import android.util.TypedValue
+
+/**
+ * Bind this EditText to a Rust editor instance and optionally apply initial content.
+ *
+ * @param id The editor session public ID.
+ * @param initialHTML Optional HTML to set as initial content.
+ */
+internal fun EditorEditText.bindEditorImpl(
+    id: Long,
+    initialHTML: String? = null,
+    notifyListener: Boolean = true
+) {
+    if (id != 0L && NativeEditorViewRegistry.isDestroyed(id)) {
+        discardTransientNativeInputForEditorRebind()
+        editorId = 0L
+        return
+    }
+    if (editorId != id) {
+        discardTransientNativeInputForEditorRebind()
+    }
+    editorId = id
+    v2Driver = EditorV2Registry.adapterForViewToken(id)
+    val driver = v2Driver
+    if (driver != null) {
+        if (!initialHTML.isNullOrEmpty()) {
+            driver.setContentHtml(initialHTML)?.let { applyUpdateJSON(it, notifyListener = false) }
+        } else {
+            driver.currentStateJson()?.let { applyUpdateJSON(it, notifyListener = notifyListener) }
+        }
+        return
+    }
+}
+
+/**
+ * Unbind from the current editor instance.
+ */
+internal fun EditorEditText.unbindEditorImpl() {
+    if (editorId != 0L) {
+        discardTransientNativeInputForEditorRebind()
+    }
+    editorId = 0
+    v2Driver = null
+}
+
+internal fun EditorEditText.handleEditorDestroyedFromRegistryImpl(destroyedEditorId: Long) {
+    if (editorId != destroyedEditorId) return
+    unbindEditor()
+}
+
+internal fun EditorEditText.setBaseStyleImpl(
+    fontSizePx: Float,
+    textColor: Int,
+    backgroundColor: Int
+) {
+    if (baseFontSize != fontSizePx || baseTextColor != textColor) {
+        renderAppearanceRevision += 1L
+    }
+    baseFontSize = fontSizePx
+    baseTextColor = textColor
+    baseBackgroundColor = backgroundColor
+    setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSizePx)
+    setTextColor(textColor)
+    setBackgroundColor(theme?.backgroundColor ?: backgroundColor)
+}
+
+internal fun EditorEditText.applyThemeImpl(theme: EditorTheme?) {
+    this.theme = theme
+    renderAppearanceRevision += 1L
+    setBackgroundColor(theme?.backgroundColor ?: baseBackgroundColor)
+    theme?.styleSheet?.let {
+        background =
+            EditorBoxDrawable(it.box("content").scaled(resources.displayMetrics.density))
+    }
+    applyContentInsets(theme?.contentInsets)
+    if (hasLiveEditor()) {
+        val previousScrollX = scrollX
+        val previousScrollY = scrollY
+        val stateJSON = v2Driver?.currentStateJson() ?: return
+        reuseImagesDuringThemeUpdate = true
+        try {
+            applyUpdateJSON(stateJSON, notifyListener = false)
+        } finally {
+            reuseImagesDuringThemeUpdate =
+                false
+        }
+        if (heightBehavior == EditorHeightBehavior.FIXED) {
+            preserveScrollPosition(previousScrollX, previousScrollY)
+        } else {
+            requestLayout()
+        }
+    } else {
+        standaloneRenderJSON?.let { json ->
+            reuseImagesDuringThemeUpdate = true
+            try {
+                val rendered = RenderBridge.buildSpannable(
+                    json,
+                    baseFontSize,
+                    baseTextColor,
+                    theme,
+                    resources.displayMetrics.density,
+                    this,
+                    atomRenderConfiguration
+                )
+                applyFullRenderPreservingEditorState(rendered)
+            } finally {
+                reuseImagesDuringThemeUpdate = false
+            }
+        }
+        requestLayout()
+        invalidate()
+    }
+}
+
+internal fun EditorEditText.applyAtomRenderConfigurationImpl(
+    configuration: AtomRenderConfiguration?
+): Boolean {
+    if (atomRenderConfiguration == configuration) return true
+    val stateJson = if (hasLiveEditor()) {
+        v2Driver?.currentStateJson() ?: return false
+    } else {
+        null
+    }
+    atomRenderConfiguration = configuration
+    renderAppearanceRevision += 1L
+
+    if (stateJson != null) {
+        val previousScrollX = scrollX
+        val previousScrollY = scrollY
+        applyUpdateJSON(stateJson, notifyListener = false)
+        if (heightBehavior == EditorHeightBehavior.FIXED) {
+            preserveScrollPosition(previousScrollX, previousScrollY)
+        } else {
+            requestLayout()
+        }
+        return true
+    }
+
+    val renderBlocks = currentRenderBlocksJson ?: return true
+    val spannable = RenderBridge.buildSpannableFromBlocks(
+        renderBlocks,
+        baseFontSize = baseFontSize,
+        textColor = baseTextColor,
+        theme = theme,
+        density = resources.displayMetrics.density,
+        hostView = this,
+        atomConfiguration = atomRenderConfiguration
+    )
+    applyFullRenderPreservingEditorState(spannable)
+    lastAppliedRenderAppearanceRevision = renderAppearanceRevision
+    onSelectionOrContentMayChange?.invoke()
+    requestLayout()
+    return true
+}
+
+internal fun EditorEditText.applyAtomHeightImpl(
+    atomKey: String,
+    heightPx: Int,
+    configuration: AtomRenderConfiguration?
+): Boolean {
+    atomRenderConfiguration = configuration
+    val content = text ?: return false
+    val span = content.getSpans(0, content.length, AtomBlockSpan::class.java)
+        .firstOrNull { it.atomKey == atomKey }
+        ?: return false
+    if (span.reservedHeightPx == heightPx) return false
+
+    val start = content.getSpanStart(span)
+    val end = content.getSpanEnd(span)
+    val flags = content.getSpanFlags(span)
+    if (start < 0 || end <= start) return false
+    span.reservedHeightPx = heightPx
+    content.removeSpan(span)
+    content.setSpan(span, start, end, flags)
+    atomHeightRenderApplyCount += 1
+    requestLayout()
+    invalidate()
+    onSelectionOrContentMayChange?.invoke()
+    return true
+}
+
+internal fun EditorEditText.atomHeightRenderApplyCountForTestingImpl(): Int =
+    atomHeightRenderApplyCount
+
+internal fun EditorEditText.setHeightBehaviorImpl(heightBehavior: EditorHeightBehavior) {
+    if (this.heightBehavior == heightBehavior) return
+    this.heightBehavior = heightBehavior
+    isVerticalScrollBarEnabled = heightBehavior == EditorHeightBehavior.FIXED
+    overScrollMode = if (heightBehavior == EditorHeightBehavior.FIXED) {
+        android.view.View.OVER_SCROLL_IF_CONTENT_SCROLLS
+    } else {
+        android.view.View.OVER_SCROLL_NEVER
+    }
+    updateEffectivePadding()
+    ensureSelectionVisible()
+    requestLayout()
+}
+
+internal fun EditorEditText.applyContentInsets(contentInsets: EditorContentInsets?) {
+    this.contentInsets = contentInsets
+    updateEffectivePadding()
+}
+
+internal fun EditorEditText.setViewportBottomInsetPxImpl(bottomInsetPx: Int) {
+    val clampedInset = bottomInsetPx.coerceAtLeast(0)
+    if (viewportBottomInsetPx == clampedInset) return
+    viewportBottomInsetPx = clampedInset
+    updateEffectivePadding()
+    ensureSelectionVisible()
+}
+
+internal fun EditorEditText.setViewportBottomOcclusionTopOnScreenPxImpl(topPx: Int?) {
+    if (viewportBottomOcclusionTopOnScreenPx == topPx) return
+    viewportBottomOcclusionTopOnScreenPx = topPx
+    ensureSelectionVisible()
+}
+
+internal fun EditorEditText.updateEffectivePadding() {
+    val density = resources.displayMetrics.density
+    val left = ((contentInsets?.left ?: 0f) * density).toInt()
+    val top = ((contentInsets?.top ?: 0f) * density).toInt()
+    val right = ((contentInsets?.right ?: 0f) * density).toInt()
+    val bottom = ((contentInsets?.bottom ?: 0f) * density).toInt()
+
+    if (heightBehavior == EditorHeightBehavior.FIXED && theme?.styleSheet == null) {
+        setPadding(left, 0, right, 0)
+        setCompoundDrawablesRelativeWithIntrinsicBounds(null, null, null, null)
+    } else {
+        setPadding(left, top, right, bottom)
+        setCompoundDrawablesRelativeWithIntrinsicBounds(null, null, null, null)
+    }
+}
+
+internal fun EditorEditText.setImageResizingEnabledImpl(enabled: Boolean) {
+    if (imageResizingEnabled == enabled) return
+    imageResizingEnabled = enabled
+    if (!enabled) {
+        clearExplicitSelectedImageRange()
+    } else {
+        onSelectionOrContentMayChange?.invoke()
+    }
+    updateImageSelectionHighlightAppearance()
+}
+
+internal fun EditorEditText.setImageLoadingPolicyJsonImpl(policyJson: String?) {
+    val nextPolicy = ImageLoadingPolicy.fromJson(policyJson)
+    if (nextPolicy == imageLoadingPolicy) return
+    imageLoadingPolicy = nextPolicy
+    if (!rebuildLatestRenderForImages()) cancelPendingImageLoads()
+}
+
+internal fun EditorEditText.currentImageLoadGenerationImpl(): Long = imageLoadGeneration
+
+internal fun EditorEditText.registerImageLoadImpl(handle: RenderImageLoader.LoadHandle) {
+    synchronized(imageLoadHandles) {
+        imageLoadHandles += handle
+    }
+    handle.onFinished {
+        synchronized(imageLoadHandles) {
+            imageLoadHandles.remove(handle)
+        }
+    }
+}
+
+internal fun EditorEditText.activeImageLoadHandleCountForTestingImpl(): Int =
+    synchronized(imageLoadHandles) {
+        imageLoadHandles.size
+    }
+
+internal fun EditorEditText.onImageSpanSizeMayChangeImpl(span: BlockImageSpan) {
+    val content = text ?: return
+    val start = content.getSpanStart(span)
+    val end = content.getSpanEnd(span)
+    val flags = content.getSpanFlags(span)
+    if (start < 0 || end <= start) return
+    content.removeSpan(span)
+    content.setSpan(span, start, end, flags)
+    requestLayout()
+    invalidate()
+    onContentSizeMayChange?.invoke()
+    onSelectionOrContentMayChange?.invoke()
+}
+
+internal fun EditorEditText.initializeEditorView() {
+    DecodedBitmapBudget.shared(context)
+    inputType = resolvedInputType()
+
+    // Disable built-in spell checking to avoid conflicts with Rust state.
+    // The Rust editor is the source of truth for text content.
+    isSaveEnabled = false
+
+    // Watch for unauthorized text mutations (IME, accessibility, etc.)
+    // and reconcile back to Rust's authoritative state.
+    addTextChangedListener(EditorReconciliationWatcher(this))
+    baseBackgroundColor = android.graphics.Color.WHITE
+    isVerticalScrollBarEnabled = true
+    overScrollMode = android.view.View.OVER_SCROLL_IF_CONTENT_SCROLLS
+
+    // Pin content to top-start to prevent theme-dependent vertical centering.
+    gravity = android.view.Gravity.TOP or android.view.Gravity.START
+
+    // Strip the default EditText theme drawable which carries implicit padding.
+    // Background color is applied in setBaseStyle() / applyTheme().
+    background = null
+    linksClickable = false
+
+    isCursorVisible = true
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        textCursorDrawable = EditorGlyphHeightCursorDrawable(this)
+    }
+
+    updateEffectivePadding()
+}

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

@@ -0,0 +1,303 @@
+package com.apollohg.editor
+
+internal fun EditorEditText.handleCompositionCommitImpl(
+    text: String,
+    replacementStartUtf16: Int,
+    replacementEndUtf16: Int,
+    newCursorPosition: Int = 1
+) {
+    val startedAt = System.nanoTime()
+    if (!isEditable) {
+        recordImeTraceForTesting(
+            "handleCompositionCommitNoop",
+            "reason=notEditable textLength=${text.length}"
+        )
+        return
+    }
+    if (isApplyingRustState) {
+        recordImeTraceForTesting(
+            "handleCompositionCommitNoop",
+            "reason=applyingRust textLength=${text.length}"
+        )
+        return
+    }
+    if (!hasLiveEditor()) {
+        recordImeTraceForTesting(
+            "handleCompositionCommitNoop",
+            "reason=noLiveEditor textLength=${text.length}"
+        )
+        return
+    }
+
+    val authorizedText = lastAuthorizedText
+    val (startUtf16, endUtf16) = PositionBridge.snapRangeToScalarBoundaries(
+        replacementStartUtf16,
+        replacementEndUtf16,
+        authorizedText
+    )
+    if (isCollapsedAtomBoundarySelection(startUtf16, endUtf16)) {
+        recordImeTraceForTesting(
+            "handleCompositionCommitNoop",
+            "reason=atomBoundary textLength=${text.length}"
+        )
+        return
+    }
+    val scalarStart = PositionBridge.utf16ToScalar(startUtf16, authorizedText)
+    val scalarEnd = PositionBridge.utf16ToScalar(endUtf16, authorizedText)
+
+    if (
+        startUtf16 <= endUtf16 &&
+        endUtf16 <= authorizedText.length &&
+        authorizedText.substring(startUtf16, endUtf16) == text
+    ) {
+        val requestedCursor = requestedCursorScalar(
+            scalarStart,
+            scalarEnd,
+            authorizedText,
+            text,
+            newCursorPosition
+        ) ?: scalarEnd
+        recordImeTraceForTesting(
+            "handleCompositionCommitNoop",
+            "reason=alreadyAuthorized textLength=${text.length} requestedCursor=$requestedCursor range=$startUtf16..$endUtf16"
+        )
+        restoreAuthorizedTextIfNeeded()
+        applyRequestedCursorScalar(requestedCursor)
+        return
+    }
+
+    if (text == "\n") {
+        recordImeTraceForTesting(
+            "handleCompositionCommit",
+            "route=return textLength=${text.length} utf16Range=$startUtf16..$endUtf16 scalarRange=$scalarStart..$scalarEnd"
+        )
+        if (scalarStart != scalarEnd) {
+            deleteAndSplitInRust(scalarStart, scalarEnd)
+        } else {
+            splitBlockInRust(scalarStart)
+        }
+        recordImeTraceForTesting(
+            "handleCompositionCommitDone",
+            "route=return totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+        )
+        return
+    }
+
+    val requestedCursor = requestedCursorScalar(
+        scalarStart,
+        scalarEnd,
+        authorizedText,
+        text,
+        newCursorPosition
+    )
+    recordImeTraceForTesting(
+        "handleCompositionCommit",
+        "textLength=${text.length} cursor=$newCursorPosition utf16Range=$startUtf16..$endUtf16 scalarRange=$scalarStart..$scalarEnd requestedCursor=$requestedCursor"
+    )
+    insertPlainTextRangeInRust(
+        scalarStart,
+        scalarEnd,
+        text,
+        requestedCursorScalar = requestedCursor
+    )
+    recordImeTraceForTesting(
+        "handleCompositionCommitDone",
+        "textLength=${text.length} totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
+    )
+}
+
+internal fun EditorEditText.handleCorrectionCommitImpl(
+    startUtf16: Int,
+    endUtf16: Int,
+    renderedOldText: String,
+    newText: String
+): Boolean {
+    if (!isEditable) return true
+    if (isApplyingRustState) return true
+    if (!hasLiveEditor()) return false
+
+    val authorizedText = lastAuthorizedText
+    if (startUtf16 < 0 || endUtf16 < startUtf16) {
+        recordImeTraceForTesting(
+            "correctionExplicitNoop",
+            "reason=invalidRange range=$startUtf16..$endUtf16 oldLength=${renderedOldText.length} newLength=${newText.length}"
+        )
+        return false
+    }
+    if (endUtf16 > authorizedText.length) {
+        recordImeTraceForTesting(
+            "correctionExplicitNoop",
+            "reason=outOfBounds range=$startUtf16..$endUtf16 authorizedLength=${authorizedText.length}"
+        )
+        return false
+    }
+    if (authorizedText.substring(startUtf16, endUtf16) != renderedOldText) {
+        recordImeTraceForTesting(
+            "correctionExplicitNoop",
+            "reason=staleText range=$startUtf16..$endUtf16 oldLength=${renderedOldText.length} newLength=${newText.length}"
+        )
+        return false
+    }
+
+    val (snappedStartUtf16, snappedEndUtf16) = PositionBridge.snapRangeToScalarBoundaries(
+        startUtf16,
+        endUtf16,
+        authorizedText
+    )
+    if (
+        snappedStartUtf16 != startUtf16 ||
+        snappedEndUtf16 != endUtf16 ||
+        snappedStartUtf16 > snappedEndUtf16
+    ) {
+        recordImeTraceForTesting(
+            "correctionExplicitNoop",
+            "reason=unsnappedScalarBoundary range=$startUtf16..$endUtf16 snapped=$snappedStartUtf16..$snappedEndUtf16"
+        )
+        return false
+    }
+
+    val scalarStart = PositionBridge.utf16ToScalar(snappedStartUtf16, authorizedText)
+    val scalarEnd = PositionBridge.utf16ToScalar(snappedEndUtf16, authorizedText)
+    recordImeTraceForTesting(
+        "correctionExplicitApply",
+        "range=$scalarStart..$scalarEnd newLength=${newText.length}"
+    )
+    insertPlainTextRangeInRust(scalarStart, scalarEnd, newText)
+    return true
+}
+
+internal fun EditorEditText.handleMissingOldTextCorrectionCommitImpl(
+    startUtf16: Int,
+    endUtf16: Int,
+    renderedOldText: String,
+    newText: String
+): Boolean {
+    if (!isEditable) return true
+    if (isApplyingRustState) return true
+    if (!hasLiveEditor()) return false
+
+    val authorizedText = lastAuthorizedText
+    if (
+        startUtf16 < 0 ||
+        endUtf16 <= startUtf16 ||
+        endUtf16 > authorizedText.length ||
+        authorizedText.substring(startUtf16, endUtf16) != renderedOldText
+    ) {
+        recordImeTraceForTesting(
+            "correctionInferredNoop",
+            "reason=staleRange range=$startUtf16..$endUtf16 newLength=${newText.length}"
+        )
+        return false
+    }
+
+    val (snappedStartUtf16, snappedEndUtf16) = PositionBridge.snapRangeToScalarBoundaries(
+        startUtf16,
+        endUtf16,
+        authorizedText
+    )
+    if (snappedStartUtf16 >= snappedEndUtf16) {
+        recordImeTraceForTesting(
+            "correctionInferredNoop",
+            "reason=emptySnappedRange token=$startUtf16..$endUtf16 snapped=$snappedStartUtf16..$snappedEndUtf16"
+        )
+        return false
+    }
+
+    val scalarStart = PositionBridge.utf16ToScalar(snappedStartUtf16, authorizedText)
+    val scalarEnd = PositionBridge.utf16ToScalar(snappedEndUtf16, authorizedText)
+    recordImeTraceForTesting(
+        "correctionInferredApply",
+        "range=$scalarStart..$scalarEnd utf16=$snappedStartUtf16..$snappedEndUtf16 newLength=${newText.length}"
+    )
+    insertPlainTextRangeInRust(scalarStart, scalarEnd, newText)
+    return true
+}
+
+internal fun EditorEditText.missingOldTextCorrectionTokenRangeForEditorImpl(
+    text: String,
+    offsetUtf16: Int
+): Pair<Int, Int>? {
+    if (offsetUtf16 < 0 || offsetUtf16 >= text.length) return null
+
+    val tokenOffset = PositionBridge.snapToScalarBoundary(
+        offsetUtf16,
+        text,
+        biasForward = false
+    )
+    if (tokenOffset < 0 || tokenOffset >= text.length) return null
+    if (!isMissingOldTextCorrectionTokenCodePointAt(text, tokenOffset)) return null
+
+    var startUtf16 = tokenOffset
+    while (startUtf16 > 0) {
+        val previousUtf16 = Character.offsetByCodePoints(text, startUtf16, -1)
+        if (!isMissingOldTextCorrectionTokenCodePointAt(text, previousUtf16)) break
+        startUtf16 = previousUtf16
+    }
+
+    var endUtf16 = tokenOffset + Character.charCount(Character.codePointAt(text, tokenOffset))
+    while (endUtf16 < text.length) {
+        if (!isMissingOldTextCorrectionTokenCodePointAt(text, endUtf16)) break
+        endUtf16 += Character.charCount(Character.codePointAt(text, endUtf16))
+    }
+
+    return if (startUtf16 < endUtf16) startUtf16 to endUtf16 else null
+}
+
+internal fun EditorEditText.isMissingOldTextCorrectionTokenCodePointAt(
+    text: String,
+    utf16Offset: Int
+): Boolean {
+    if (utf16Offset < 0 || utf16Offset >= text.length) return false
+    val codePoint = Character.codePointAt(text, utf16Offset)
+    if (isMissingOldTextCorrectionCoreTokenCodePoint(codePoint)) return true
+    if (!isMissingOldTextCorrectionJoinerCodePoint(codePoint)) return false
+
+    val previousCodePoint = previousCodePointBefore(text, utf16Offset) ?: return false
+    val nextUtf16Offset = utf16Offset + Character.charCount(codePoint)
+    val nextCodePoint = nextCodePointAt(text, nextUtf16Offset) ?: return false
+    return isMissingOldTextCorrectionCoreTokenCodePoint(previousCodePoint) &&
+        isMissingOldTextCorrectionCoreTokenCodePoint(nextCodePoint)
+}
+
+internal fun EditorEditText.isMissingOldTextCorrectionCoreTokenCodePoint(codePoint: Int): Boolean {
+    if (Character.isLetterOrDigit(codePoint)) return true
+    return when (Character.getType(codePoint)) {
+        Character.NON_SPACING_MARK.toInt(),
+        Character.COMBINING_SPACING_MARK.toInt(),
+        Character.ENCLOSING_MARK.toInt(),
+        Character.CONNECTOR_PUNCTUATION.toInt(),
+        Character.MATH_SYMBOL.toInt(),
+        Character.CURRENCY_SYMBOL.toInt(),
+        Character.MODIFIER_SYMBOL.toInt(),
+        Character.OTHER_SYMBOL.toInt(),
+        Character.SURROGATE.toInt() -> true
+
+        else -> false
+    }
+}
+
+internal fun EditorEditText.isMissingOldTextCorrectionJoinerCodePoint(codePoint: Int): Boolean =
+    codePoint == '\''.code ||
+        codePoint == 0x2018 ||
+        codePoint == 0x2019 ||
+        codePoint == 0x201B ||
+        codePoint == 0xFF07 ||
+        codePoint == '-'.code ||
+        codePoint == 0x2010 ||
+        codePoint == 0x2011 ||
+        codePoint == 0x2012 ||
+        codePoint == 0x2013 ||
+        codePoint == 0x2014 ||
+        codePoint == 0x2212 ||
+        codePoint == 0x200D
+
+internal fun EditorEditText.previousCodePointBefore(text: String, utf16Offset: Int): Int? {
+    if (utf16Offset <= 0 || utf16Offset > text.length) return null
+    val previousUtf16 = Character.offsetByCodePoints(text, utf16Offset, -1)
+    return Character.codePointAt(text, previousUtf16)
+}
+
+internal fun EditorEditText.nextCodePointAt(text: String, utf16Offset: Int): Int? {
+    if (utf16Offset < 0 || utf16Offset >= text.length) return null
+    return Character.codePointAt(text, utf16Offset)
+}