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

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

@@ -0,0 +1,191 @@
+package com.apollohg.editor
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.text.Selection
+import android.text.Spanned
+import android.view.KeyEvent
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.CompletionInfo
+import android.view.inputmethod.CorrectionInfo
+import android.view.inputmethod.InputConnection
+import android.view.inputmethod.InputConnectionWrapper
+
+internal fun EditorInputConnection.isCurrentInputSession(): Boolean =
+    !closedForInput && editorView.activeInputConnection === this &&
+        editorView.isInputConnectionCurrentForEditor(boundEditorId, boundGeneration)
+
+internal fun EditorInputConnection.currentMapper(): ImeTextCoordinateMapper? =
+    if (isCurrentInputSession()) {
+        editorView.imeTextCoordinateMapperForEditor(
+            boundMapperGeneration
+        )
+    } else {
+        null
+    }
+
+internal fun EditorInputConnection.imeTextSlice(
+    mapper: ImeTextCoordinateMapper,
+    start: Int,
+    end: Int,
+    flags: Int
+): CharSequence {
+    val slice = mapper.visibleText.subSequence(start, end)
+    return if ((flags and InputConnection.GET_TEXT_WITH_STYLES) != 0 && slice is Spanned) {
+        slice
+    } else {
+        slice.toString()
+    }
+}
+
+internal fun EditorInputConnection.rawRangeForIme(start: Int, end: Int): Pair<Int, Int>? {
+    val mapper = currentMapper() ?: return null
+    if (start == end) {
+        val raw = mapper.imeToRaw(start, ImeTextCoordinateMapper.Affinity.AFTER)
+        return raw to raw
+    }
+    return if (start < end) {
+        mapper.imeToRaw(start, ImeTextCoordinateMapper.Affinity.AFTER) to
+            mapper.imeToRaw(end, ImeTextCoordinateMapper.Affinity.BEFORE)
+    } else {
+        mapper.imeToRaw(start, ImeTextCoordinateMapper.Affinity.BEFORE) to
+            mapper.imeToRaw(end, ImeTextCoordinateMapper.Affinity.AFTER)
+    }
+}
+
+internal fun EditorInputConnection.nanosToMicros(nanos: Long): Long = nanos / 1_000L
+
+internal fun EditorInputConnection.isCurrentInputSessionFor(event: String): Boolean {
+    val isCurrent = isCurrentInputSession()
+    if (!isCurrent) {
+        editorView.recordImeTraceForTesting(
+            "${event}Ignored",
+            "reason=stale boundEditor=$boundEditorId boundGen=$boundGeneration"
+        )
+    }
+    return isCurrent
+}
+
+internal fun EditorInputConnection.refreshComposingTextFromEditable() {
+    val editable = editorView.text ?: return
+    val visibleReplacementText = editorView.composingTextFromVisibleReplacementForEditor()
+    if (visibleReplacementText != null) {
+        editorView.setComposingTextForEditor(
+            ImeTextCoordinateMapper.build(visibleReplacementText, boundMapperGeneration)
+                .visibleText
+                .toString()
+        )
+        return
+    }
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0 || start > end || end > editable.length) {
+        editorView.setComposingTextForEditor(null)
+        return
+    }
+    val mapper = currentMapper()
+    val composingText = if (mapper != null) {
+        mapper.visibleText.subSequence(
+            mapper.rawToIme(start),
+            mapper.rawToIme(end)
+        ).toString()
+    } else {
+        editable.subSequence(start, end).toString()
+    }
+    editorView.setComposingTextForEditor(composingText)
+}
+
+internal fun EditorInputConnection.deleteTransientTextAroundSelection(
+    beforeLength: Int,
+    afterLength: Int
+): Boolean {
+    val editable = editorView.text ?: return false
+    val rawStart = editorView.selectionStart
+    val rawEnd = editorView.selectionEnd
+    if (rawStart < 0 || rawEnd < 0) return false
+    val selectionStart = rawStart.coerceIn(0, editable.length)
+    val selectionEnd = rawEnd.coerceIn(0, editable.length)
+    val normalizedStart = minOf(selectionStart, selectionEnd)
+    val normalizedEnd = maxOf(selectionStart, selectionEnd)
+    val deleteStart: Int
+    val deleteEnd: Int
+    if (normalizedStart != normalizedEnd) {
+        deleteStart = normalizedStart
+        deleteEnd = normalizedEnd
+    } else {
+        deleteStart = maxOf(0, normalizedStart - beforeLength.coerceAtLeast(0))
+        deleteEnd = minOf(editable.length, normalizedEnd + afterLength.coerceAtLeast(0))
+    }
+    if (deleteStart >= deleteEnd) return false
+    val (snappedStart, snappedEnd) = PositionBridge.snapRangeToScalarBoundaries(
+        deleteStart,
+        deleteEnd,
+        editable.toString()
+    )
+    if (snappedStart >= snappedEnd) return false
+    editable.delete(snappedStart, snappedEnd)
+    Selection.setSelection(editable, snappedStart.coerceIn(0, editable.length))
+    return true
+}
+
+internal fun EditorInputConnection.deleteTransientTextAroundSelectionInCodePoints(
+    beforeLength: Int,
+    afterLength: Int
+): Boolean {
+    val currentText = editorView.text?.toString() ?: return false
+    val rawStart = editorView.selectionStart
+    val rawEnd = editorView.selectionEnd
+    if (rawStart < 0 || rawEnd < 0) return false
+    val selectionStart = rawStart.coerceIn(0, currentText.length)
+    val selectionEnd = rawEnd.coerceIn(0, currentText.length)
+    val normalizedStart = minOf(selectionStart, selectionEnd)
+    val normalizedEnd = maxOf(selectionStart, selectionEnd)
+    if (normalizedStart != normalizedEnd) {
+        return deleteTransientTextAroundSelection(0, 0)
+    }
+    val beforeUtf16Length = EditorInputConnection.codePointsToUtf16Length(
+        text = currentText,
+        fromUtf16Offset = normalizedStart,
+        codePointCount = beforeLength,
+        forward = false
+    )
+    val afterUtf16Length = EditorInputConnection.codePointsToUtf16Length(
+        text = currentText,
+        fromUtf16Offset = normalizedEnd,
+        codePointCount = afterLength,
+        forward = true
+    )
+    return deleteTransientTextAroundSelection(beforeUtf16Length, afterUtf16Length)
+}
+
+internal fun EditorInputConnection.currentComposingSpanText(): String? {
+    val editable = editorView.text ?: return null
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0 || start > end || end > editable.length) {
+        return null
+    }
+    return editable.subSequence(start, end).toString()
+}
+
+internal fun EditorInputConnection.currentComposingSpanRange(): Pair<Int, Int>? {
+    if (!editorView.isCurrentTextAuthorizedForEditor()) return null
+    val editable = editorView.text ?: return null
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0 || start > end || end > editable.length) {
+        return null
+    }
+    return editorView.authorizedUtf16Range(start, end)
+}
+
+internal fun EditorInputConnection.currentComposingSpanRawRange(): Pair<Int, Int>? {
+    val editable = editorView.text ?: return null
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0 || start > end || end > editable.length) {
+        return null
+    }
+    return start to end
+}

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

@@ -0,0 +1,107 @@
+package com.apollohg.editor
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.text.Selection
+import android.text.Spanned
+import android.view.KeyEvent
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.CompletionInfo
+import android.view.inputmethod.CorrectionInfo
+import android.view.inputmethod.InputConnection
+import android.view.inputmethod.InputConnectionWrapper
+
+internal data class PendingDuplicateCorrectionCommit(val text: String, val deadlineMs: Long)
+
+internal data class PendingCompositionCorrectionCommit(
+    val text: String,
+    val deadlineMs: Long,
+    val generation: Long
+)
+
+internal data class GeneratedCompositionAdjustment(
+    val leadingText: String,
+    val trailingText: String
+) {
+    fun sanitize(text: String): String {
+        var sanitized = text
+        if (leadingText.isNotEmpty() && sanitized.startsWith(leadingText)) {
+            sanitized = sanitized.substring(leadingText.length)
+        }
+        if (trailingText.isNotEmpty() && sanitized.endsWith(trailingText)) {
+            sanitized = sanitized.substring(0, sanitized.length - trailingText.length)
+        }
+        return sanitized
+    }
+}
+
+internal fun EditorInputConnection.rememberPendingDuplicateCorrectionCommit(text: String) {
+    pendingDuplicateCorrectionCommit = PendingDuplicateCorrectionCommit(
+        text = text,
+        deadlineMs =
+            SystemClock.uptimeMillis() + EditorInputConnection.DUPLICATE_CORRECTION_COMMIT_WINDOW_MS
+    )
+}
+
+internal fun EditorInputConnection.consumePendingDuplicateCorrectionCommitIfNeeded(
+    text: String?
+): Boolean {
+    val pending = pendingDuplicateCorrectionCommit ?: return false
+    pendingDuplicateCorrectionCommit = null
+    if (text == null) return false
+    if (SystemClock.uptimeMillis() > pending.deadlineMs) return false
+    return text == pending.text
+}
+
+internal fun EditorInputConnection.rememberPendingCompositionCorrectionCommit(text: String) {
+    val generation = ++pendingCompositionCorrectionGeneration
+    pendingCompositionCorrectionCommit = PendingCompositionCorrectionCommit(
+        text = text,
+        deadlineMs =
+            SystemClock.uptimeMillis() +
+                EditorInputConnection.DUPLICATE_CORRECTION_COMMIT_WINDOW_MS,
+        generation = generation
+    )
+    Handler(Looper.getMainLooper()).post {
+        val pending = pendingCompositionCorrectionCommit ?: return@post
+        if (pending.generation != generation) return@post
+        applyPendingCompositionCorrectionCommitIfNeeded("commitCorrectionDeferred")
+    }
+}
+
+internal fun EditorInputConnection.consumePendingCompositionCorrectionCommitIfNeeded(
+    text: String?,
+    newCursorPosition: Int
+): Boolean {
+    val pending = pendingCompositionCorrectionCommit ?: return false
+    if (SystemClock.uptimeMillis() > pending.deadlineMs) {
+        pendingCompositionCorrectionCommit = null
+        return false
+    }
+    if (text != pending.text) return false
+    pendingCompositionCorrectionCommit = null
+    pendingCompositionCorrectionGeneration += 1L
+    editorView.recordImeTraceForTesting(
+        "commitTextConsumesPendingCorrection",
+        "textLength=${text.length}"
+    )
+    commitTextToEditor(text, newCursorPosition)
+    return true
+}
+
+internal fun EditorInputConnection.applyPendingCompositionCorrectionCommitIfNeeded(
+    source: String
+): Boolean {
+    val pending = pendingCompositionCorrectionCommit ?: return false
+    pendingCompositionCorrectionCommit = null
+    pendingCompositionCorrectionGeneration += 1L
+    if (!isCurrentInputSessionFor("applyPendingCompositionCorrection")) return false
+    if (!editorView.isEditable || editorView.editorId == 0L) return false
+    editorView.recordImeTraceForTesting(
+        "applyPendingCompositionCorrection",
+        "source=$source textLength=${pending.text.length}"
+    )
+    commitTextToEditor(pending.text, 1)
+    return true
+}

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

@@ -0,0 +1,128 @@
+package com.apollohg.editor
+
+import android.graphics.Matrix
+import android.graphics.Rect
+import android.graphics.RectF
+import android.text.Layout
+import android.view.View
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.CursorAnchorInfo
+
+internal fun EditorEditText.buildSurfaceCursorAnchorInfo(): CursorAnchorInfo {
+    val mapper = imeTextCoordinateMapperForEditor()
+        ?: ImeTextCoordinateMapper.build(editableText, inputConnectionGeneration)
+    val raw = editableText
+    val layout = layout
+    val originX = totalPaddingLeft.toFloat() - scrollX
+    val originY = totalPaddingTop.toFloat() - scrollY
+    val start = selectionStart.coerceIn(0, raw.length)
+    val end = selectionEnd.coerceIn(0, raw.length)
+    val builder = CursorAnchorInfo.Builder()
+        .setMatrix(cursorScreenMatrix())
+        .setSelectionRange(mapper.rawToIme(start), mapper.rawToIme(end))
+    val visible = Rect()
+    getLocalVisibleRect(visible)
+    visible.offset(-scrollX, -scrollY)
+    fun flags(left: Float, top: Float, right: Float, bottom: Float, rtl: Boolean): Int {
+        val overlaps =
+            left <= visible.right && right >= visible.left && top < visible.bottom &&
+                bottom > visible.top
+        var result = if (overlaps) CursorAnchorInfo.FLAG_HAS_VISIBLE_REGION else 0
+        if (left < visible.left || right > visible.right || top < visible.top ||
+            bottom > visible.bottom ||
+            !overlaps
+        ) {
+            result = result or CursorAnchorInfo.FLAG_HAS_INVISIBLE_REGION
+        }
+        if (rtl) result = result or CursorAnchorInfo.FLAG_IS_RTL
+        return result
+    }
+    fun top(line: Int): Float =
+        originY + ((layout as? EditorDocumentLayout)?.textLineTop(line) ?: layout.getLineTop(line))
+    fun bottom(line: Int): Float = originY +
+        ((layout as? EditorDocumentLayout)?.textLineBottom(line) ?: layout.getLineBottom(line))
+    val line = layout.getLineForOffset(end)
+    val x = originX + layout.getPrimaryHorizontal(end)
+    val top = top(line)
+    val bottom = bottom(line)
+    builder.setInsertionMarkerLocation(
+        x,
+        top,
+        originY + layout.getLineBaseline(line),
+        bottom,
+        flags(x, top, x, bottom, layout.getParagraphDirection(line) == Layout.DIR_RIGHT_TO_LEFT)
+    )
+    val composingStart = BaseInputConnection.getComposingSpanStart(raw)
+    val composingEnd = BaseInputConnection.getComposingSpanEnd(raw)
+    if (composingStart >= 0 && composingEnd >= composingStart) {
+        val imeStart = mapper.rawToIme(composingStart)
+        val imeEnd = mapper.rawToIme(composingEnd)
+        builder.setComposingText(imeStart, mapper.visibleText.subSequence(imeStart, imeEnd))
+        var offset = imeStart
+        while (offset < imeEnd) {
+            val next = (
+                offset +
+                    Character.charCount(Character.codePointAt(mapper.visibleText, offset))
+                ).coerceAtMost(imeEnd)
+            val rawStart = mapper.imeToRaw(offset, ImeTextCoordinateMapper.Affinity.AFTER)
+            val rawEnd = mapper.imeToRaw(next, ImeTextCoordinateMapper.Affinity.BEFORE)
+            val characterLine = layout.getLineForOffset(rawStart)
+            val leading = originX + layout.getPrimaryHorizontal(rawStart)
+            val trailing =
+                originX +
+                    if (layout.getLineForOffset(rawEnd) ==
+                        characterLine
+                    ) {
+                        layout.getPrimaryHorizontal(rawEnd)
+                    } else {
+                        layout.getLineRight(characterLine)
+                    }
+            val bounds =
+                RectF(
+                    minOf(leading, trailing),
+                    top(characterLine),
+                    maxOf(leading, trailing),
+                    bottom(characterLine)
+                )
+            val characterFlags =
+                flags(
+                    bounds.left,
+                    bounds.top,
+                    bounds.right,
+                    bounds.bottom,
+                    layout.isRtlCharAt(rawStart)
+                )
+            for (unit in offset until next) {
+                builder.addCharacterBounds(
+                    unit,
+                    bounds.left,
+                    bounds.top,
+                    bounds.right,
+                    bounds.bottom,
+                    characterFlags
+                )
+            }
+            offset = next
+        }
+    }
+    return builder.build()
+}
+
+private fun View.cursorScreenMatrix(): Matrix {
+    val result = Matrix()
+    fun append(view: View) {
+        (view.parent as? View)?.let { parent ->
+            append(parent)
+            result.preTranslate(-parent.scrollX.toFloat(), -parent.scrollY.toFloat())
+        }
+        result.preTranslate(view.left.toFloat(), view.top.toFloat())
+        result.preConcat(view.matrix)
+    }
+    append(this)
+    val origin = floatArrayOf(0f, 0f)
+    result.mapPoints(origin)
+    val screen = IntArray(2)
+    getLocationOnScreen(screen)
+    result.postTranslate(screen[0] - origin[0], screen[1] - origin[1])
+    return result
+}

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

@@ -0,0 +1,134 @@
+package com.apollohg.editor
+
+import android.content.Context
+import android.text.TextUtils
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.ExtractedText
+import android.view.inputmethod.ExtractedTextRequest
+import android.view.inputmethod.InputConnection
+import android.view.inputmethod.InputMethodManager
+import android.view.inputmethod.SurroundingText
+import android.view.inputmethod.TextSnapshot
+import androidx.annotation.RequiresApi
+
+internal fun EditorInputConnection.extractedTextForIme(
+    request: ExtractedTextRequest?,
+    flags: Int
+): ExtractedText? {
+    val mapper = currentMapper() ?: return null
+    if (request != null && flags and InputConnection.GET_EXTRACTED_TEXT_MONITOR != 0) {
+        extractedTextRequest = ExtractedTextRequest().apply {
+            token = request.token
+            this.flags = request.flags
+            hintMaxLines = request.hintMaxLines
+            hintMaxChars = request.hintMaxChars
+        }
+    }
+    return buildExtractedText(mapper, request?.flags ?: 0).also {
+        if (flags and InputConnection.GET_EXTRACTED_TEXT_MONITOR !=
+            0
+        ) {
+            lastPublishedExtractedText = it
+        }
+    }
+}
+
+private fun EditorInputConnection.buildExtractedText(
+    mapper: ImeTextCoordinateMapper,
+    flags: Int
+): ExtractedText = ExtractedText().apply {
+    text = imeTextSlice(mapper, 0, mapper.visibleText.length, flags)
+    startOffset = 0
+    partialStartOffset = -1
+    partialEndOffset = -1
+    selectionStart = mapper.rawToIme(editorView.selectionStart.coerceAtLeast(0))
+    selectionEnd = mapper.rawToIme(editorView.selectionEnd.coerceAtLeast(0))
+    this.flags =
+        if (editorView.inputType and android.text.InputType.TYPE_TEXT_FLAG_MULTI_LINE ==
+            0
+        ) {
+            ExtractedText.FLAG_SINGLE_LINE
+        } else {
+            0
+        }
+}
+
+@RequiresApi(31)
+internal fun EditorInputConnection.surroundingTextForIme(
+    beforeLength: Int,
+    afterLength: Int,
+    flags: Int
+): SurroundingText? {
+    if (beforeLength < 0 || afterLength < 0) return null
+    val mapper = currentMapper() ?: return null
+    if (editorView.selectionStart < 0 || editorView.selectionEnd < 0) return null
+    val from = mapper.rawToIme(minOf(editorView.selectionStart, editorView.selectionEnd))
+    val to = mapper.rawToIme(maxOf(editorView.selectionStart, editorView.selectionEnd))
+    val start = (from.toLong() - beforeLength).coerceAtLeast(0).toInt()
+    val end = (to.toLong() + afterLength).coerceAtMost(mapper.visibleText.length.toLong()).toInt()
+    return SurroundingText(imeTextSlice(mapper, start, end, flags), from - start, to - start, start)
+}
+
+@RequiresApi(33)
+internal fun EditorInputConnection.snapshotForIme(): TextSnapshot? {
+    val surrounding =
+        surroundingTextForIme(1024, 1024, InputConnection.GET_TEXT_WITH_STYLES) ?: return null
+    val mapper = currentMapper() ?: return null
+    val composing = composingSelectionForIme(mapper)
+    return TextSnapshot(
+        surrounding,
+        composing.first,
+        composing.second,
+        getCursorCapsMode(
+            TextUtils.CAP_MODE_CHARACTERS or TextUtils.CAP_MODE_WORDS or
+                TextUtils.CAP_MODE_SENTENCES
+        )
+    )
+}
+
+private fun EditorInputConnection.composingSelectionForIme(
+    mapper: ImeTextCoordinateMapper
+): Pair<Int, Int> {
+    val editable = editorView.editableText
+    val start = BaseInputConnection.getComposingSpanStart(editable)
+    val end = BaseInputConnection.getComposingSpanEnd(editable)
+    if (start < 0 || end < 0) return -1 to -1
+    return mapper.rawToIme(minOf(start, end)) to mapper.rawToIme(maxOf(start, end))
+}
+
+internal fun EditorInputConnection.publishInputStateIfNeeded() {
+    val mapper = currentMapper() ?: return
+    val composing = composingSelectionForIme(mapper)
+    val selection = listOf(
+        mapper.rawToIme(editorView.selectionStart.coerceAtLeast(0)),
+        mapper.rawToIme(editorView.selectionEnd.coerceAtLeast(0)),
+        composing.first,
+        composing.second
+    )
+    if (selection != lastPublishedSelection) {
+        lastPublishedSelection = selection
+        val manager = editorView.context.getSystemService(
+            Context.INPUT_METHOD_SERVICE
+        ) as? InputMethodManager
+        manager?.updateSelection(editorView, selection[0], selection[1], selection[2], selection[3])
+    }
+    publishExtractedTextIfNeeded()
+}
+
+internal fun EditorInputConnection.publishExtractedTextIfNeeded() {
+    val request = extractedTextRequest ?: return
+    val mapper = currentMapper() ?: return
+    val next = buildExtractedText(mapper, request.flags)
+    val previous = lastPublishedExtractedText
+    if (previous != null && previous.text == next.text &&
+        previous.selectionStart == next.selectionStart &&
+        previous.selectionEnd == next.selectionEnd && previous.flags == next.flags
+    ) {
+        return
+    }
+    lastPublishedExtractedText = next
+    val manager = editorView.context.getSystemService(
+        Context.INPUT_METHOD_SERVICE
+    ) as? InputMethodManager
+    manager?.updateExtractedText(editorView, request.token, next)
+}