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

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

@@ -0,0 +1,243 @@
+package com.apollohg.editor
+
+import android.os.SystemClock
+import com.apollohg.editor.EditorEditText.Companion.NATIVE_TEXT_MUTATION_AFTER_BLUR_WINDOW_MS
+
+internal fun EditorEditText.nativeTextMutationFromAuthorizedDiff(
+    currentText: String
+): NativeTextMutation? {
+    val authorizedText = lastAuthorizedText
+    if (currentText == authorizedText) return null
+
+    var prefix = 0
+    val sharedLength = minOf(authorizedText.length, currentText.length)
+    while (
+        prefix < sharedLength &&
+        authorizedText[prefix] == currentText[prefix]
+    ) {
+        prefix++
+    }
+    prefix = minOf(
+        PositionBridge.snapToScalarBoundary(prefix, authorizedText, biasForward = false),
+        PositionBridge.snapToScalarBoundary(prefix, currentText, biasForward = false)
+    )
+
+    var authorizedEnd = authorizedText.length
+    var currentEnd = currentText.length
+    while (
+        authorizedEnd > prefix &&
+        currentEnd > prefix &&
+        authorizedText[authorizedEnd - 1] == currentText[currentEnd - 1]
+    ) {
+        authorizedEnd--
+        currentEnd--
+    }
+    authorizedEnd = PositionBridge.snapToScalarBoundary(
+        authorizedEnd,
+        authorizedText,
+        biasForward = true
+    )
+    currentEnd = PositionBridge.snapToScalarBoundary(
+        currentEnd,
+        currentText,
+        biasForward = true
+    )
+
+    val replacementText = currentText.substring(prefix, currentEnd)
+    val rawSelectionStart = selectionStart
+    val rawSelectionEnd = selectionEnd
+    val selectionAnchorUtf16 = rawSelectionStart
+        .takeIf { it >= 0 }
+        ?.let { PositionBridge.snapToScalarBoundary(it, currentText, biasForward = true) }
+    val selectionHeadUtf16 = rawSelectionEnd
+        .takeIf { it >= 0 }
+        ?.let { PositionBridge.snapToScalarBoundary(it, currentText, biasForward = true) }
+    return NativeTextMutation(
+        scalarFrom = PositionBridge.utf16ToScalar(prefix, authorizedText),
+        scalarTo = PositionBridge.utf16ToScalar(authorizedEnd, authorizedText),
+        replacementText = replacementText,
+        resultingText = currentText,
+        replacementStartUtf16 = prefix,
+        replacementEndUtf16 = currentEnd,
+        selectionScalarAnchor = selectionAnchorUtf16?.let {
+            PositionBridge.utf16ToScalar(it, currentText)
+        },
+        selectionScalarHead = selectionHeadUtf16?.let {
+            PositionBridge.utf16ToScalar(it, currentText)
+        }
+    )
+}
+
+internal fun EditorEditText.shouldAdoptNativeTextMutation(
+    mutation: NativeTextMutation,
+    allowAfterBlur: Boolean = false
+): Boolean {
+    if (!isEditable) return false
+    if (isNativeTextMutationAdoptionSuppressedForCurrentRevision()) return false
+    if (!hasFocus()) {
+        return allowAfterBlur &&
+            canAdoptNativeTextMutationAfterBlur() &&
+            shouldAdoptFinalNativeTextMutation(mutation)
+    }
+    return shouldAdoptFinalNativeTextMutation(mutation)
+}
+
+internal fun EditorEditText.shouldAdoptFinalNativeTextMutation(
+    mutation: NativeTextMutation
+): Boolean {
+    if (composingTextForEditor() != null) return false
+    val trackedRange = compositionReplacementRange() ?: return true
+    val authorizedText = lastAuthorizedText
+    val trackedStart = PositionBridge.utf16ToScalar(trackedRange.first, authorizedText)
+    val trackedEnd = PositionBridge.utf16ToScalar(trackedRange.second, authorizedText)
+    if (trackedStart == trackedEnd) {
+        return mutation.scalarFrom == trackedStart &&
+            mutation.scalarTo == trackedStart &&
+            mutation.replacementText.isNotEmpty()
+    }
+    if (mutation.scalarFrom == mutation.scalarTo) {
+        return mutation.replacementText.isNotEmpty() &&
+            mutation.scalarFrom >= trackedStart &&
+            mutation.scalarFrom <= trackedEnd
+    }
+    return mutation.scalarFrom < trackedEnd && mutation.scalarTo > trackedStart
+}
+
+internal fun EditorEditText.drainNativeTextMutationIfNeeded(
+    allowAfterBlur: Boolean,
+    preserveInputConnectionForExternalUpdate: Boolean = false
+): Boolean {
+    if (editorId == 0L) return true
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return false
+    val editable = text
+    val currentText = editable?.toString() ?: ""
+    if (currentText == lastAuthorizedText) return true
+
+    val mutation = nativeTextMutationFromAuthorizedDiff(currentText)
+    if (mutation != null && shouldAdoptNativeTextMutation(mutation, allowAfterBlur)) {
+        commitNativeTextMutation(
+            mutation,
+            preserveInputConnectionForExternalUpdate = preserveInputConnectionForExternalUpdate
+        )
+        return true
+    }
+    recordImeTraceForTesting(
+        "nativeMutationNoop",
+        "reason=${if (mutation == null) "noDiffRange" else "notAdoptable"} allowAfterBlur=$allowAfterBlur currentLength=${currentText.length} authorizedLength=${lastAuthorizedText.length}"
+    )
+    return false
+}
+
+internal fun EditorEditText.beginNativeTextMutationAfterBlurWindow() {
+    if (!hasLiveEditor()) {
+        clearNativeTextMutationAfterBlurWindow()
+        return
+    }
+    nativeTextMutationAfterBlurWindow = NativeTextMutationAfterBlurWindow(
+        editorId = editorId,
+        authorizedTextRevision = lastAuthorizedTextRevision,
+        deadlineMs = SystemClock.uptimeMillis() + NATIVE_TEXT_MUTATION_AFTER_BLUR_WINDOW_MS
+    )
+}
+
+internal fun EditorEditText.clearNativeTextMutationAfterBlurWindow() {
+    nativeTextMutationAfterBlurWindow = null
+}
+
+internal fun EditorEditText.suppressNativeTextMutationAdoptionForCurrentRevision() {
+    if (!hasLiveEditor()) {
+        clearNativeTextMutationAdoptionSuppression()
+        return
+    }
+    nativeTextMutationAdoptionSuppression = NativeTextMutationAdoptionSuppression(
+        editorId = editorId,
+        authorizedTextRevision = lastAuthorizedTextRevision
+    )
+}
+
+internal fun EditorEditText.clearNativeTextMutationAdoptionSuppression() {
+    nativeTextMutationAdoptionSuppression = null
+}
+
+internal fun EditorEditText.isNativeTextMutationAdoptionSuppressedForCurrentRevision(): Boolean {
+    val suppression = nativeTextMutationAdoptionSuppression ?: return false
+    if (
+        suppression.editorId != editorId ||
+        suppression.authorizedTextRevision != lastAuthorizedTextRevision
+    ) {
+        nativeTextMutationAdoptionSuppression = null
+        return false
+    }
+    return true
+}
+
+internal fun EditorEditText.canAdoptNativeTextMutationAfterBlur(): Boolean {
+    val window = nativeTextMutationAfterBlurWindow ?: return false
+    val now = SystemClock.uptimeMillis()
+    if (now > window.deadlineMs ||
+        window.editorId != editorId ||
+        window.authorizedTextRevision != lastAuthorizedTextRevision ||
+        window.didAdoptMutation
+    ) {
+        nativeTextMutationAfterBlurWindow = null
+        return false
+    }
+    return true
+}
+
+internal fun EditorEditText.commitNativeTextMutation(
+    mutation: NativeTextMutation,
+    preserveInputConnectionForExternalUpdate: Boolean = false
+) {
+    if (!hasLiveEditor()) return
+    val startedAt = System.nanoTime()
+    if ((text?.toString() ?: "") != mutation.resultingText) {
+        recordImeTraceForTesting(
+            "nativeMutationNoop",
+            "reason=staleResult range=${mutation.scalarFrom}..${mutation.scalarTo} replacementLength=${mutation.replacementText.length}"
+        )
+        return
+    }
+    val shouldRestartInput = hasFocus()
+    if (preserveInputConnectionForExternalUpdate) {
+        clearInputStateForExternalReplacementPreservingConnection()
+    } else {
+        retireInputConnectionForEditor()
+    }
+    nativeTextMutationAfterBlurWindow?.didAdoptMutation = true
+    clearNativeTextMutationAfterBlurWindow()
+
+    recordImeTraceForTesting(
+        "nativeMutationApply",
+        "range=${mutation.scalarFrom}..${mutation.scalarTo} replacementLength=${mutation.replacementText.length} restartInput=$shouldRestartInput preserveInputConnection=$preserveInputConnectionForExternalUpdate"
+    )
+    if (mutation.replacementText.isEmpty()) {
+        deleteRangeInRust(mutation.scalarFrom, mutation.scalarTo)
+    } else {
+        insertPlainTextRangeInRust(
+            mutation.scalarFrom,
+            mutation.scalarTo,
+            mutation.replacementText
+        )
+    }
+    restoreSelectionAfterNativeTextMutation(mutation)
+    if (shouldRestartInput) {
+        restartInputForEditor(
+            if (preserveInputConnectionForExternalUpdate) "externalUpdatePreflight" else "explicit"
+        )
+    }
+    recordImeTraceForTesting(
+        "nativeMutationApplyDone",
+        "totalUs=${nanosToMicros(System.nanoTime() - startedAt)} restartInput=$shouldRestartInput"
+    )
+}
+
+internal fun EditorEditText.restoreSelectionAfterNativeTextMutation(mutation: NativeTextMutation) {
+    val selectionScalarAnchor = mutation.selectionScalarAnchor ?: return
+    val selectionScalarHead = mutation.selectionScalarHead ?: return
+    val currentText = text?.toString() ?: return
+    val anchorUtf16 = PositionBridge.scalarToUtf16(selectionScalarAnchor, currentText)
+    val headUtf16 = PositionBridge.scalarToUtf16(selectionScalarHead, currentText)
+    val length = currentText.length
+    setSelection(anchorUtf16.coerceIn(0, length), headUtf16.coerceIn(0, length))
+}

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

@@ -0,0 +1,154 @@
+package com.apollohg.editor
+
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.StaticLayout
+import android.text.TextPaint
+import com.apollohg.editor.EditorEditText.Companion.EMPTY_BLOCK_PLACEHOLDER
+
+/**
+ * Whether the document holds nothing the user authored.
+ *
+ * Taken verbatim from the core. Deriving it cannot work: an empty list item
+ * contributes no characters, so scanning the rendered content reports empty
+ * and leaves the placeholder over a visible bullet. The scan below is only
+ * the fallback for renders with no editor update.
+ */
+internal fun EditorEditText.isRenderedContentEmpty(content: CharSequence? = text): Boolean {
+    coreReportedDocumentIsEmpty?.let { return it }
+
+    val renderedContent = content ?: return true
+    if (renderedContent.isEmpty()) return true
+
+    for (index in 0 until renderedContent.length) {
+        when (renderedContent[index]) {
+            EMPTY_BLOCK_PLACEHOLDER, '\n', '\r' -> continue
+            else -> return false
+        }
+    }
+
+    return true
+}
+
+/** Adopt the core's authoritative empty state from an editor update. */
+internal fun EditorEditText.setCoreReportedDocumentIsEmptyImpl(isEmpty: Boolean?) {
+    if (coreReportedDocumentIsEmpty == isEmpty) return
+    coreReportedDocumentIsEmpty = isEmpty
+    invalidate()
+}
+
+internal fun EditorEditText.shouldDisplayPlaceholder(): Boolean = placeholderText.isNotEmpty() &&
+    externalTextComposition?.latestText.isNullOrEmpty() &&
+    isRenderedContentEmpty()
+
+internal fun EditorEditText.shouldDisplayPlaceholderForTestingImpl(): Boolean =
+    shouldDisplayPlaceholder()
+
+internal fun EditorEditText.buildPlaceholderLayout(availableWidth: Int): StaticLayout? {
+    if (!shouldDisplayPlaceholder()) return null
+    if (availableWidth <= 0) return null
+    val insets = placeholderContentInsets(availableWidth)
+    val contentWidth = (availableWidth - insets.left - insets.right).toInt().coerceAtLeast(1)
+
+    val placeholderPaint = resolvedPlaceholderPaint()
+    val styledPlaceholder = theme?.styleSheet?.let { sheet ->
+        android.text.SpannableStringBuilder(placeholderText).apply {
+            setSpan(
+                EditorResolvedTextSpan(
+                    sheet.resolveText("placeholder"),
+                    resources.displayMetrics.density
+                ),
+                0,
+                length,
+                android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+            )
+            applyStyleSheetLineMetrics()
+        }
+    } ?: placeholderText
+    return StaticLayout.Builder
+        .obtain(
+            styledPlaceholder,
+            0,
+            placeholderText.length,
+            placeholderPaint,
+            contentWidth
+        )
+        .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+        .setIncludePad(includeFontPadding)
+        .build()
+}
+
+internal fun EditorEditText.placeholderContentInsets(availableWidth: Int): EditorEdges {
+    val current = layout
+    val document = if (current is EditorDocumentLayout &&
+        current.width == availableWidth
+    ) {
+        current
+    } else {
+        EditorDocumentLayout(
+            editableText,
+            paint,
+            availableWidth.coerceAtLeast(1),
+            includeFontPadding,
+            lineSpacingMultiplier,
+            lineSpacingExtra
+        )
+    }
+    return EditorEdges(
+        top = document.textLineTop(0).toFloat(),
+        right = availableWidth - document.contentRight(0),
+        bottom = (document.height - document.textLineBottom(document.lineCount - 1)).toFloat(),
+        left = document.contentLeft(0)
+    )
+}
+
+internal fun EditorEditText.resolvedPlaceholderPaint(): TextPaint {
+    val textStyle =
+        theme?.styleSheet?.resolveText("placeholder") ?: theme?.effectiveTextStyle("paragraph")
+    val resolvedTextSize =
+        textStyle?.fontSize?.times(resources.displayMetrics.density) ?: baseFontSize
+    val resolvedTypeface = resolvePlaceholderTypeface(textStyle)
+
+    return TextPaint(paint).apply {
+        color = theme?.placeholderColor ?: currentHintTextColor
+        textSize = resolvedTextSize
+        typeface = resolvedTypeface
+        textStyle?.letterSpacing?.let {
+            letterSpacing =
+                it * resources.displayMetrics.density / textSize
+        }
+        if (theme?.styleSheet != null &&
+            textStyle != null
+        ) {
+            EditorResolvedTextSpan(
+                textStyle,
+                resources.displayMetrics.density
+            ).updateDrawState(this)
+        }
+    }
+}
+
+internal fun EditorEditText.resolvePlaceholderTypeface(textStyle: EditorTextStyle?): Typeface {
+    val baseTypeface = typeface ?: Typeface.DEFAULT
+    val requestedStyle = textStyle?.typefaceStyle() ?: Typeface.NORMAL
+    val family = textStyle?.fontFamily?.takeIf { it.isNotBlank() }
+
+    return when {
+        family != null -> Typeface.create(family, requestedStyle)
+        requestedStyle != Typeface.NORMAL -> Typeface.create(baseTypeface, requestedStyle)
+        else -> baseTypeface
+    }
+}
+
+internal fun EditorEditText.resolvePlaceholderHeightForMeasuredWidth(widthPx: Int): Int? {
+    val availableWidth = (widthPx - compoundPaddingLeft - compoundPaddingRight).coerceAtLeast(0)
+    return resolvePlaceholderHeightForAvailableWidth(availableWidth)
+}
+
+internal fun EditorEditText.resolvePlaceholderHeightForAvailableWidth(availableWidth: Int): Int? {
+    val placeholderLayout = buildPlaceholderLayout(availableWidth) ?: return null
+    val placeholderHeight = placeholderLayout.height.takeIf { it > 0 } ?: lineHeight
+    val insets = placeholderContentInsets(availableWidth)
+    return placeholderHeight + insets.top.toInt() + insets.bottom.toInt() + compoundPaddingTop +
+        compoundPaddingBottom
+}