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

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

@@ -0,0 +1,197 @@
+package com.apollohg.editor
+
+import android.os.Looper
+import com.apollohg.editor.NativeEditorExpoView.Companion.MAX_PENDING_UPDATE_RETRY_ATTEMPTS
+import com.apollohg.editor.NativeEditorExpoView.Companion.NATIVE_ACTION_RETRY_DELAY_MS
+import com.apollohg.editor.NativeEditorExpoView.PendingPropertyRetry
+import com.apollohg.editor.NativeEditorExpoView.PendingPropertyRetryResult
+
+internal fun NativeEditorExpoView.clearPendingThemeRetry() {
+    pendingThemeJson = null
+    hasPendingTheme = false
+    cancelPendingThemeRetry()
+}
+
+internal fun NativeEditorExpoView.cancelPendingThemeRetry() {
+    pendingThemeRetry.cancel()
+}
+
+internal fun NativeEditorExpoView.applyPendingThemeIfNeeded() {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (!hasPendingTheme) return
+    val themeJson = pendingThemeJson
+    val editorId = richTextView.editorId
+    if (pendingThemeRetry.editorId != editorId) {
+        pendingThemeRetry.bind(editorId)
+    }
+    if (
+        blockThemePreflightForTesting ||
+        !richTextView.editorEditText.prepareForExternalEditorUpdate()
+    ) {
+        schedulePendingThemeRetry()
+        return
+    }
+    pendingThemeJson = null
+    hasPendingTheme = false
+    cancelPendingThemeRetry()
+    applyThemeJson(themeJson)
+}
+
+internal fun NativeEditorExpoView.schedulePendingThemeRetry() {
+    schedulePendingPropertyRetry(
+        pendingThemeRetry,
+        onEditorChanged = ::clearPendingThemeRetry,
+        apply = ::applyPendingThemeIfNeeded
+    )
+}
+
+internal fun NativeEditorExpoView.cancelPendingAtomsRetry() {
+    pendingAtomsRetry.cancel()
+}
+
+internal fun NativeEditorExpoView.applyPendingAtomsIfNeeded() {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (!hasPendingAtoms) return
+    val atomsJson = pendingAtomsJson
+    val editorId = richTextView.editorId
+    if (pendingAtomsRetry.editorId != editorId) {
+        pendingAtomsRetry.bind(editorId)
+    }
+    val configuration = AtomRenderConfiguration.fromJson(atomsJson)
+    if (!richTextView.applyAtomRenderConfiguration(configuration)) {
+        schedulePendingAtomsRetry()
+        return
+    }
+    lastAtomsJson = atomsJson
+    pendingAtomsJson = null
+    hasPendingAtoms = false
+    cancelPendingAtomsRetry()
+}
+
+internal fun NativeEditorExpoView.schedulePendingAtomsRetry() {
+    schedulePendingPropertyRetry(
+        pendingAtomsRetry,
+        onEditorChanged = ::cancelPendingAtomsRetry,
+        apply = ::applyPendingAtomsIfNeeded
+    )
+}
+
+internal fun NativeEditorExpoView.schedulePendingPropertyRetry(
+    state: PendingPropertyRetry,
+    onEditorChanged: () -> Unit,
+    apply: () -> Unit
+) {
+    val (generation, attempt) = state.schedule(
+        richTextView.editorId,
+        MAX_PENDING_UPDATE_RETRY_ATTEMPTS
+    ) ?: return
+    val retry = Runnable {
+        when (state.consume(generation, richTextView.editorId)) {
+            PendingPropertyRetryResult.STALE -> return@Runnable
+            PendingPropertyRetryResult.EDITOR_CHANGED -> onEditorChanged()
+            PendingPropertyRetryResult.READY -> apply()
+        }
+    }
+    mainHandler.postDelayed(retry, NATIVE_ACTION_RETRY_DELAY_MS * attempt)
+}
+
+internal fun NativeEditorExpoView.clearPendingViewCommandUpdateRetry() {
+    pendingViewCommandUpdateJson = null
+    pendingViewCommandUpdateEditorId = null
+    pendingViewCommandUpdateRetryScheduled = false
+    pendingViewCommandUpdateRetryAttempts = 0
+    pendingViewCommandUpdateRetryGeneration += 1
+}
+
+internal fun NativeEditorExpoView.scheduleViewCommandUpdateRetry(updateJson: String) {
+    if (pendingViewCommandUpdateJson != updateJson) {
+        pendingViewCommandUpdateRetryAttempts = 0
+    }
+    pendingViewCommandUpdateJson = updateJson
+    pendingViewCommandUpdateEditorId = richTextView.editorId
+    if (pendingViewCommandUpdateRetryScheduled) return
+    if (pendingViewCommandUpdateRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS) return
+    pendingViewCommandUpdateRetryAttempts += 1
+    pendingViewCommandUpdateRetryScheduled = true
+    pendingViewCommandUpdateRetryGeneration += 1
+    val retryGeneration = pendingViewCommandUpdateRetryGeneration
+    val delayMs = NATIVE_ACTION_RETRY_DELAY_MS * pendingViewCommandUpdateRetryAttempts
+    val retry = Runnable {
+        if (retryGeneration != pendingViewCommandUpdateRetryGeneration) return@Runnable
+        val retryJson = pendingViewCommandUpdateJson ?: run {
+            pendingViewCommandUpdateRetryScheduled = false
+            return@Runnable
+        }
+        if (pendingViewCommandUpdateEditorId != richTextView.editorId ||
+            richTextView.editorId == 0L
+        ) {
+            clearPendingViewCommandUpdateRetry()
+            return@Runnable
+        }
+        if (handleDestroyedCurrentEditorIfNeeded()) {
+            clearPendingViewCommandUpdateRetry()
+            return@Runnable
+        }
+        pendingViewCommandUpdateRetryScheduled = false
+        if (
+            applyEditorUpdateOutcome(retryJson, scheduleViewCommandRetry = true) !=
+            PendingEditorUpdateApplyOutcome.RETRYABLE_DEFERRED
+        ) {
+            clearPendingViewCommandUpdateRetry()
+        }
+    }
+    mainHandler.postDelayed(retry, delayMs)
+}
+
+internal fun NativeEditorExpoView.schedulePendingPreflightWake() {
+    if (pendingPreflightWakeScheduled) return
+    pendingPreflightWakeScheduled = true
+    pendingPreflightWakeGeneration += 1
+    val wakeGeneration = pendingPreflightWakeGeneration
+    mainHandler.post {
+        if (wakeGeneration != pendingPreflightWakeGeneration) return@post
+        pendingPreflightWakeScheduled = false
+        wakePendingPreflightWork()
+    }
+}
+
+internal fun NativeEditorExpoView.cancelPendingPreflightWake() {
+    pendingPreflightWakeScheduled = false
+    pendingPreflightWakeGeneration += 1
+}
+
+internal fun NativeEditorExpoView.wakePendingPreflightWork() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+        schedulePendingPreflightWake()
+        return
+    }
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (pendingEditorResetUpdateJson != null) {
+        applyPendingEditorResetUpdateIfNeeded()
+    }
+    if (pendingEditorUpdateJson != null) {
+        pendingEditorUpdateRetryAttempts = 0
+        pendingEditorUpdateForcedRecoveryAttempted = false
+        applyPendingEditorUpdateIfNeeded()
+    }
+    if (hasPendingTheme) {
+        pendingThemeRetry.resetAttempts()
+        applyPendingThemeIfNeeded()
+    }
+    if (hasPendingAtoms) {
+        pendingAtomsRetry.resetAttempts()
+        applyPendingAtomsIfNeeded()
+    }
+    pendingViewCommandUpdateJson?.let { updateJson ->
+        pendingViewCommandUpdateRetryAttempts = 0
+        pendingViewCommandUpdateRetryScheduled = false
+        pendingViewCommandUpdateRetryGeneration += 1
+        if (
+            applyEditorUpdateOutcome(updateJson, scheduleViewCommandRetry = true) !=
+            PendingEditorUpdateApplyOutcome.RETRYABLE_DEFERRED
+        ) {
+            clearPendingViewCommandUpdateRetry()
+        }
+    }
+    retryPendingNativeActionFromWake()
+}

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

@@ -0,0 +1,285 @@
+package com.apollohg.editor
+
+import android.view.Gravity
+import android.view.View
+import android.view.View.MeasureSpec
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.ScrollView
+import androidx.core.view.ViewCompat
+import androidx.core.widget.NestedScrollView
+import com.apollohg.editor.NativeEditorExpoView.PendingNativeAction
+import com.apollohg.editor.NativeEditorExpoView.PreflightUpdateEvent
+import com.apollohg.editor.NativeEditorExpoView.ToolbarPlacement
+
+internal fun NativeEditorExpoView.refreshToolbarStateFromEditorSelection(): String? {
+    if (richTextView.editorId == 0L) return null
+    if (handleDestroyedCurrentEditorIfNeeded()) return null
+    onRefreshToolbarStateFromEditorSelectionForTesting?.let { callback ->
+        val stateJson = callback()
+        noteDocumentVersionFromUpdateJSON(stateJson)
+        return stateJson
+    }
+    val stateJson = richTextView.editorEditText.v2Driver?.currentStateJson() ?: return null
+    noteDocumentVersionFromUpdateJSON(stateJson)
+    val state = NativeToolbarState.fromUpdateJson(stateJson) ?: return null
+    toolbarState = state
+    keyboardToolbarView.applyState(state)
+    return stateJson
+}
+
+internal fun NativeEditorExpoView.ensureKeyboardToolbarAttached() {
+    val host = resolveActivity(context)?.findViewById<ViewGroup>(android.R.id.content) ?: return
+    pendingKeyboardToolbarDetachGeneration += 1
+    if (keyboardToolbarView.parent === host) {
+        updateKeyboardToolbarLayout()
+        return
+    }
+    (keyboardToolbarView.parent as? ViewGroup)?.removeView(keyboardToolbarView)
+    host.addView(
+        keyboardToolbarView,
+        FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            Gravity.BOTTOM or Gravity.START
+        )
+    )
+    updateKeyboardToolbarLayout()
+    ViewCompat.requestApplyInsets(keyboardToolbarView)
+}
+
+internal fun NativeEditorExpoView.detachKeyboardToolbarIfNeeded() {
+    pendingKeyboardToolbarDetachGeneration += 1
+    val generation = pendingKeyboardToolbarDetachGeneration
+    val parent = keyboardToolbarView.parent as? ViewGroup ?: return
+    keyboardToolbarImeAnimationController.cancel()
+    keyboardToolbarView.visibility = View.GONE
+    parent.post {
+        if (generation != pendingKeyboardToolbarDetachGeneration) return@post
+        if (keyboardToolbarView.parent === parent) {
+            parent.removeView(keyboardToolbarView)
+        }
+    }
+}
+
+internal fun NativeEditorExpoView.updateKeyboardToolbarLayout() {
+    val params = keyboardToolbarView.layoutParams as? FrameLayout.LayoutParams ?: return
+    val toolbarTheme = richTextView.editorEditText.theme?.toolbar
+    val density = resources.displayMetrics.density
+    params.gravity = Gravity.BOTTOM or Gravity.START
+    val horizontalInsetPx = ((toolbarTheme?.resolvedHorizontalInset() ?: 0f) * density).toInt()
+    val keyboardOffsetPx = ((toolbarTheme?.resolvedKeyboardOffset() ?: 0f) * density).toInt()
+    params.leftMargin = horizontalInsetPx
+    params.rightMargin = horizontalInsetPx
+    params.bottomMargin = currentImeBottom + keyboardOffsetPx
+    keyboardToolbarView.layoutParams = params
+}
+
+internal fun NativeEditorExpoView.updateAttachedKeyboardToolbarForInsets() {
+    if (currentImeBottom <= 0) {
+        clearPendingNativeActionRetry()
+    }
+    keyboardToolbarView.visibility = if (currentImeBottom > 0) View.VISIBLE else View.INVISIBLE
+    updateEditorViewportInset()
+}
+
+internal fun NativeEditorExpoView.updateKeyboardToolbarVisibility() {
+    val shouldAttach =
+        showsToolbar &&
+            canFocusCurrentEditor() &&
+            toolbarPlacement == ToolbarPlacement.KEYBOARD &&
+            richTextView.editorEditText.isEditable &&
+            richTextView.editorEditText.hasFocus()
+
+    if (!shouldAttach) {
+        keyboardToolbarView.visibility = View.GONE
+        detachKeyboardToolbarIfNeeded()
+        updateEditorViewportInset()
+        return
+    }
+
+    ensureKeyboardToolbarAttached()
+    keyboardToolbarView.visibility = if (currentImeBottom > 0) View.VISIBLE else View.INVISIBLE
+    updateEditorViewportInset()
+}
+
+internal fun NativeEditorExpoView.updateEditorViewportInset(forceMeasureToolbar: Boolean = false) {
+    val shouldReserveToolbarSpace =
+        showsToolbar &&
+            toolbarPlacement == ToolbarPlacement.KEYBOARD &&
+            richTextView.editorEditText.isEditable &&
+            richTextView.editorEditText.hasFocus() &&
+            currentImeBottom > 0
+
+    if (!shouldReserveToolbarSpace) {
+        richTextView.setViewportBottomOcclusionTopOnScreenPx(null)
+        richTextView.setViewportBottomInsetPx(0)
+        return
+    }
+
+    val hostWidth = (
+        resolveActivity(context)?.findViewById<ViewGroup>(android.R.id.content)?.width
+            ?: width
+        )
+        .coerceAtLeast(0)
+    val toolbarTheme = richTextView.editorEditText.theme?.toolbar
+    val density = resources.displayMetrics.density
+    val horizontalInsetPx = ((toolbarTheme?.resolvedHorizontalInset() ?: 0f) * density).toInt()
+    if (forceMeasureToolbar || keyboardToolbarView.measuredHeight == 0) {
+        val availableWidth = (hostWidth - horizontalInsetPx * 2).coerceAtLeast(0)
+        val widthSpec = MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST)
+        val heightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
+        keyboardToolbarView.measure(widthSpec, heightSpec)
+    }
+    val toolbarHeight = keyboardToolbarView.measuredHeight.coerceAtLeast(keyboardToolbarView.height)
+    val keyboardOffsetPx = ((toolbarTheme?.resolvedKeyboardOffset() ?: 0f) * density).toInt()
+    val toolbarTopOnScreenPx = resolveToolbarTopOnScreenPx(
+        toolbarHeight = toolbarHeight,
+        keyboardOffsetPx = keyboardOffsetPx
+    )
+    richTextView.setViewportBottomOcclusionTopOnScreenPx(toolbarTopOnScreenPx)
+    richTextView.setViewportBottomInsetPx(
+        resolveToolbarViewportInsetPx(
+            toolbarHeight = toolbarHeight,
+            keyboardOffsetPx = keyboardOffsetPx,
+            toolbarTopOnScreenPx = toolbarTopOnScreenPx
+        )
+    )
+}
+
+internal fun NativeEditorExpoView.resolveToolbarTopOnScreenPx(
+    toolbarHeight: Int,
+    keyboardOffsetPx: Int
+): Int? {
+    val host = resolveActivity(context)?.findViewById<ViewGroup>(android.R.id.content)
+        ?: return null
+    if (host.height <= 0) return null
+    val hostLocation = IntArray(2)
+    host.getLocationOnScreen(hostLocation)
+    return hostLocation[1] + host.height - currentImeBottom - keyboardOffsetPx - toolbarHeight
+}
+
+internal fun NativeEditorExpoView.resolveToolbarViewportInsetPx(
+    toolbarHeight: Int,
+    keyboardOffsetPx: Int,
+    toolbarTopOnScreenPx: Int?
+): Int {
+    val fallbackInset = (toolbarHeight + keyboardOffsetPx).coerceAtLeast(0)
+    val toolbarTop = toolbarTopOnScreenPx ?: return fallbackInset
+    var foundScrollViewport = false
+    var viewportInset = 0
+
+    fun includeScrollViewport(view: View) {
+        if (view.height <= 0) return
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        foundScrollViewport = true
+        viewportInset = maxOf(viewportInset, location[1] + view.height - toolbarTop)
+    }
+
+    if (heightBehavior == EditorHeightBehavior.FIXED) {
+        includeScrollViewport(richTextView.editorScrollView)
+    } else {
+        var ancestor = parent
+        while (ancestor is View) {
+            if (ancestor is ScrollView || ancestor is NestedScrollView) {
+                includeScrollViewport(ancestor)
+            }
+            ancestor = (ancestor as View).parent
+        }
+    }
+
+    return if (foundScrollViewport) viewportInset.coerceAtLeast(0) else fallbackInset
+}
+
+internal fun NativeEditorExpoView.handleListToggle(listType: String) {
+    val isActive = toolbarState.nodes[listType] == true
+    richTextView.editorEditText.performToolbarToggleList(listType, isActive)
+}
+
+internal fun NativeEditorExpoView.handleToolbarItemPress(
+    item: NativeToolbarItem,
+    allowPreflightRetry: Boolean = true
+) {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (!richTextView.editorEditText.isEditable) {
+        clearPendingNativeActionRetry()
+        return
+    }
+    var preflightUpdate: PreflightUpdateEvent? = null
+    val needsEditorPreflight = when (item.type) {
+        ToolbarItemKind.MARK,
+        ToolbarItemKind.HEADING,
+        ToolbarItemKind.BLOCKQUOTE,
+        ToolbarItemKind.LIST,
+        ToolbarItemKind.COMMAND,
+        ToolbarItemKind.NODE,
+        ToolbarItemKind.ACTION -> true
+
+        ToolbarItemKind.GROUP,
+        ToolbarItemKind.SEPARATOR -> false
+    }
+    if (needsEditorPreflight) {
+        if (shouldBlockEditorCommandForPendingUpdate()) {
+            if (allowPreflightRetry) {
+                schedulePendingNativeActionRetry(PendingNativeAction.ToolbarItemPress(item))
+            }
+            return
+        }
+        val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
+        if (!preparation.ready) {
+            if (allowPreflightRetry) {
+                schedulePendingNativeActionRetry(PendingNativeAction.ToolbarItemPress(item))
+            }
+            return
+        }
+        preflightUpdate = preflightUpdateEventFromJSON(preparation.updateJSON)
+        preflightUpdate?.let { lastDocumentVersion = it.documentRevision }
+        clearPendingNativeActionRetry()
+    }
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    when (item.type) {
+        ToolbarItemKind.MARK -> item.mark?.let {
+            richTextView.editorEditText.performToolbarToggleMark(it)
+        }
+
+        ToolbarItemKind.HEADING -> item.headingLevel?.let {
+            richTextView.editorEditText.performToolbarToggleHeading(it)
+        }
+
+        ToolbarItemKind.BLOCKQUOTE -> richTextView.editorEditText.performToolbarToggleBlockquote()
+
+        ToolbarItemKind.LIST -> item.listType?.wireValue?.let { handleListToggle(it) }
+
+        ToolbarItemKind.COMMAND -> when (item.command) {
+            ToolbarCommand.INDENT_LIST -> richTextView.editorEditText.performToolbarIndentListItem()
+
+            ToolbarCommand.OUTDENT_LIST ->
+                richTextView.editorEditText.performToolbarOutdentListItem()
+
+            ToolbarCommand.UNDO -> richTextView.editorEditText.performToolbarUndo()
+
+            ToolbarCommand.REDO -> richTextView.editorEditText.performToolbarRedo()
+
+            null -> Unit
+        }
+
+        ToolbarItemKind.NODE -> item.nodeType?.let {
+            richTextView.editorEditText.performToolbarInsertNode(it)
+        }
+
+        ToolbarItemKind.ACTION -> item.key?.let {
+            if (handleDestroyedCurrentEditorIfNeeded()) return
+            val payload = mutableMapOf<String, Any>(
+                "key" to it,
+                "editorId" to eventEditorId(richTextView.editorId)
+            )
+            addPreflightUpdateToEvent(payload, preflightUpdate)
+            onToolbarActionForTesting?.invoke(payload) ?: onToolbarAction(payload)
+        }
+
+        ToolbarItemKind.GROUP -> Unit
+
+        ToolbarItemKind.SEPARATOR -> Unit
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.apollohg.editor
+
+import java.util.concurrent.atomic.AtomicLong
+
+internal const val ATOM_NATIVE_ID_PREFIX = "prose-atom:"
+internal val nextNativeEditorErrorCallbackToken = AtomicLong(0)
+
+internal enum class NativeEditorOutsideTapDecision {
+    IGNORE,
+    PRESERVE_FOCUS,
+    OUTSIDE_EDITOR
+}
+
+internal data class NativeEditorOutsideTapRouteTestState(
+    val isRegistered: Boolean,
+    val hasCallbackReconciler: Boolean
+)
+
+internal enum class PendingEditorUpdateApplyOutcome {
+    APPLIED,
+    RETRYABLE_DEFERRED,
+    PERMANENTLY_REJECTED
+}
+
+internal enum class PendingEditorUpdateKind {
+    ORDINARY,
+    RESET
+}