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

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

@@ -0,0 +1,259 @@
+package com.apollohg.editor
+
+import com.apollohg.editor.NativeEditorExpoView.PendingNativeAction
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal fun NativeEditorExpoView.refreshMentionQuery() {
+    val mentions = addons.mentions
+    if (mentions == null || !richTextView.editorEditText.hasFocus()) {
+        clearMentionQueryState()
+        emitMentionQueryChange("", "@", 0, 0, false)
+        return
+    }
+
+    val queryState = currentMentionQueryState(mentions.trigger)
+    if (queryState == null) {
+        clearMentionQueryState()
+        emitMentionQueryChange("", mentions.trigger, 0, 0, false)
+        return
+    }
+
+    mentionQueryState = queryState
+    val suggestions = filteredMentionSuggestions(queryState, mentions)
+    keyboardToolbarView.applyMentionTheme(
+        richTextView.editorEditText.theme?.mentions ?: mentions.theme
+    )
+    syncKeyboardToolbarMentionSuggestions(suggestions, mentions.trigger)
+    emitMentionQueryChange(
+        queryState.query,
+        queryState.trigger,
+        queryState.anchor,
+        queryState.head,
+        true
+    )
+}
+
+internal fun NativeEditorExpoView.clearMentionQueryState(resetLastEvent: Boolean = false) {
+    mentionQueryState = null
+    if (resetLastEvent) {
+        lastMentionEventJson = null
+        lastMentionEventEditorId = null
+    }
+    syncKeyboardToolbarMentionSuggestions(emptyList())
+}
+
+internal fun NativeEditorExpoView.currentMentionQueryState(trigger: String): MentionQueryState? {
+    val editor = richTextView.editorEditText
+    if (editor.selectionStart != editor.selectionEnd) return null
+    val text = editor.text?.toString() ?: return null
+    val cursorUtf16 = editor.selectionStart
+    val cursorScalar = PositionBridge.utf16ToScalar(cursorUtf16, text)
+    return resolveMentionQueryState(
+        text = text,
+        cursorScalar = cursorScalar,
+        trigger = trigger,
+        isCaretInsideMention = isCaretInsideMention(cursorUtf16)
+    )
+}
+
+internal fun NativeEditorExpoView.isCaretInsideMention(cursorUtf16: Int): Boolean {
+    val editable = richTextView.editorEditText.text ?: return false
+    val checkOffsets = listOf(cursorUtf16, (cursorUtf16 - 1).coerceAtLeast(0))
+    return checkOffsets.any { offset ->
+        editable.getSpans(offset, offset, android.text.Annotation::class.java).any { span ->
+            span.key == "nativeVoidNodeType" && span.value == "mention"
+        }
+    }
+}
+
+internal fun NativeEditorExpoView.filteredMentionSuggestions(
+    queryState: MentionQueryState,
+    config: NativeMentionsAddonConfig
+): List<NativeMentionSuggestion> {
+    val normalizedQuery = queryState.query.trim().lowercase()
+    if (normalizedQuery.isEmpty()) return config.suggestions
+    return config.suggestions.filter { suggestion ->
+        suggestion.title.lowercase().contains(normalizedQuery) ||
+            suggestion.label.lowercase().contains(normalizedQuery) ||
+            (suggestion.subtitle?.lowercase()?.contains(normalizedQuery) == true)
+    }
+}
+
+internal fun NativeEditorExpoView.syncKeyboardToolbarMentionSuggestions(
+    suggestions: List<NativeMentionSuggestion>,
+    trigger: String = addons.mentions?.trigger ?: "@"
+) {
+    keyboardToolbarView.setMentionSuggestions(suggestions, trigger)
+    keyboardToolbarView.requestLayout()
+    post {
+        updateKeyboardToolbarLayout()
+        updateEditorViewportInset()
+    }
+}
+
+internal fun NativeEditorExpoView.emitMentionQueryChange(
+    query: String,
+    trigger: String,
+    anchor: Int,
+    head: Int,
+    isActive: Boolean
+) {
+    val eventJson = JSONObject()
+        .put("type", "mentionsQueryChange")
+        .put("query", query)
+        .put("trigger", trigger)
+        .put("range", JSONObject().put("anchor", anchor).put("head", head))
+        .put("isActive", isActive)
+        .apply {
+            lastDocumentVersion?.let { put("documentVersion", it) }
+        }
+        .toString()
+    val editorId = richTextView.editorId
+    if (eventJson == lastMentionEventJson && editorId == lastMentionEventEditorId) return
+    lastMentionEventJson = eventJson
+    lastMentionEventEditorId = editorId
+    emitAddonEvent(mapOf("eventJson" to eventJson, "editorId" to eventEditorId(editorId)))
+}
+
+internal fun NativeEditorExpoView.resolvedMentionAttrs(
+    trigger: String,
+    suggestion: NativeMentionSuggestion
+): JSONObject {
+    val attrs = JSONObject(suggestion.attrs.toString())
+    if (!attrs.has("label")) {
+        attrs.put("label", suggestion.label)
+    }
+    if (!attrs.has("mentionSuggestionChar")) {
+        attrs.put("mentionSuggestionChar", trigger)
+    }
+    return attrs
+}
+
+internal fun NativeEditorExpoView.emitMentionSelect(
+    trigger: String,
+    suggestion: NativeMentionSuggestion,
+    attrs: JSONObject
+) {
+    val eventJson = JSONObject()
+        .put("type", "mentionsSelect")
+        .put("trigger", trigger)
+        .put("suggestionKey", suggestion.key)
+        .put("attrs", attrs)
+        .apply {
+            lastDocumentVersion?.let { put("documentVersion", it) }
+        }
+        .toString()
+    emitAddonEvent(
+        mapOf(
+            "eventJson" to eventJson,
+            "editorId" to eventEditorId(richTextView.editorId)
+        )
+    )
+}
+
+internal fun NativeEditorExpoView.emitMentionSelectRequest(
+    trigger: String,
+    suggestion: NativeMentionSuggestion,
+    attrs: JSONObject,
+    range: MentionQueryState,
+    preflightUpdateJSON: String?
+) {
+    val eventJson = JSONObject()
+        .put("type", "mentionsSelectRequest")
+        .put("trigger", trigger)
+        .put("suggestionKey", suggestion.key)
+        .put("attrs", attrs)
+        .put("range", JSONObject().put("anchor", range.anchor).put("head", range.head))
+        .apply {
+            if (preflightUpdateJSON != null) {
+                put("updateJson", preflightUpdateJSON)
+            }
+            (documentVersionFromUpdateJSON(preflightUpdateJSON) ?: lastDocumentVersion)
+                ?.let { put("documentVersion", it) }
+        }
+        .toString()
+    emitAddonEvent(
+        mapOf(
+            "eventJson" to eventJson,
+            "editorId" to eventEditorId(richTextView.editorId)
+        )
+    )
+}
+
+internal fun NativeEditorExpoView.insertMentionSuggestion(
+    suggestion: NativeMentionSuggestion,
+    allowPreflightRetry: Boolean = true
+) {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (!richTextView.editorEditText.isEditable) {
+        clearPendingNativeActionRetry()
+        return
+    }
+    val mentions = addons.mentions ?: return
+    if (shouldBlockEditorCommandForPendingUpdate()) {
+        if (allowPreflightRetry) {
+            schedulePendingNativeActionRetry(
+                PendingNativeAction.MentionSuggestionSelect(suggestion)
+            )
+        }
+        return
+    }
+    val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
+    if (!preparation.ready) {
+        if (allowPreflightRetry) {
+            schedulePendingNativeActionRetry(
+                PendingNativeAction.MentionSuggestionSelect(suggestion)
+            )
+        }
+        return
+    }
+    val preflightUpdateJSON = preparation.updateJSON
+    noteDocumentVersionFromUpdateJSON(preflightUpdateJSON)
+    clearPendingNativeActionRetry()
+    val queryState = currentMentionQueryState(mentions.trigger) ?: run {
+        clearMentionQueryState()
+        return
+    }
+    val freshSuggestions = filteredMentionSuggestions(queryState, mentions)
+    if (freshSuggestions.none { it.key == suggestion.key }) {
+        refreshMentionQuery()
+        return
+    }
+    mentionQueryState = queryState
+    val attrs = resolvedMentionAttrs(mentions.trigger, suggestion)
+    if (mentions.resolveSelectionAttrs || mentions.resolveTheme) {
+        emitMentionSelectRequest(
+            mentions.trigger,
+            suggestion,
+            attrs,
+            queryState,
+            preflightUpdateJSON
+        )
+        lastMentionEventJson = null
+        clearMentionQueryState()
+        return
+    }
+    val docJson = JSONObject()
+        .put("type", "doc")
+        .put(
+            "content",
+            JSONArray().put(
+                JSONObject()
+                    .put("type", "mention")
+                    .put("attrs", attrs)
+            )
+        )
+
+    val updateJson = richTextView.editorEditText.v2Driver?.insertContentJsonAtSelection(
+        docJson.toString(),
+        queryState.anchor,
+        queryState.head
+    )
+    if (updateJson != null) {
+        richTextView.editorEditText.applyUpdateJSON(updateJson)
+    }
+    emitMentionSelect(mentions.trigger, suggestion, attrs)
+    lastMentionEventJson = null
+    clearMentionQueryState()
+}

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

@@ -0,0 +1,179 @@
+package com.apollohg.editor
+
+import android.view.View
+import com.apollohg.editor.NativeEditorExpoView.Companion.MAX_NATIVE_ACTION_RETRY_ATTEMPTS
+import com.apollohg.editor.NativeEditorExpoView.Companion.NATIVE_ACTION_RETRY_DELAY_MS
+import com.apollohg.editor.NativeEditorExpoView.PendingNativeAction
+import com.apollohg.editor.NativeEditorExpoView.PendingNativeActionScope
+import com.apollohg.editor.NativeEditorExpoView.ToolbarPlacement
+
+internal fun NativeEditorExpoView.clearPendingNativeActionRetry() {
+    pendingNativeAction = null
+    pendingNativeActionScope = null
+    pendingNativeActionRetryEditorId = null
+    pendingNativeActionRetryScheduled = false
+    pendingNativeActionRetryAttempts = 0
+    pendingNativeActionRetryGeneration += 1
+}
+
+internal fun NativeEditorExpoView.currentNativeActionScope(
+    action: PendingNativeAction
+): PendingNativeActionScope {
+    val selection = richTextView.editorEditText.currentScalarSelection()
+    val mentionScope = when (action) {
+        is PendingNativeAction.MentionSuggestionSelect ->
+            mentionQueryState ?: addons.mentions?.let { currentMentionQueryState(it.trigger) }
+
+        is PendingNativeAction.ToolbarItemPress -> null
+    }
+    return PendingNativeActionScope(
+        editorId = richTextView.editorId,
+        documentVersion = lastDocumentVersion,
+        allowedDocumentVersion = documentVersionFromUpdateJSON(pendingEditorUpdateJson),
+        hadFocus = isEditorEffectivelyFocusedForNativeAction(),
+        hadVisibleToolbar = isNativeActionToolbarVisible(action),
+        selectionAnchor = selection?.first,
+        selectionHead = selection?.second,
+        mentionAnchor = mentionScope?.anchor,
+        mentionHead = mentionScope?.head,
+        mentionQuery = mentionScope?.query
+    )
+}
+
+internal fun NativeEditorExpoView.isPendingNativeActionScopeCurrent(
+    action: PendingNativeAction,
+    scope: PendingNativeActionScope
+): Boolean {
+    if (scope.editorId != richTextView.editorId) return false
+    if (scope.hadFocus != isEditorEffectivelyFocusedForNativeAction()) return false
+    if (scope.hadVisibleToolbar != isNativeActionToolbarVisible(action)) return false
+    if (
+        scope.documentVersion != lastDocumentVersion &&
+        (
+            scope.allowedDocumentVersion == null ||
+                scope.allowedDocumentVersion != lastDocumentVersion
+            )
+    ) {
+        return false
+    }
+    val selection = richTextView.editorEditText.currentScalarSelection()
+    if (scope.selectionAnchor != selection?.first || scope.selectionHead != selection?.second) {
+        return false
+    }
+    if (action is PendingNativeAction.MentionSuggestionSelect) {
+        val mentions = addons.mentions ?: return false
+        val currentQuery = currentMentionQueryState(mentions.trigger) ?: return false
+        if (
+            scope.mentionAnchor != currentQuery.anchor ||
+            scope.mentionHead != currentQuery.head ||
+            scope.mentionQuery != currentQuery.query
+        ) {
+            return false
+        }
+    }
+    return true
+}
+
+internal fun NativeEditorExpoView.isNativeActionToolbarVisible(
+    action: PendingNativeAction
+): Boolean {
+    if (!showsToolbar || toolbarPlacement != ToolbarPlacement.KEYBOARD) return false
+    if (keyboardToolbarView.parent == null ||
+        keyboardToolbarView.visibility != View.VISIBLE
+    ) {
+        return false
+    }
+    if (action is PendingNativeAction.MentionSuggestionSelect) {
+        return keyboardToolbarView.isShowingMentionSuggestions
+    }
+    return true
+}
+
+internal fun NativeEditorExpoView.isEditorEffectivelyFocusedForNativeAction(): Boolean =
+    richTextView.editorEditText.hasFocus() ||
+        (pendingToolbarRefocus != null && pendingToolbarRefocusEditorId == richTextView.editorId)
+
+internal fun NativeEditorExpoView.clearPendingNativeActionRetryIfScopeChanged() {
+    val action = pendingNativeAction ?: return
+    val scope = pendingNativeActionScope ?: return
+    if (!isPendingNativeActionScopeCurrent(action, scope)) {
+        clearPendingNativeActionRetry()
+    }
+}
+
+internal fun NativeEditorExpoView.schedulePendingNativeActionRetry(action: PendingNativeAction) {
+    val isSameAction = pendingNativeAction == action
+    if (isSameAction) {
+        pendingNativeActionRetryAttempts += 1
+    } else {
+        pendingNativeActionRetryAttempts = 1
+        pendingNativeActionScope = currentNativeActionScope(action)
+    }
+    if (pendingNativeActionRetryAttempts > MAX_NATIVE_ACTION_RETRY_ATTEMPTS) {
+        pendingNativeAction = action
+        pendingNativeActionRetryEditorId = richTextView.editorId
+        pendingNativeActionRetryScheduled = false
+        return
+    }
+    pendingNativeAction = action
+    pendingNativeActionRetryEditorId = richTextView.editorId
+    if (pendingNativeActionRetryScheduled) return
+    pendingNativeActionRetryScheduled = true
+    pendingNativeActionRetryGeneration += 1
+    val retryGeneration = pendingNativeActionRetryGeneration
+    val retry = Runnable {
+        if (retryGeneration != pendingNativeActionRetryGeneration) return@Runnable
+        val retryAction = pendingNativeAction ?: run {
+            pendingNativeActionRetryScheduled = false
+            return@Runnable
+        }
+        val retryScope = pendingNativeActionScope ?: run {
+            clearPendingNativeActionRetry()
+            return@Runnable
+        }
+        if (pendingNativeActionRetryEditorId != richTextView.editorId ||
+            richTextView.editorId == 0L
+        ) {
+            clearPendingNativeActionRetry()
+            return@Runnable
+        }
+        if (!isPendingNativeActionScopeCurrent(retryAction, retryScope)) {
+            clearPendingNativeActionRetry()
+            return@Runnable
+        }
+        pendingNativeActionRetryScheduled = false
+        val allowNextRetry = pendingNativeActionRetryAttempts < MAX_NATIVE_ACTION_RETRY_ATTEMPTS
+        when (retryAction) {
+            is PendingNativeAction.ToolbarItemPress ->
+                handleToolbarItemPress(retryAction.item, allowPreflightRetry = allowNextRetry)
+
+            is PendingNativeAction.MentionSuggestionSelect ->
+                insertMentionSuggestion(
+                    retryAction.suggestion,
+                    allowPreflightRetry = allowNextRetry
+                )
+        }
+    }
+    mainHandler.postDelayed(retry, NATIVE_ACTION_RETRY_DELAY_MS)
+}
+
+internal fun NativeEditorExpoView.retryPendingNativeActionFromWake() {
+    val action = pendingNativeAction ?: return
+    val scope = pendingNativeActionScope ?: run {
+        clearPendingNativeActionRetry()
+        return
+    }
+    if (!isPendingNativeActionScopeCurrent(action, scope)) {
+        clearPendingNativeActionRetry()
+        return
+    }
+    pendingNativeActionRetryAttempts = 0
+    pendingNativeActionRetryScheduled = false
+    when (action) {
+        is PendingNativeAction.ToolbarItemPress ->
+            handleToolbarItemPress(action.item, allowPreflightRetry = true)
+
+        is PendingNativeAction.MentionSuggestionSelect ->
+            insertMentionSuggestion(action.suggestion, allowPreflightRetry = true)
+    }
+}

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

@@ -0,0 +1,214 @@
+package com.apollohg.editor
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.graphics.Point
+import android.graphics.Rect
+import android.graphics.RectF
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.View
+import com.apollohg.editor.NativeEditorExpoView.Companion.OUTSIDE_TAP_HANDLER_INSTALL_RETRY_DELAY_MS
+import com.apollohg.editor.NativeEditorExpoView.Companion.TOOLBAR_FOCUS_PRESERVE_MS
+import com.apollohg.editor.NativeEditorExpoView.Companion.TOOLBAR_HIT_SLOP_DP
+
+internal fun NativeEditorExpoView.installOutsideTapBlurHandlerIfNeeded() {
+    val window = resolveActivity(context)?.window ?: return
+    if (outsideTapWindow !== window) {
+        uninstallOutsideTapBlurHandler()
+    }
+    NativeEditorOutsideTapDispatcher.register(window, this)
+    outsideTapWindow = window
+}
+
+internal fun NativeEditorExpoView.scheduleOutsideTapBlurHandlerInstallRetry() {
+    cancelPendingOutsideTapBlurHandlerInstallRetry()
+    val retry = Runnable {
+        pendingOutsideTapHandlerInstallRetry = null
+        if (richTextView.editorEditText.hasFocus()) {
+            installOutsideTapBlurHandlerIfNeeded()
+        }
+    }
+    pendingOutsideTapHandlerInstallRetry = retry
+    richTextView.editorEditText.postDelayed(retry, OUTSIDE_TAP_HANDLER_INSTALL_RETRY_DELAY_MS)
+}
+
+internal fun NativeEditorExpoView.cancelPendingOutsideTapBlurHandlerInstallRetry() {
+    pendingOutsideTapHandlerInstallRetry?.let {
+        richTextView.editorEditText.removeCallbacks(it)
+        pendingOutsideTapHandlerInstallRetry = null
+    }
+}
+
+internal fun NativeEditorExpoView.uninstallOutsideTapBlurHandler() {
+    cancelPendingOutsideTapBlurHandlerInstallRetry()
+    val window = outsideTapWindow ?: return
+    NativeEditorOutsideTapDispatcher.unregister(window, this)
+    outsideTapWindow = null
+}
+
+internal fun NativeEditorExpoView.prepareOutsideTapDecisionForWindowEventImpl(
+    event: MotionEvent
+): NativeEditorOutsideTapDecision {
+    if (!isAttachedToNativeWindow) {
+        traceOutsideTap("decision ignored detached")
+        return NativeEditorOutsideTapDecision.IGNORE
+    }
+    if (event.action != MotionEvent.ACTION_DOWN) {
+        traceOutsideTap("decision ignored action=${event.action}")
+        return NativeEditorOutsideTapDecision.IGNORE
+    }
+    if (!isEditorFocusedForOutsideTapDecision()) {
+        traceOutsideTap("decision ignored not focused")
+        return NativeEditorOutsideTapDecision.IGNORE
+    }
+
+    val decision = if (isTouchOutsideEditor(event)) {
+        NativeEditorOutsideTapDecision.OUTSIDE_EDITOR
+    } else {
+        NativeEditorOutsideTapDecision.PRESERVE_FOCUS
+    }
+    traceOutsideTap("decision raw=${event.rawX.toInt()},${event.rawY.toInt()} value=$decision")
+    return decision
+}
+
+internal fun NativeEditorExpoView.handleOutsideTapDecisionFromWindowDispatcherImpl(
+    decision: NativeEditorOutsideTapDecision
+) {
+    traceOutsideTap("handle decision=$decision")
+    when (decision) {
+        NativeEditorOutsideTapDecision.IGNORE -> {
+            if (!richTextView.editorEditText.hasFocus()) {
+                cancelPendingOutsideTapBlur()
+            }
+        }
+
+        NativeEditorOutsideTapDecision.PRESERVE_FOCUS -> cancelPendingOutsideTapBlur()
+
+        NativeEditorOutsideTapDecision.OUTSIDE_EDITOR -> {
+            clearRecentToolbarTouch()
+            cancelPendingToolbarRefocus()
+            scheduleOutsideTapBlur()
+        }
+    }
+}
+
+internal fun NativeEditorExpoView.scheduleOutsideTapBlurFromWindowDispatcherImpl() {
+    scheduleOutsideTapBlur()
+}
+
+internal fun NativeEditorExpoView.cancelOutsideTapBlurFromWindowDispatcherImpl() {
+    cancelPendingOutsideTapBlur()
+}
+
+internal fun NativeEditorExpoView.isEditorFocusedForOutsideTapDecision(): Boolean =
+    editorFocusedForOutsideTapOverrideForTesting ?: richTextView.editorEditText.hasFocus()
+
+internal fun NativeEditorExpoView.isTouchOutsideEditor(event: MotionEvent): Boolean {
+    if (isTouchInsideKeyboardToolbar(event)) {
+        markRecentToolbarTouch()
+        return false
+    }
+    if (isTouchInsideStandaloneToolbar(event)) {
+        markRecentToolbarTouch()
+        return false
+    }
+    val rect = Rect()
+    richTextView.editorEditText.getGlobalVisibleRect(rect)
+    val isOutside = !rect.contains(event.rawX.toInt(), event.rawY.toInt())
+    if (isOutside) {
+        clearRecentToolbarTouch()
+    }
+    return isOutside
+}
+
+internal fun NativeEditorExpoView.markRecentToolbarTouch() {
+    lastToolbarTouchUptimeMs = SystemClock.uptimeMillis()
+}
+
+internal fun NativeEditorExpoView.clearRecentToolbarTouch() {
+    lastToolbarTouchUptimeMs = null
+}
+
+internal fun NativeEditorExpoView.shouldPreserveFocusAfterToolbarTouch(): Boolean {
+    val lastToolbarTouch = lastToolbarTouchUptimeMs ?: return false
+    val elapsedMs = SystemClock.uptimeMillis() - lastToolbarTouch
+    return elapsedMs in 0L..TOOLBAR_FOCUS_PRESERVE_MS
+}
+
+internal fun NativeEditorExpoView.consumeToolbarFocusPreservationForBlur(): Boolean {
+    if (!shouldPreserveFocusAfterToolbarTouch()) {
+        return false
+    }
+    clearRecentToolbarTouch()
+    return true
+}
+
+internal fun NativeEditorExpoView.isTouchInsideStandaloneToolbar(event: MotionEvent): Boolean =
+    isPointInsideStandaloneToolbar(event.rawX, event.rawY, windowOriginOnScreen())
+
+internal fun NativeEditorExpoView.windowOriginOnScreen(): Point {
+    val onScreen = IntArray(2)
+    val inWindow = IntArray(2)
+    getLocationOnScreen(onScreen)
+    getLocationInWindow(inWindow)
+    return Point(onScreen[0] - inWindow[0], onScreen[1] - inWindow[1])
+}
+
+internal fun NativeEditorExpoView.isPointInsideStandaloneToolbarForTestingImpl(
+    rawX: Float,
+    rawY: Float,
+    windowOriginOnScreen: Point
+): Boolean = isPointInsideStandaloneToolbar(rawX, rawY, windowOriginOnScreen)
+
+internal fun NativeEditorExpoView.isPointInsideStandaloneToolbar(
+    rawX: Float,
+    rawY: Float,
+    windowOriginOnScreen: Point
+): Boolean {
+    if (toolbarFramesInWindow.isEmpty()) {
+        return false
+    }
+    // toolbarFrame is in DP from Fabric's measureInWindow, which offsets by
+    // the surface's getLocationInWindow. rawX/rawY are screen pixels, so
+    // normalize them into the same window space rather than the visible
+    // display frame, whose top also excludes the status bar and cutout.
+    val density = resources.displayMetrics.density
+    val hitSlopPx = TOOLBAR_HIT_SLOP_DP * density
+    val eventX = rawX - windowOriginOnScreen.x
+    val eventY = rawY - windowOriginOnScreen.y
+    for (toolbarFrame in toolbarFramesInWindow) {
+        val windowFrameInPx = RectF(
+            toolbarFrame.left * density,
+            toolbarFrame.top * density,
+            toolbarFrame.right * density,
+            toolbarFrame.bottom * density
+        ).apply {
+            inset(-hitSlopPx, -hitSlopPx)
+        }
+        if (windowFrameInPx.contains(eventX, eventY)) {
+            return true
+        }
+    }
+    return false
+}
+
+internal fun NativeEditorExpoView.isTouchInsideKeyboardToolbar(event: MotionEvent): Boolean {
+    if (keyboardToolbarView.parent == null || keyboardToolbarView.visibility != View.VISIBLE) {
+        return false
+    }
+    val rect = Rect()
+    keyboardToolbarView.getGlobalVisibleRect(rect)
+    return rect.contains(event.rawX.toInt(), event.rawY.toInt())
+}
+
+internal fun NativeEditorExpoView.resolveActivity(context: Context): Activity? {
+    appContext.currentActivity?.let { return it }
+    var current: Context? = context
+    while (current is ContextWrapper) {
+        if (current is Activity) return current
+        current = current.baseContext
+    }
+    return null
+}