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

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

@@ -0,0 +1,280 @@
+package com.apollohg.editor
+
+import android.graphics.Color
+import android.graphics.RectF
+import android.text.Layout
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.view.MotionEvent
+import com.apollohg.editor.EditorEditText.SelectedImageGeometry
+import kotlin.math.roundToInt
+
+internal fun EditorEditText.cancelPendingImageLoads() {
+    imageLoadGeneration += 1L
+    val handles = synchronized(imageLoadHandles) {
+        imageLoadHandles.toList().also { imageLoadHandles.clear() }
+    }
+    handles.forEach { it.cancel() }
+}
+
+internal fun EditorEditText.rebuildLatestRenderForImages(): Boolean {
+    val currentContent = text as? Spanned ?: return false
+    val imageSpans = currentContent.getSpans(
+        0,
+        currentContent.length,
+        BlockImageSpan::class.java
+    )
+    if (imageSpans.isEmpty()) return false
+
+    cancelPendingImageLoads()
+    val spannable = SpannableStringBuilder(currentContent)
+    imageSpans.forEach { span ->
+        val start = currentContent.getSpanStart(span)
+        val end = currentContent.getSpanEnd(span)
+        val flags = currentContent.getSpanFlags(span)
+        span.close()
+        spannable.removeSpan(span)
+        if (start >= 0 && end > start) {
+            spannable.setSpan(span.reloadedFor(this), start, end, flags)
+        }
+    }
+    applyFullRenderPreservingEditorState(spannable, restoreScrollAfterLayout = true)
+    requestLayout()
+    invalidate()
+    onContentSizeMayChange?.invoke()
+    onSelectionOrContentMayChange?.invoke()
+    return true
+}
+
+internal fun EditorEditText.hasRenderedImageSpans(): Boolean {
+    val content = text as? Spanned ?: return false
+    return content.getSpans(0, content.length, BlockImageSpan::class.java).isNotEmpty()
+}
+
+internal fun EditorEditText.selectedImageGeometryImpl(): SelectedImageGeometry? {
+    if (!imageResizingEnabled) return null
+    val spannable = text as? Spanned ?: return null
+    val selection = resolvedSelectedImageRange(spannable) ?: return null
+    val start = selection.start
+    val end = selection.end
+    val imageSpan = spannable
+        .getSpans(start, end, BlockImageSpan::class.java)
+        .firstOrNull() ?: return null
+    val spanStart = spannable.getSpanStart(imageSpan)
+    val spanEnd = spannable.getSpanEnd(imageSpan)
+    if (spanStart != start || spanEnd != end) return null
+
+    val textLayout = layout ?: return null
+    val currentText = text?.toString() ?: return null
+    val scalarPos = PositionBridge.utf16ToScalar(spanStart, currentText)
+    val docPos = v2Driver?.docPositionForScalar(scalarPos) ?: scalarPos
+    val line = textLayout.getLineForOffset(spanStart.coerceAtMost(maxOf(spannable.length - 1, 0)))
+    val rect = resolvedImageRect(textLayout, imageSpan, spanStart, spanEnd)
+    return SelectedImageGeometry(
+        docPos = docPos,
+        rect = rect
+    )
+}
+
+internal fun EditorEditText.resizeImageAtDocPosImpl(docPos: Int, widthPx: Float, heightPx: Float) {
+    if (!hasLiveEditor()) return
+    val density = resources.displayMetrics.density
+    val widthDp = maxOf(48, (widthPx / density).roundToInt())
+    val heightDp = maxOf(48, (heightPx / density).roundToInt())
+    onResizeImageAtDocPosForTesting?.let { callback ->
+        callback(docPos, widthDp, heightDp)
+        return
+    }
+    v2Driver?.let { driver ->
+        driver.resizeImageAtDocPos(docPos, widthDp, heightDp)?.let { applyUpdateJSON(it) }
+    }
+}
+
+internal fun EditorEditText.handleImageTap(event: MotionEvent): Boolean {
+    if (!imageResizingEnabled) {
+        pendingImageGesture = null
+        return false
+    }
+    when (event.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+            val hit = if (event.pointerCount == 1) imageSpanHitAt(event.x, event.y) else null
+            pendingImageGesture = hit?.let {
+                ImageGesture(
+                    target = it.span,
+                    pointerId = event.getPointerId(event.actionIndex),
+                    downX = event.x,
+                    downY = event.y
+                )
+            }
+            if (hit != null) requestFocus()
+            return hit != null
+        }
+
+        MotionEvent.ACTION_MOVE -> {
+            val gesture = pendingImageGesture ?: return false
+            if (
+                event.pointerCount != 1 ||
+                event.findPointerIndex(gesture.pointerId) < 0 ||
+                movedBeyondImageTouchSlop(gesture, event)
+            ) {
+                pendingImageGesture = null
+                return false
+            }
+            return true
+        }
+
+        MotionEvent.ACTION_POINTER_DOWN,
+        MotionEvent.ACTION_POINTER_UP,
+        MotionEvent.ACTION_CANCEL -> {
+            pendingImageGesture = null
+            return false
+        }
+
+        MotionEvent.ACTION_UP -> {
+            val gesture = pendingImageGesture
+            pendingImageGesture = null
+            if (
+                gesture == null ||
+                event.pointerCount != 1 ||
+                event.getPointerId(event.actionIndex) != gesture.pointerId ||
+                movedBeyondImageTouchSlop(gesture, event)
+            ) {
+                return false
+            }
+            val hit = imageSpanHitAt(event.x, event.y) ?: return false
+            if (hit.span !== gesture.target) return false
+            requestFocus()
+            selectExplicitImageRange(hit.start, hit.end)
+            performClick()
+            return true
+        }
+
+        else -> return false
+    }
+}
+
+internal fun EditorEditText.movedBeyondImageTouchSlop(
+    gesture: ImageGesture,
+    event: MotionEvent
+): Boolean {
+    val deltaX = event.x - gesture.downX
+    val deltaY = event.y - gesture.downY
+    return deltaX * deltaX + deltaY * deltaY > touchSlopPx * touchSlopPx
+}
+
+internal fun EditorEditText.imageSpanHitAt(x: Float, y: Float): ImageSpanHit? {
+    val spannable = text as? Spanned ?: return null
+    val textLayout = layout ?: return null
+    return imageSpanRectHit(spannable, textLayout, x + scrollX, y + scrollY)
+}
+
+internal fun EditorEditText.imageSpanRectHit(
+    spannable: Spanned,
+    textLayout: Layout,
+    x: Float,
+    y: Float
+): ImageSpanHit? {
+    val candidateSpans = spannable.getSpans(0, spannable.length, BlockImageSpan::class.java)
+    for (span in candidateSpans) {
+        val spanStart = spannable.getSpanStart(span)
+        val spanEnd = spannable.getSpanEnd(span)
+        if (spanStart < 0 || spanEnd <= spanStart) continue
+        val rect = resolvedImageRect(textLayout, span, spanStart, spanEnd)
+        if (rect.contains(x, y)) {
+            return ImageSpanHit(span, spanStart, spanEnd)
+        }
+    }
+    return null
+}
+
+internal fun EditorEditText.selectExplicitImageRange(start: Int, end: Int) {
+    explicitSelectedImageRange = ImageSelectionRange(start, end)
+    if (selectionStart == start && selectionEnd == end) {
+        onSelectionOrContentMayChange?.invoke()
+        return
+    }
+    setSelection(start, end)
+}
+
+internal fun EditorEditText.clearExplicitSelectedImageRange() {
+    if (explicitSelectedImageRange == null) return
+    explicitSelectedImageRange = null
+    onSelectionOrContentMayChange?.invoke()
+}
+
+internal fun EditorEditText.updateImageSelectionHighlightAppearance(
+    start: Int = selectionStart,
+    end: Int = selectionEnd,
+    focused: Boolean = isFocused
+) {
+    val content = text as? Spanned
+    val shouldSuppress = focused &&
+        imageResizingEnabled &&
+        content != null &&
+        isExactImageSpanRange(content, start, end)
+    if (shouldSuppress) {
+        if (suppressedImageSelectionHighlightColor == null) {
+            suppressedImageSelectionHighlightColor = highlightColor
+            highlightColor = Color.TRANSPARENT
+        }
+        return
+    }
+
+    val restoredColor = suppressedImageSelectionHighlightColor ?: return
+    suppressedImageSelectionHighlightColor = null
+    highlightColor = restoredColor
+}
+
+internal fun EditorEditText.resolvedSelectedImageRange(spannable: Spanned): ImageSelectionRange? {
+    explicitSelectedImageRange?.let { explicit ->
+        if (isExactImageSpanRange(spannable, explicit.start, explicit.end)) {
+            return explicit
+        }
+        explicitSelectedImageRange = null
+    }
+
+    val start = selectionStart
+    val end = selectionEnd
+    if (!isExactImageSpanRange(spannable, start, end)) return null
+    return ImageSelectionRange(start, end)
+}
+
+internal fun EditorEditText.isExactImageSpanRange(
+    spannable: Spanned,
+    start: Int,
+    end: Int
+): Boolean {
+    if (start < 0 || end != start + 1) return false
+    val imageSpan = spannable
+        .getSpans(start, end, BlockImageSpan::class.java)
+        .firstOrNull() ?: return false
+    return spannable.getSpanStart(imageSpan) == start && spannable.getSpanEnd(imageSpan) == end
+}
+
+internal fun EditorEditText.resolvedImageRect(
+    textLayout: Layout,
+    imageSpan: BlockImageSpan,
+    spanStart: Int,
+    spanEnd: Int
+): RectF {
+    (textLayout as? EditorDocumentLayout)?.imageBounds(imageSpan)?.let {
+        it.offset(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat())
+        return it
+    }
+    imageSpan.currentDrawRect()?.let { drawnRect ->
+        return drawnRect
+    }
+
+    val safeOffset = spanStart.coerceAtMost(maxOf((text?.length ?: 0) - 1, 0))
+    val line = textLayout.getLineForOffset(safeOffset)
+    val startHorizontal = textLayout.getPrimaryHorizontal(spanStart)
+    val endHorizontal = textLayout.getPrimaryHorizontal(spanEnd)
+    val (widthPx, heightPx) = imageSpan.currentSizePx()
+    val left = compoundPaddingLeft + minOf(startHorizontal, endHorizontal)
+    val right = compoundPaddingLeft + maxOf(
+        maxOf(startHorizontal, endHorizontal),
+        minOf(startHorizontal, endHorizontal) + widthPx
+    )
+    val top = extendedPaddingTop + textLayout.editorTextLineBottom(line) - heightPx
+    return RectF(left, top.toFloat(), right, top + heightPx.toFloat())
+}

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

@@ -0,0 +1,183 @@
+package com.apollohg.editor
+
+import android.content.Context
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.InputMethodManager
+
+internal fun EditorEditText.restartInputForEditorIfFocused(source: String) {
+    if (!hasFocus()) return
+    restartInputForEditor(source)
+}
+
+internal fun EditorEditText.restartInputForEditor(source: String = "explicit") {
+    recordImeTraceForTesting("restartInput", "source=$source")
+    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+    imm?.restartInput(this)
+    scheduleSelectionUpdateAfterRestartInput(source)
+}
+
+internal fun EditorEditText.scheduleSelectionUpdateAfterRestartInput(source: String) {
+    val generation = ++restartInputSelectionUpdateGeneration
+    post {
+        if (generation != restartInputSelectionUpdateGeneration) return@post
+        if (!hasFocus()) return@post
+        val start = selectionStart
+        val end = selectionEnd
+        if (start < 0 || end < 0) {
+            recordImeTraceForTesting(
+                "updateSelectionAfterRestartSkipped",
+                "source=$source reason=selection start=$start end=$end"
+            )
+            return@post
+        }
+        val mapper = imeTextCoordinateMapperForEditor() ?: return@post
+        val imeStart = mapper.rawToIme(start)
+        val imeEnd = mapper.rawToIme(end)
+        val editable = text
+        val rawComposingStart = editable?.let(BaseInputConnection::getComposingSpanStart) ?: -1
+        val rawComposingEnd = editable?.let(BaseInputConnection::getComposingSpanEnd) ?: -1
+        val imeComposingStart = if (rawComposingStart >= 0) {
+            mapper.rawToIme(rawComposingStart)
+        } else {
+            -1
+        }
+        val imeComposingEnd = if (rawComposingEnd >= 0) {
+            mapper.rawToIme(rawComposingEnd)
+        } else {
+            -1
+        }
+        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+        imm?.updateSelection(
+            this,
+            imeStart,
+            imeEnd,
+            imeComposingStart,
+            imeComposingEnd
+        )
+        recordImeTraceForTesting(
+            "updateSelectionAfterRestart",
+            "source=$source sel=$imeStart..$imeEnd"
+        )
+    }
+}
+
+internal fun EditorEditText.scheduleLineBoundaryInputRefreshForEditor(source: String) {
+    if (!hasFocus()) return
+    val generation = ++lineBoundaryInputRefreshGeneration
+    recordImeTraceForTesting(
+        "lineBoundaryInputRefreshScheduled",
+        "source=$source generation=$generation"
+    )
+    post {
+        if (generation != lineBoundaryInputRefreshGeneration) return@post
+        if (!hasFocus()) return@post
+        if (!isCursorAtRenderedLineStartForSentenceCaps()) {
+            recordImeTraceForTesting(
+                "lineBoundaryInputRefreshSkipped",
+                "source=$source reason=cursor"
+            )
+            return@post
+        }
+        restartInputForEditor("lineBoundary:$source")
+    }
+}
+
+internal fun EditorEditText.clearCompositionInvalidationForEditor() {
+    didInvalidateCompositionReplacementRange = false
+}
+
+internal fun EditorEditText.nextInputConnectionGenerationForEditor(): Long =
+    inputConnectionGeneration
+
+internal fun EditorEditText.isInputConnectionCurrentForEditorImpl(
+    boundEditorId: Long,
+    boundGeneration: Long
+): Boolean = editorId == boundEditorId &&
+    inputConnectionGeneration == boundGeneration &&
+    !isEditorDestroyedForInput()
+
+internal fun EditorEditText.invalidateInputConnectionsForEditor() {
+    inputConnectionGeneration += 1L
+    cachedImeTextCoordinateMapper = null
+    recordImeTraceForTesting("invalidateInputConnections", "nextGen=$inputConnectionGeneration")
+    activeInputConnection = null
+}
+
+internal fun EditorEditText.imeTextCoordinateMapperForEditorImpl(
+    boundGeneration: Long = inputConnectionGeneration
+): ImeTextCoordinateMapper? {
+    if (boundGeneration != inputConnectionGeneration) return null
+    val cached = cachedImeTextCoordinateMapper
+    if (
+        cached != null &&
+        cached.generation == boundGeneration &&
+        cachedImeTextCoordinateRevision == imeTextCoordinateRevision
+    ) {
+        return cached
+    }
+    return ImeTextCoordinateMapper.build(text ?: "", boundGeneration).also { mapper ->
+        cachedImeTextCoordinateMapper = mapper
+        cachedImeTextCoordinateRevision = imeTextCoordinateRevision
+    }
+}
+
+internal fun EditorEditText.invalidateImeTextCoordinateMapperForEditor() {
+    imeTextCoordinateRevision += 1L
+    cachedImeTextCoordinateMapper = null
+}
+
+internal fun EditorEditText.clearNativeComposingSpans() {
+    val editable = text ?: return
+    BaseInputConnection.removeComposingSpans(editable)
+    removeTransientComposingTextStyleSpans(editable)
+}
+
+internal fun EditorEditText.restoreAuthorizedTextIfNeededImpl() {
+    if (!hasLiveEditor()) return
+    if ((text?.toString() ?: "") == lastAuthorizedText) return
+    recordImeTraceForTesting(
+        "restoreAuthorizedText",
+        "authorizedLength=${lastAuthorizedText.length}"
+    )
+    val stateJSON = v2Driver?.currentStateJson() ?: return
+    applyUpdateJSON(stateJSON)
+}
+
+internal fun EditorEditText.discardTransientNativeInputForEditorRebindImpl() {
+    cancelExternalTextCompositionForLifecycleIfNeeded()
+    retireInputConnectionForEditor()
+    nativeTextMutationAfterBlurWindow = null
+    lastAllowedAtomCaretSelection = null
+    clearNativeTextMutationAdoptionSuppression()
+    clearImeTraceForTesting()
+}
+
+internal fun EditorEditText.discardTransientNativeInputForExternalRecoveryImpl() {
+    cancelExternalTextCompositionForLifecycleIfNeeded()
+    retireInputConnectionForEditor()
+    nativeTextMutationAfterBlurWindow = null
+    restoreAuthorizedTextIfNeeded()
+    suppressNativeTextMutationAdoptionForCurrentRevision()
+}
+
+internal fun EditorEditText.discardTransientNativeInputForReadOnly() {
+    discardTransientNativeInputForExternalRecovery()
+}
+
+internal fun EditorEditText.refreshInputConnectionAfterExternalTextReplacementIfNeeded(
+    enabled: Boolean,
+    previousVisibleText: String
+) {
+    if (!enabled || !hasFocus()) return
+    val currentVisibleText = text?.toString().orEmpty()
+    if (currentVisibleText == previousVisibleText) return
+    clearInputStateForExternalReplacementPreservingConnection()
+    restartInputForEditor("externalUpdate")
+}
+
+internal fun EditorEditText.clearInputStateForExternalReplacementPreservingConnection() {
+    activeInputConnection?.clearCompositionTrackingForEditor()
+    clearCompositionTrackingForEditor()
+    clearCompositionInvalidationForEditor()
+    clearNativeComposingSpans()
+}

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

@@ -0,0 +1,79 @@
+package com.apollohg.editor
+
+import com.apollohg.editor.EditorEditText.CommandPreparation
+import com.apollohg.editor.EditorEditText.ExternalEditorUpdatePreparation
+
+internal fun EditorEditText.prepareForExternalEditorUpdateImpl(): Boolean =
+    prepareExternalUpdateInternal().ready
+
+/**
+ * Performs external-update preflight while retaining a mutation snapshot
+ * for the caller that will apply it. This prevents a second state render
+ * after a composing commit has already produced and adopted one.
+ */
+internal fun EditorEditText.hasPendingCompositionForExternalRefreshImpl(): Boolean =
+    externalTextComposition != null || activeInputConnection?.hasPendingComposition() == true
+
+internal fun EditorEditText.prepareExternalUpdateWithResultImpl(): ExternalEditorUpdatePreparation {
+    externalUpdatePreparationCaptureDepth += 1
+    if (externalUpdatePreparationCaptureDepth == 1) {
+        capturedExternalUpdatePreparationJSON = null
+    }
+    return try {
+        val preparation = prepareExternalUpdateInternal()
+        ExternalEditorUpdatePreparation(
+            ready = preparation.ready,
+            adoptedUpdateJSON = capturedExternalUpdatePreparationJSON
+        )
+    } finally {
+        externalUpdatePreparationCaptureDepth -= 1
+        if (externalUpdatePreparationCaptureDepth == 0) {
+            capturedExternalUpdatePreparationJSON = null
+        }
+    }
+}
+
+internal fun EditorEditText.prepareExternalUpdateInternal(): ExternalEditorUpdatePreparation {
+    if (blockExternalEditorUpdatePreparationForTesting) {
+        return ExternalEditorUpdatePreparation(ready = false, adoptedUpdateJSON = null)
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) {
+        return ExternalEditorUpdatePreparation(ready = false, adoptedUpdateJSON = null)
+    }
+    if (!commitExternalTextCompositionForDocumentChangeIfNeeded()) {
+        return ExternalEditorUpdatePreparation(ready = false, adoptedUpdateJSON = null)
+    }
+    val inputConnection = activeInputConnection
+    if (inputConnection?.flushPendingCompositionForExternalMutation() == false) {
+        return ExternalEditorUpdatePreparation(ready = false, adoptedUpdateJSON = null)
+    }
+    return ExternalEditorUpdatePreparation(
+        ready = drainNativeTextMutationIfNeeded(
+            allowAfterBlur = true,
+            preserveInputConnectionForExternalUpdate = true
+        ),
+        adoptedUpdateJSON = null
+    )
+}
+
+internal fun EditorEditText.prepareForExternalEditorCommandImpl(): CommandPreparation {
+    if (blockExternalEditorCommandPreparationForTesting) {
+        return CommandPreparation(ready = false, updateJSON = null)
+    }
+    val previousAuthorizedText = lastAuthorizedText
+    val preflight = prepareForExternalEditorUpdateWithResult()
+    if (!preflight.ready) {
+        return CommandPreparation(ready = false, updateJSON = null)
+    }
+    if (preflight.adoptedUpdateJSON != null) {
+        return CommandPreparation(ready = true, updateJSON = preflight.adoptedUpdateJSON)
+    }
+    if (!hasLiveEditor() || lastAuthorizedText == previousAuthorizedText) {
+        return CommandPreparation(ready = true, updateJSON = null)
+    }
+    val commandStateJSON = v2Driver?.currentStateJson()
+    return CommandPreparation(
+        ready = true,
+        updateJSON = commandStateJSON
+    )
+}