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

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

@@ -0,0 +1,67 @@
+package com.apollohg.editor
+
+import android.text.Annotation
+import android.text.Spanned
+import android.view.DragEvent
+
+internal fun EditorEditText.localTextDragFor(event: DragEvent): LocalTextDrag? {
+    if (!isEditable || editorId == 0L || !isDragFromThisEditor(event.localState) || !hasFocus()) {
+        return null
+    }
+    val currentText = text?.toString() ?: return null
+    val selection = normalizedUtf16SelectionRange(currentText) ?: return null
+    val (start, end) = PositionBridge.snapRangeToScalarBoundaries(
+        selection.first,
+        selection.second,
+        currentText
+    )
+    if (start >= end || containsInterBlockBoundary(start, end)) return null
+    return LocalTextDrag(
+        PositionBridge.utf16ToScalar(start, currentText),
+        PositionBridge.utf16ToScalar(end, currentText),
+        lastAppliedDocumentVersion,
+        editorId
+    )
+}
+
+internal fun EditorEditText.isDragFromThisEditor(localState: Any?): Boolean = localState === this
+
+internal fun EditorEditText.containsInterBlockBoundary(start: Int, end: Int): Boolean {
+    val content = text as? Spanned ?: return false
+    return content.getSpans(start, end, Annotation::class.java).any {
+        it.key == RenderBridge.NATIVE_INTER_BLOCK_SEPARATOR_ANNOTATION
+    }
+}
+
+internal fun EditorEditText.performLocalSelectionDrop(
+    drag: LocalTextDrag,
+    destination: Int
+): Boolean {
+    if (destination in drag.scalarFrom..drag.scalarTo) return false
+    if (drag.editorId != editorId || drag.documentVersion == null) return false
+    if (lastAppliedDocumentVersion == null ||
+        lastAppliedDocumentVersion != drag.documentVersion
+    ) {
+        return false
+    }
+    if (!prepareForExternalInteractionMutation()) return false
+    if (lastAppliedDocumentVersion != drag.documentVersion) return false
+    onMoveSelectionScalarForTesting?.let { callback ->
+        callback(drag.scalarFrom, drag.scalarTo, destination)
+        return true
+    }
+    val driver = v2Driver ?: return false
+    val updateJSON = driver.moveSelection(drag.scalarFrom, drag.scalarTo, destination)
+    applyNonOptimisticRustUpdate(driver, updateJSON)
+    return updateJSON != null
+}
+
+internal fun EditorEditText.performLocalSelectionDropForTestingImpl(
+    scalarFrom: Int,
+    scalarTo: Int,
+    destination: Int,
+    documentVersion: String?
+): Boolean = performLocalSelectionDrop(
+    LocalTextDrag(scalarFrom, scalarTo, documentVersion, editorId),
+    destination
+)

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

@@ -0,0 +1,357 @@
+package com.apollohg.editor
+
+import android.text.Selection
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.view.inputmethod.BaseInputConnection
+import org.json.JSONObject
+
+internal fun EditorEditText.runWithTransientInputMutationGuardImpl(block: () -> Boolean): Boolean {
+    val wasApplyingRustState = isApplyingRustState
+    isApplyingRustState = true
+    return try {
+        block()
+    } finally {
+        isApplyingRustState = wasApplyingRustState
+    }
+}
+
+internal fun EditorEditText.beginExternalTextCompositionImpl(sessionId: String): String {
+    val driver = v2Driver
+    if (!hasLiveEditor() || !isEditable || driver == null) {
+        return externalCompositionErrorJSON(
+            sessionId,
+            "EXTERNAL_COMPOSITION_UNAVAILABLE",
+            "The native editor is unavailable or not editable"
+        )
+    }
+    if (externalTextCompositionTerminalResults.containsKey(sessionId)) {
+        return externalCompositionEndedErrorJSON(sessionId)
+    }
+    val selection = try {
+        driver.selectionJson()?.let(::JSONObject)
+    } catch (_: Exception) {
+        null
+    }
+    if (selection?.optString("type") != "text") {
+        return externalCompositionErrorJSON(
+            sessionId,
+            "EXTERNAL_COMPOSITION_SELECTION_INCOMPATIBLE",
+            "External composition requires a text selection"
+        )
+    }
+
+    if (externalTextComposition != null) {
+        if (!finishExternalTextComposition("consumer", finalText = null, cancel = false)) {
+            return externalCompositionErrorJSON(
+                sessionId,
+                "EXTERNAL_COMPOSITION_COMMIT_FAILED",
+                "The previous external text composition could not be committed"
+            )
+        }
+        if (externalTextCompositionTerminalResults.containsKey(sessionId)) {
+            return externalCompositionEndedErrorJSON(sessionId)
+        }
+    }
+    if (!prepareExternalUpdateInternal().ready) {
+        return externalCompositionErrorJSON(
+            sessionId,
+            "EXTERNAL_COMPOSITION_UNAVAILABLE",
+            "Pending native input could not be committed"
+        )
+    }
+
+    captureCompositionReplacementRangeIfNeeded()
+    val (replacementStart, replacementEnd) = compositionReplacementRange()
+        ?: return externalCompositionErrorJSON(
+            sessionId,
+            "EXTERNAL_COMPOSITION_SELECTION_INCOMPATIBLE",
+            "External composition requires a text selection"
+        )
+    externalTextComposition = ExternalTextCompositionState(
+        sessionId = sessionId,
+        latestText = "",
+        replacementStartUtf16 = replacementStart,
+        replacementEndUtf16 = replacementEnd,
+        startingAuthorizedText = lastAuthorizedText,
+        startingAuthorizedRenderedText = lastAuthorizedRenderedText?.let(::SpannableStringBuilder)
+    )
+    return externalCompositionActiveJSON(sessionId)
+}
+
+internal fun EditorEditText.updateExternalTextCompositionImpl(
+    sessionId: String,
+    text: String
+): String {
+    val state = externalTextComposition
+    if (state?.sessionId != sessionId) {
+        return externalCompositionEndedErrorJSON(sessionId)
+    }
+    renderExternalTextComposition(text)
+    return externalCompositionActiveJSON(sessionId)
+}
+
+internal fun EditorEditText.commitExternalTextCompositionImpl(
+    sessionId: String,
+    finalText: String
+): String {
+    if (externalTextComposition?.sessionId != sessionId) {
+        return externalTextCompositionTerminalResults[sessionId]
+            ?: externalCompositionEndedErrorJSON(sessionId)
+    }
+    finishExternalTextComposition("consumer", finalText, cancel = false)
+    return externalTextCompositionTerminalResults[sessionId]
+        ?: externalCompositionEndedErrorJSON(sessionId)
+}
+
+internal fun EditorEditText.cancelExternalTextCompositionImpl(
+    sessionId: String,
+    cause: String
+): String {
+    if (cause !in setOf("consumer", "documentChange", "lifecycle")) {
+        return externalCompositionErrorJSON(
+            sessionId,
+            "EXTERNAL_COMPOSITION_CANCEL_CAUSE_INVALID",
+            "The external composition cancellation cause is invalid"
+        )
+    }
+    if (externalTextComposition?.sessionId != sessionId) {
+        return externalTextCompositionTerminalResults[sessionId]
+            ?: externalCompositionEndedErrorJSON(sessionId)
+    }
+    finishExternalTextComposition(cause, finalText = null, cancel = true)
+    return externalTextCompositionTerminalResults[sessionId]
+        ?: externalCompositionEndedErrorJSON(sessionId)
+}
+
+internal fun EditorEditText.commitExternalTextCompositionBeforeInteractionIfNeededImpl(): Boolean =
+    externalTextComposition == null ||
+        finishExternalTextComposition("interaction", finalText = null, cancel = false)
+
+internal fun EditorEditText.hasActiveExternalTextCompositionForEditorImpl(): Boolean =
+    externalTextComposition != null
+
+internal fun EditorEditText.commitExternalTextCompositionForDocumentChangeIfNeeded(): Boolean =
+    externalTextComposition == null ||
+        finishExternalTextComposition("documentChange", finalText = null, cancel = false)
+
+internal fun EditorEditText.cancelExternalTextCompositionForLifecycleIfNeeded() {
+    if (externalTextComposition != null) {
+        finishExternalTextComposition("lifecycle", finalText = null, cancel = true)
+    }
+}
+
+internal fun EditorEditText.renderExternalTextComposition(text: String) {
+    val state = externalTextComposition ?: return
+    val editable = this.text ?: return
+    val visibleStart = state.replacementStartUtf16.coerceIn(0, editable.length)
+    val visibleEnd = if (editable.toString() == state.startingAuthorizedText) {
+        state.replacementEndUtf16
+    } else {
+        visibleStart + state.latestText.length
+    }.coerceIn(visibleStart, editable.length)
+    runWithTransientInputMutationGuard {
+        editable.replace(visibleStart, visibleEnd, text)
+        BaseInputConnection.removeComposingSpans(editable)
+        if (text.isNotEmpty()) {
+            editable.setSpan(
+                externalCompositionMarker,
+                visibleStart,
+                visibleStart + text.length,
+                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_COMPOSING
+            )
+        }
+        Selection.setSelection(editable, visibleStart + text.length)
+        true
+    }
+    state.latestText = text
+    setComposingTextForEditor(text)
+    invalidate()
+}
+
+internal fun EditorEditText.finishExternalTextComposition(
+    cause: String,
+    finalText: String?,
+    cancel: Boolean
+): Boolean {
+    val state = externalTextComposition ?: return true
+    if (finalText != null && finalText != state.latestText) {
+        renderExternalTextComposition(finalText)
+    }
+    if (finalText != null) state.latestText = finalText
+    val authoritativeCancellationUpdate = if (cancel) {
+        v2Driver?.currentStateJson()
+    } else {
+        null
+    }
+    externalTextComposition = null
+    clearCompositionTrackingForEditor()
+
+    if (cancel) {
+        restoreAuthorizedExternalComposition(state, authoritativeCancellationUpdate)
+        emitExternalTextCompositionEnd(
+            state.sessionId,
+            externalCompositionEndedJSON(
+                state.sessionId,
+                "cancelled",
+                cause,
+                state.latestText
+            )
+        )
+        return true
+    }
+
+    val driver = v2Driver
+    restoreAuthorizedExternalComposition(state)
+    val scalarFrom = PositionBridge.utf16ToScalar(
+        state.replacementStartUtf16,
+        state.startingAuthorizedText
+    )
+    val scalarTo = PositionBridge.utf16ToScalar(
+        state.replacementEndUtf16,
+        state.startingAuthorizedText
+    )
+    val nativeOutcome = if (driver is EditorV2Adapter) {
+        driver.replaceTextRangeNative(scalarFrom, scalarTo, state.latestText)
+    } else {
+        null
+    }
+    if (nativeOutcome is EditorV2NativeIntentResult.Recovered) {
+        applyUpdateJSON(nativeOutcome.updateJson, notifyListener = false)
+        return failExternalTextCompositionCommit(state, cause)
+    }
+    val updateJSON = when (nativeOutcome) {
+        is EditorV2NativeIntentResult.Applied -> nativeOutcome.render.updateJson
+        EditorV2NativeIntentResult.Rejected -> null
+        is EditorV2NativeIntentResult.Recovered -> null
+        null -> driver?.replaceTextRange(scalarFrom, scalarTo, state.latestText)
+    }
+    if (updateJSON == null) {
+        val recoveryJSON = (driver as? EditorV2Adapter)?.recoverNativeRender()
+            ?: if (driver is EditorV2Adapter) null else driver?.currentStateJson()
+        recoveryJSON?.let {
+            applyUpdateJSON(it, notifyListener = false)
+        }
+        return failExternalTextCompositionCommit(state, cause)
+    }
+
+    applyUpdateJSON(updateJSON, notifyListener = false)
+    val documentChanged = (nativeOutcome as? EditorV2NativeIntentResult.Applied)
+        ?.render
+        ?.documentChanged
+        ?: (text?.toString() != state.startingAuthorizedText)
+    if (documentChanged) {
+        editorListener?.onEditorUpdate(updateJSON)
+    }
+    emitExternalTextCompositionEnd(
+        state.sessionId,
+        externalCompositionEndedJSON(
+            state.sessionId,
+            "committed",
+            cause,
+            state.latestText
+        )
+    )
+    return true
+}
+
+internal fun EditorEditText.failExternalTextCompositionCommit(
+    state: ExternalTextCompositionState,
+    cause: String
+): Boolean {
+    val resultJSON = externalCompositionEndedJSON(
+        state.sessionId,
+        "cancelled",
+        cause,
+        state.latestText,
+        externalCompositionErrorPayload(
+            "EXTERNAL_COMPOSITION_COMMIT_FAILED",
+            "The external text composition could not be committed"
+        )
+    )
+    emitExternalTextCompositionEnd(state.sessionId, resultJSON)
+    return false
+}
+
+internal fun EditorEditText.restoreAuthorizedExternalComposition(
+    state: ExternalTextCompositionState,
+    authoritativeUpdateJSON: String? = null
+) {
+    val snapshot = state.startingAuthorizedRenderedText ?: state.startingAuthorizedText
+    runWithTransientInputMutationGuard {
+        beginBatchEdit()
+        try {
+            setText(snapshot)
+            val length = text?.length ?: 0
+            Selection.setSelection(
+                text,
+                state.replacementStartUtf16.coerceIn(0, length),
+                state.replacementEndUtf16.coerceIn(0, length)
+            )
+        } finally {
+            endBatchEdit()
+        }
+        true
+    }
+    authoritativeUpdateJSON?.let {
+        applyUpdateJSON(it, notifyListener = false)
+    }
+}
+
+internal fun EditorEditText.emitExternalTextCompositionEnd(sessionId: String, resultJson: String) {
+    if (externalTextCompositionTerminalResults.putIfAbsent(sessionId, resultJson) != null) return
+    editorListener?.onExternalTextCompositionEnded(resultJson)
+}
+
+internal fun EditorEditText.externalCompositionActiveJSON(sessionId: String): String = JSONObject()
+    .put("version", 1)
+    .put("type", "active")
+    .put("sessionId", sessionId)
+    .toString()
+
+internal fun EditorEditText.externalCompositionEndedJSON(
+    sessionId: String,
+    outcome: String,
+    cause: String,
+    text: String,
+    error: JSONObject? = null
+): String = JSONObject()
+    .put("version", 1)
+    .put("type", "ended")
+    .put("sessionId", sessionId)
+    .put("outcome", outcome)
+    .put("cause", cause)
+    .put("text", text)
+    .apply { if (error != null) put("error", error) }
+    .toString()
+
+internal fun EditorEditText.externalCompositionEndedErrorJSON(sessionId: String): String =
+    externalCompositionErrorJSON(
+        sessionId,
+        "EXTERNAL_COMPOSITION_ENDED",
+        "The external text composition session has ended"
+    )
+
+internal fun EditorEditText.externalCompositionErrorJSON(
+    sessionId: String?,
+    code: String,
+    message: String
+): String = JSONObject()
+    .put("version", 1)
+    .put("type", "error")
+    .put("sessionId", sessionId ?: JSONObject.NULL)
+    .put("error", externalCompositionErrorPayload(code, message))
+    .toString()
+
+internal fun EditorEditText.externalCompositionErrorPayload(
+    code: String,
+    message: String
+): JSONObject = JSONObject()
+    .put("domain", "lifecycle")
+    .put("code", code)
+    .put("message", message)
+    .put("requestId", JSONObject.NULL)
+    .put("operationIndex", JSONObject.NULL)
+    .put("limit", JSONObject.NULL)
+    .put("actual", JSONObject.NULL)
+    .put("details", JSONObject.NULL)

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

@@ -0,0 +1,277 @@
+package com.apollohg.editor
+
+import android.os.SystemClock
+import android.view.KeyEvent
+import com.apollohg.editor.EditorEditText.Companion.RECENT_HANDLED_HARDWARE_KEY_DOWN_WINDOW_MS
+
+internal fun EditorEditText.handleCompositionKeyEventImpl(
+    event: KeyEvent,
+    applyBaseEvent: () -> Boolean
+): Boolean {
+    val inputConnection = activeInputConnection ?: return false
+    if (!inputConnection.hasPendingComposition()) return false
+    if (!isCompositionKeyCode(event.keyCode)) return false
+    if (event.action == KeyEvent.ACTION_DOWN) {
+        val signature = hardwareKeyEventSignature(event)
+        if (
+            lastHandledHardwareKeySignature == signature ||
+            didRecentlyHandleHardwareKeyDown(signature)
+        ) {
+            return true
+        }
+        markHandledHardwareKeyDown(signature)
+        runWithTransientInputMutationGuard {
+            when (event.keyCode) {
+                KeyEvent.KEYCODE_DEL,
+                KeyEvent.KEYCODE_FORWARD_DEL ->
+                    inputConnection.deleteTransientTextForHardwareKeyEvent(
+                        event
+                    )
+
+                else -> applyBaseEvent()
+            }
+        }
+        inputConnection.refreshComposingTextFromEditableForEditor()
+        return true
+    }
+    if (event.action == KeyEvent.ACTION_UP) {
+        if (lastHandledHardwareKeySignature?.let {
+                it.keyCode == event.keyCode && it.downTime == event.downTime
+            } == true
+        ) {
+            lastHandledHardwareKeySignature = null
+        }
+        return true
+    }
+    return false
+}
+
+internal fun EditorEditText.isCompositionKeyCode(keyCode: Int): Boolean = when (keyCode) {
+    KeyEvent.KEYCODE_DEL,
+    KeyEvent.KEYCODE_FORWARD_DEL,
+    KeyEvent.KEYCODE_ENTER,
+    KeyEvent.KEYCODE_NUMPAD_ENTER,
+    KeyEvent.KEYCODE_TAB -> true
+
+    else -> false
+}
+
+internal fun EditorEditText.handleHardwareKeyDownImpl(
+    keyCode: Int,
+    shiftPressed: Boolean
+): Boolean {
+    if (!isEditable || isApplyingRustState) return false
+    return when (keyCode) {
+        KeyEvent.KEYCODE_DEL -> {
+            handleBackspace()
+            true
+        }
+
+        KeyEvent.KEYCODE_FORWARD_DEL -> {
+            handleForwardDelete()
+            true
+        }
+
+        KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_NUMPAD_ENTER -> {
+            if (shiftPressed) {
+                handleHardBreak()
+            } else {
+                handleReturnKey()
+            }
+            true
+        }
+
+        KeyEvent.KEYCODE_TAB -> handleTab(shiftPressed)
+
+        else -> false
+    }
+}
+
+internal fun EditorEditText.isSupportedHardwareMutationKey(keyCode: Int): Boolean = when (keyCode) {
+    KeyEvent.KEYCODE_DEL,
+    KeyEvent.KEYCODE_FORWARD_DEL,
+    KeyEvent.KEYCODE_ENTER,
+    KeyEvent.KEYCODE_NUMPAD_ENTER,
+    KeyEvent.KEYCODE_TAB -> true
+
+    else -> false
+}
+
+internal fun EditorEditText.isReadOnlyTextMutationKeyEventImpl(event: KeyEvent): Boolean {
+    if (isSupportedHardwareMutationKey(event.keyCode) ||
+        event.keyCode == KeyEvent.KEYCODE_FORWARD_DEL
+    ) {
+        return true
+    }
+    if (event.keyCode == KeyEvent.KEYCODE_INSERT && event.isShiftPressed) {
+        return true
+    }
+    if (event.isCtrlPressed || event.isMetaPressed) {
+        return when (event.keyCode) {
+            KeyEvent.KEYCODE_V,
+            KeyEvent.KEYCODE_X,
+            KeyEvent.KEYCODE_Z,
+            KeyEvent.KEYCODE_Y -> true
+
+            else -> false
+        }
+    }
+    if (!keyEventCharacters(event).isNullOrEmpty()) return true
+    return event.unicodeChar != 0
+}
+
+internal fun EditorEditText.handleHardwareKeyEventImpl(event: KeyEvent?): Boolean {
+    if (event == null || !isEditable || isApplyingRustState) return false
+
+    return when (event.action) {
+        KeyEvent.ACTION_DOWN -> {
+            if (!isSupportedHardwareMutationKey(event.keyCode)) return false
+
+            val signature = hardwareKeyEventSignature(event)
+            if (
+                lastHandledHardwareKeySignature == signature ||
+                didRecentlyHandleHardwareKeyDown(signature)
+            ) {
+                return true
+            }
+
+            if (handleHardwareKeyDown(event.keyCode, event.isShiftPressed)) {
+                markHandledHardwareKeyDown(signature)
+                true
+            } else {
+                false
+            }
+        }
+
+        KeyEvent.ACTION_UP -> {
+            if (lastHandledHardwareKeySignature?.let {
+                    it.keyCode == event.keyCode && it.downTime == event.downTime
+                } == true
+            ) {
+                lastHandledHardwareKeySignature = null
+                true
+            } else {
+                false
+            }
+        }
+
+        else -> false
+    }
+}
+
+internal fun EditorEditText.handlePrintableHardwareKeyEventImpl(
+    event: KeyEvent,
+    applyBaseEvent: () -> Boolean
+): Boolean {
+    if (!isEditable || isApplyingRustState || !isPrintableHardwareMutationKey(event)) {
+        return false
+    }
+    val signature = hardwareKeyEventSignature(event)
+    return when (event.action) {
+        KeyEvent.ACTION_DOWN -> {
+            if (
+                lastHandledHardwareKeySignature == signature ||
+                didRecentlyHandleHardwareKeyDown(signature)
+            ) {
+                true
+            } else {
+                val inputConnection = activeInputConnection?.takeIf {
+                    it.hasPendingComposition()
+                }
+                if (inputConnection != null) {
+                    var didMutate = false
+                    runWithTransientInputMutationGuard {
+                        didMutate = insertTransientHardwareText(keyEventText(event))
+                        didMutate
+                    }
+                    if (!didMutate) return false
+                    inputConnection.refreshComposingTextFromEditableForEditor()
+                } else {
+                    applyBaseEvent()
+                }
+                markHandledHardwareKeyDown(signature)
+                true
+            }
+        }
+
+        KeyEvent.ACTION_UP -> {
+            if (lastHandledHardwareKeySignature?.let {
+                    it.keyCode == event.keyCode && it.downTime == event.downTime
+                } == true
+            ) {
+                lastHandledHardwareKeySignature = null
+            }
+            false
+        }
+
+        else -> false
+    }
+}
+
+internal fun EditorEditText.isPrintableHardwareMutationKey(event: KeyEvent): Boolean {
+    if (isSupportedHardwareMutationKey(event.keyCode)) return false
+    if (event.isCtrlPressed || event.isMetaPressed) return false
+    return !keyEventText(event).isNullOrEmpty()
+}
+
+internal fun EditorEditText.hardwareKeyEventSignature(event: KeyEvent): HardwareKeyEventSignature =
+    HardwareKeyEventSignature(
+        keyCode = event.keyCode,
+        downTime = event.downTime,
+        repeatCount = event.repeatCount
+    )
+
+@Suppress("DEPRECATION")
+internal fun EditorEditText.keyEventCharacters(event: KeyEvent): String? = event.characters
+
+internal fun EditorEditText.keyEventText(event: KeyEvent): String? {
+    val characters = keyEventCharacters(event)
+    if (!characters.isNullOrEmpty()) return characters
+    val unicodeChar = event.unicodeChar
+    if (unicodeChar == 0) return null
+    return runCatching {
+        String(Character.toChars(unicodeChar))
+    }.getOrNull()
+}
+
+internal fun EditorEditText.insertTransientHardwareText(insertedText: String?): Boolean {
+    if (insertedText.isNullOrEmpty()) return false
+    val editable = text ?: return false
+    val currentText = editable.toString()
+    val rawStart = selectionStart
+    val rawEnd = selectionEnd
+    if (rawStart < 0 || rawEnd < 0) return false
+    val start = rawStart.coerceIn(0, editable.length)
+    val end = rawEnd.coerceIn(0, editable.length)
+    val normalizedStart = minOf(start, end)
+    val normalizedEnd = maxOf(start, end)
+    val (replaceStart, replaceEnd) = PositionBridge.snapRangeToScalarBoundaries(
+        normalizedStart,
+        normalizedEnd,
+        currentText
+    )
+    if (isCollapsedAtomBoundarySelection(replaceStart, replaceEnd)) return false
+    editable.replace(replaceStart, replaceEnd, insertedText)
+    val cursor = (replaceStart + insertedText.length).coerceIn(0, editable.length)
+    setSelection(cursor)
+    return true
+}
+
+internal fun EditorEditText.markHandledHardwareKeyDown(signature: HardwareKeyEventSignature) {
+    lastHandledHardwareKeySignature = signature
+    recentHandledHardwareKeyDownSignature = signature
+    recentHandledHardwareKeyDownUptimeMs = SystemClock.uptimeMillis()
+}
+
+internal fun EditorEditText.didRecentlyHandleHardwareKeyDown(
+    signature: HardwareKeyEventSignature
+): Boolean {
+    val recentSignature = recentHandledHardwareKeyDownSignature ?: return false
+    val elapsedMs = SystemClock.uptimeMillis() - recentHandledHardwareKeyDownUptimeMs
+    if (elapsedMs > RECENT_HANDLED_HARDWARE_KEY_DOWN_WINDOW_MS) {
+        recentHandledHardwareKeyDownSignature = null
+        recentHandledHardwareKeyDownUptimeMs = 0L
+        return false
+    }
+    return recentSignature == signature
+}