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

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

@@ -0,0 +1,376 @@
+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.Companion.PENDING_UPDATE_RECOVERY_RETRY_DELAY_MS
+
+internal fun NativeEditorExpoView.setPendingEditorUpdateJsonImpl(editorUpdateJson: String?) {
+    lastEditorUpdateJsonProp = editorUpdateJson
+    pendingEditorUpdateJson = editorUpdateJson
+}
+
+internal fun NativeEditorExpoView.setPendingEditorUpdateEditorHandleImpl(
+    editorUpdateEditorHandle: String?
+) {
+    val viewToken = editorUpdateEditorHandle?.let(EditorV2Registry::viewTokenForHandle)
+    lastEditorUpdateEditorIdProp = viewToken
+    pendingEditorUpdateEditorId = viewToken
+}
+
+/** Internal widget/test hook; production props always use decimal handles. */
+internal fun NativeEditorExpoView.setPendingEditorUpdateEditorIdImpl(viewToken: Long?) {
+    lastEditorUpdateEditorIdProp = viewToken
+    pendingEditorUpdateEditorId = viewToken
+}
+
+internal fun NativeEditorExpoView.setPendingEditorUpdateRevisionImpl(editorUpdateRevision: Long) {
+    if (pendingEditorUpdateRevision != editorUpdateRevision) {
+        pendingEditorUpdateRetryAttempts = 0
+        pendingEditorUpdateForcedRecoveryAttempted = false
+    }
+    if (editorUpdateRevision != 0L && pendingEditorUpdateJson == null) {
+        pendingEditorUpdateJson = lastEditorUpdateJsonProp
+    }
+    if (editorUpdateRevision != 0L && pendingEditorUpdateEditorId == null) {
+        pendingEditorUpdateEditorId = lastEditorUpdateEditorIdProp
+    }
+    pendingEditorUpdateRevision = editorUpdateRevision
+}
+
+internal fun NativeEditorExpoView.setPendingEditorResetUpdateJsonImpl(
+    editorResetUpdateJson: String?
+) {
+    lastEditorResetUpdateJsonProp = editorResetUpdateJson
+    pendingEditorResetUpdateJson = editorResetUpdateJson
+}
+
+internal fun NativeEditorExpoView.setPendingEditorResetUpdateEditorHandleImpl(
+    editorResetUpdateEditorHandle: String?
+) {
+    val viewToken = editorResetUpdateEditorHandle?.let(EditorV2Registry::viewTokenForHandle)
+    lastEditorResetUpdateEditorIdProp = viewToken
+    pendingEditorResetUpdateEditorId = viewToken
+}
+
+/** Internal widget/test hook; production props always use decimal handles. */
+internal fun NativeEditorExpoView.setPendingEditorResetUpdateEditorIdImpl(viewToken: Long?) {
+    lastEditorResetUpdateEditorIdProp = viewToken
+    pendingEditorResetUpdateEditorId = viewToken
+}
+
+internal fun NativeEditorExpoView.setPendingEditorResetUpdateRevisionImpl(
+    editorResetUpdateRevision: Long
+) {
+    if (pendingEditorResetUpdateRevision != editorResetUpdateRevision) {
+        pendingEditorUpdateRetryAttempts = 0
+        pendingEditorUpdateForcedRecoveryAttempted = false
+    }
+    if (editorResetUpdateRevision != 0L && pendingEditorResetUpdateJson == null) {
+        pendingEditorResetUpdateJson = lastEditorResetUpdateJsonProp
+    }
+    if (editorResetUpdateRevision != 0L && pendingEditorResetUpdateEditorId == null) {
+        pendingEditorResetUpdateEditorId = lastEditorResetUpdateEditorIdProp
+    }
+    pendingEditorResetUpdateRevision = editorResetUpdateRevision
+}
+
+internal fun NativeEditorExpoView.isConsumedEditorUpdateRevision(
+    editorId: Long,
+    revision: Long
+): Boolean = revision != 0L &&
+    consumedEditorUpdateEditorId == editorId &&
+    consumedEditorUpdateRevision == revision
+
+internal fun NativeEditorExpoView.isConsumedEditorResetUpdateRevision(
+    editorId: Long,
+    revision: Long
+): Boolean = revision != 0L &&
+    consumedEditorResetUpdateEditorId == editorId &&
+    consumedEditorResetUpdateRevision == revision
+
+internal fun NativeEditorExpoView.consumeEditorUpdateRevision(editorId: Long, revision: Long) {
+    consumedEditorUpdateEditorId = editorId
+    consumedEditorUpdateRevision = revision
+}
+
+internal fun NativeEditorExpoView.consumeEditorResetUpdateRevision(editorId: Long, revision: Long) {
+    consumedEditorResetUpdateEditorId = editorId
+    consumedEditorResetUpdateRevision = revision
+}
+
+internal fun NativeEditorExpoView.hasPendingEditorUpdateForEditor(editorId: Long): Boolean =
+    pendingEditorUpdateJson != null &&
+        pendingEditorUpdateRevision != 0L &&
+        pendingEditorUpdateRevision != appliedEditorUpdateRevision &&
+        !isConsumedEditorUpdateRevision(editorId, pendingEditorUpdateRevision) &&
+        pendingEditorUpdateEditorId == editorId
+
+internal fun NativeEditorExpoView.hasPendingEditorResetUpdateForEditor(editorId: Long): Boolean =
+    pendingEditorResetUpdateJson != null &&
+        pendingEditorResetUpdateRevision != 0L &&
+        pendingEditorResetUpdateRevision != appliedEditorResetUpdateRevision &&
+        !isConsumedEditorResetUpdateRevision(editorId, pendingEditorResetUpdateRevision) &&
+        pendingEditorResetUpdateEditorId == editorId
+
+internal fun NativeEditorExpoView.hasPendingEditorUpdateForCurrentEditor(): Boolean =
+    hasPendingEditorUpdateForEditor(richTextView.editorId)
+
+internal fun NativeEditorExpoView.hasPendingEditorResetUpdateForCurrentEditor(): Boolean =
+    hasPendingEditorResetUpdateForEditor(richTextView.editorId)
+
+internal fun NativeEditorExpoView.pendingEditorUpdateCommandPreparationJSON(): String =
+    NativeEditorViewRegistry.commandPreparationJSON(
+        ready = false,
+        blockedReason = "pendingUpdate"
+    )
+
+internal fun NativeEditorExpoView.shouldBlockEditorCommandForPendingUpdate(): Boolean =
+    hasPendingEditorResetUpdateForCurrentEditor() || hasPendingEditorUpdateForCurrentEditor()
+
+internal fun NativeEditorExpoView.refreshReadyStateIfSettled() {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (hasPendingEditorResetUpdateForCurrentEditor()) return
+    if (hasPendingEditorUpdateForCurrentEditor()) return
+    if (!isAttachedToNativeWindow) return
+    if (richTextView.editorEditText.editorId != richTextView.editorId) return
+    refreshToolbarStateFromEditorSelection()
+    refreshMentionQuery()
+    emitEditorReadyIfNeeded()
+}
+
+internal fun NativeEditorExpoView.applyPendingEditorResetUpdateIfNeededImpl() {
+    if (handleDestroyedCurrentEditorIfNeeded()) return
+    if (pendingEditorResetUpdateRevision == 0L) return
+    val revision = pendingEditorResetUpdateRevision
+    val editorId = richTextView.editorId
+    val expectedEditorId = pendingEditorResetUpdateEditorId
+    if (expectedEditorId == null) return
+    if (expectedEditorId != editorId) return
+    if (isConsumedEditorResetUpdateRevision(editorId, revision)) {
+        clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+        refreshReadyStateIfSettled()
+        return
+    }
+    if (pendingEditorResetUpdateJson == null) {
+        clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+        refreshReadyStateIfSettled()
+        return
+    }
+    val updateJson = pendingEditorResetUpdateJson ?: return
+    if (revision == appliedEditorResetUpdateRevision) {
+        clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+        emitEditorReady(editorUpdateRevision = revision)
+        refreshReadyStateIfSettled()
+        return
+    }
+    if (editorId != 0L && !isAttachedToNativeWindow) return
+    val apply = Runnable {
+        if (editorId != richTextView.editorId) return@Runnable
+        if (expectedEditorId != richTextView.editorId) return@Runnable
+        if (editorId != 0L && !isAttachedToNativeWindow) return@Runnable
+        if (revision != pendingEditorResetUpdateRevision) return@Runnable
+        if (revision == appliedEditorResetUpdateRevision) {
+            clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+            emitEditorReady(editorUpdateRevision = revision)
+            refreshReadyStateIfSettled()
+            return@Runnable
+        }
+        when (applyEditorResetUpdateOutcome(updateJson)) {
+            PendingEditorUpdateApplyOutcome.APPLIED -> {
+                appliedEditorResetUpdateRevision = revision
+                clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+                emitEditorReady(editorUpdateRevision = revision)
+                refreshReadyStateIfSettled()
+            }
+
+            PendingEditorUpdateApplyOutcome.RETRYABLE_DEFERRED -> {
+                schedulePendingEditorUpdateRetry(PendingEditorUpdateKind.RESET)
+            }
+
+            PendingEditorUpdateApplyOutcome.PERMANENTLY_REJECTED -> {
+                consumeEditorResetUpdateRevision(editorId, revision)
+                clearPendingEditorResetUpdateState(resetAppliedRevision = false)
+                refreshReadyStateIfSettled()
+            }
+        }
+    }
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+        apply.run()
+    } else if (!post(apply)) {
+        richTextView.post(apply)
+    }
+}
+
+internal fun NativeEditorExpoView.applyPendingEditorUpdateIfNeededImpl() {
+    if (handleDestroyedCurrentEditorIfNeeded()) {
+        return
+    }
+    if (pendingEditorUpdateRevision == 0L) {
+        return
+    }
+    val revision = pendingEditorUpdateRevision
+    val editorId = richTextView.editorId
+    val expectedEditorId = pendingEditorUpdateEditorId
+    if (expectedEditorId == null) {
+        return
+    }
+    if (expectedEditorId != editorId) {
+        return
+    }
+    if (isConsumedEditorUpdateRevision(editorId, revision)) {
+        clearPendingEditorUpdateState(resetAppliedRevision = false)
+        refreshReadyStateIfSettled()
+        return
+    }
+    if (pendingEditorUpdateJson == null) {
+        clearPendingEditorUpdateState(resetAppliedRevision = false)
+        refreshReadyStateIfSettled()
+        return
+    }
+    val updateJson = pendingEditorUpdateJson ?: return
+    if (pendingEditorUpdateRevision == appliedEditorUpdateRevision) {
+        clearPendingEditorUpdateState(resetAppliedRevision = false)
+        emitEditorReady(editorUpdateRevision = revision)
+        refreshReadyStateIfSettled()
+        return
+    }
+    if (editorId != 0L && !isAttachedToNativeWindow) {
+        return
+    }
+    val apply = Runnable {
+        if (editorId != richTextView.editorId) return@Runnable
+        if (expectedEditorId != richTextView.editorId) return@Runnable
+        if (editorId != 0L && !isAttachedToNativeWindow) return@Runnable
+        if (revision != pendingEditorUpdateRevision) return@Runnable
+        if (revision == appliedEditorUpdateRevision) {
+            clearPendingEditorUpdateState(resetAppliedRevision = false)
+            emitEditorReady(editorUpdateRevision = revision)
+            refreshReadyStateIfSettled()
+            return@Runnable
+        }
+        val resetJson = pendingEditorUpdateResetJson
+        val outcome = if (resetJson != null) {
+            applyEditorResetUpdateOutcome(updateJson, resetJson)
+        } else {
+            applyEditorUpdateOutcome(
+                updateJson,
+                scheduleViewCommandRetry = false
+            )
+        }
+        when (outcome) {
+            PendingEditorUpdateApplyOutcome.APPLIED -> {
+                appliedEditorUpdateRevision = revision
+                pendingEditorUpdateJson = null
+                pendingEditorUpdateEditorId = null
+                pendingEditorUpdateRevision = 0L
+                pendingEditorUpdateRetryAttempts = 0
+                pendingEditorUpdateForcedRecoveryAttempted = false
+                cancelPendingEditorUpdateRetry(PendingEditorUpdateKind.ORDINARY)
+                emitEditorReady(editorUpdateRevision = revision)
+                refreshReadyStateIfSettled()
+            }
+
+            PendingEditorUpdateApplyOutcome.RETRYABLE_DEFERRED -> {
+                schedulePendingEditorUpdateRetry(PendingEditorUpdateKind.ORDINARY)
+            }
+
+            PendingEditorUpdateApplyOutcome.PERMANENTLY_REJECTED -> {
+                consumeEditorUpdateRevision(editorId, revision)
+                clearPendingEditorUpdateState(resetAppliedRevision = false)
+                refreshReadyStateIfSettled()
+            }
+        }
+    }
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+        apply.run()
+    } else if (!post(apply)) {
+        richTextView.post(apply)
+    }
+}
+
+internal fun NativeEditorExpoView.clearPendingEditorUpdateState(
+    resetAppliedRevision: Boolean = true
+) {
+    pendingEditorUpdateJson = null
+    pendingEditorUpdateEditorId = null
+    pendingEditorUpdateRevision = 0L
+    if (resetAppliedRevision) {
+        pendingEditorUpdateResetJson = null
+        appliedEditorUpdateRevision = 0L
+    }
+    cancelPendingEditorUpdateRetry(PendingEditorUpdateKind.ORDINARY)
+}
+
+internal fun NativeEditorExpoView.clearPendingEditorResetUpdateState(
+    resetAppliedRevision: Boolean = true
+) {
+    pendingEditorResetUpdateJson = null
+    pendingEditorResetUpdateEditorId = null
+    pendingEditorResetUpdateRevision = 0L
+    if (resetAppliedRevision) {
+        appliedEditorResetUpdateRevision = 0L
+    }
+    cancelPendingEditorUpdateRetry(PendingEditorUpdateKind.RESET)
+}
+
+internal fun NativeEditorExpoView.cancelPendingEditorUpdateRetry(
+    kind: PendingEditorUpdateKind? = null
+) {
+    if (kind != null && pendingEditorUpdateRetryKind != null &&
+        pendingEditorUpdateRetryKind != kind
+    ) {
+        return
+    }
+    pendingEditorUpdateRetryScheduled = false
+    pendingEditorUpdateRetryEditorId = null
+    pendingEditorUpdateRetryKind = null
+    pendingEditorUpdateRetryAttempts = 0
+    pendingEditorUpdateForcedRecoveryAttempted = false
+    pendingEditorUpdateRetryGeneration += 1
+}
+
+internal fun NativeEditorExpoView.schedulePendingEditorUpdateRetry(kind: PendingEditorUpdateKind) {
+    if (pendingEditorUpdateRetryScheduled) return
+    val pastFastRetryBudget =
+        pendingEditorUpdateRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS
+    if (
+        pastFastRetryBudget &&
+        !pendingEditorUpdateForcedRecoveryAttempted &&
+        richTextView.editorId != 0L &&
+        richTextView.editorEditText.editorId == richTextView.editorId
+    ) {
+        pendingEditorUpdateForcedRecoveryAttempted = true
+        richTextView.editorEditText.discardTransientNativeInputForExternalRecovery()
+    }
+    if (!pastFastRetryBudget) {
+        pendingEditorUpdateRetryAttempts += 1
+    }
+    pendingEditorUpdateRetryEditorId = richTextView.editorId
+    pendingEditorUpdateRetryKind = kind
+    pendingEditorUpdateRetryScheduled = true
+    pendingEditorUpdateRetryGeneration += 1
+    val retryGeneration = pendingEditorUpdateRetryGeneration
+    val delayMs = if (pastFastRetryBudget) {
+        PENDING_UPDATE_RECOVERY_RETRY_DELAY_MS
+    } else {
+        NATIVE_ACTION_RETRY_DELAY_MS * pendingEditorUpdateRetryAttempts
+    }
+    val retry = Runnable {
+        if (retryGeneration != pendingEditorUpdateRetryGeneration) return@Runnable
+        if (pendingEditorUpdateRetryEditorId != richTextView.editorId) {
+            when (pendingEditorUpdateRetryKind) {
+                PendingEditorUpdateKind.ORDINARY -> clearPendingEditorUpdateState()
+                PendingEditorUpdateKind.RESET -> clearPendingEditorResetUpdateState()
+                null -> Unit
+            }
+            return@Runnable
+        }
+        pendingEditorUpdateRetryScheduled = false
+        pendingEditorUpdateRetryEditorId = null
+        pendingEditorUpdateRetryKind = null
+        applyPendingEditorResetUpdateIfNeeded()
+        applyPendingEditorUpdateIfNeeded()
+    }
+    mainHandler.postDelayed(retry, delayMs)
+}

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

@@ -0,0 +1,234 @@
+package com.apollohg.editor
+
+import android.graphics.RectF
+import android.os.Build
+import android.widget.LinearLayout.LayoutParams
+import com.apollohg.editor.NativeEditorExpoView.ToolbarPlacement
+import org.json.JSONObject
+
+internal fun NativeEditorExpoView.setThemeJsonImpl(themeJson: String?) {
+    if (lastThemeJson == themeJson && !hasPendingTheme) return
+    pendingThemeJson = themeJson
+    hasPendingTheme = true
+    pendingThemeRetry.bind(richTextView.editorId)
+    pendingThemeRetry.resetAttempts()
+    applyPendingThemeIfNeeded()
+}
+
+internal fun NativeEditorExpoView.setImageLoadingPolicyJsonImpl(policyJson: String?) {
+    richTextView.editorEditText.setImageLoadingPolicyJson(policyJson)
+}
+
+internal fun NativeEditorExpoView.applyThemeJson(themeJson: String?) {
+    if (lastThemeJson == themeJson) return
+    val theme = EditorTheme.fromJson(themeJson)
+    require(themeJson.isNullOrBlank() || theme != null) {
+        "Invalid editor theme version or payload shape."
+    }
+    lastThemeJson = themeJson
+    richTextView.applyTheme(theme)
+    keyboardToolbarView.applyTheme(theme?.toolbar)
+    keyboardToolbarView.applyMentionTheme(theme?.mentions ?: addons.mentions?.theme)
+    keyboardToolbarView.requestLayout()
+    updateKeyboardToolbarLayout()
+    updateEditorViewportInset(forceMeasureToolbar = true)
+    post {
+        updateKeyboardToolbarLayout()
+        updateEditorViewportInset(forceMeasureToolbar = true)
+    }
+}
+
+internal fun NativeEditorExpoView.setHeightBehaviorImpl(rawHeightBehavior: String) {
+    val nextBehavior = EditorHeightBehavior.fromRaw(rawHeightBehavior)
+    if (heightBehavior == nextBehavior) return
+    heightBehavior = nextBehavior
+    if (nextBehavior != EditorHeightBehavior.AUTO_GROW) {
+        lastEmittedContentHeight = 0
+        lastEmittedContentHeightEditorId = null
+        publishAutoGrowStyleHeight(null)
+    }
+    richTextView.setHeightBehavior(nextBehavior)
+    val params = richTextView.layoutParams as LayoutParams
+    params.width = LayoutParams.MATCH_PARENT
+    params.height = if (nextBehavior == EditorHeightBehavior.AUTO_GROW) {
+        LayoutParams.WRAP_CONTENT
+    } else {
+        LayoutParams.MATCH_PARENT
+    }
+    richTextView.layoutParams = params
+    requestLayout()
+    if (nextBehavior == EditorHeightBehavior.AUTO_GROW) {
+        post { emitContentHeightIfNeeded(force = true) }
+    }
+    updateEditorViewportInset()
+}
+
+internal fun NativeEditorExpoView.invalidateAutoGrowContentHeightEmission() {
+    if (heightBehavior != EditorHeightBehavior.AUTO_GROW) return
+    lastEmittedContentHeight = 0
+    lastEmittedContentHeightEditorId = null
+    requestLayout()
+}
+
+internal fun NativeEditorExpoView.setAddonsJsonImpl(addonsJson: String?) {
+    if (lastAddonsJson == addonsJson) return
+    clearPendingNativeActionRetry()
+    val next = NativeEditorAddons.fromJson(addonsJson)
+    richTextView.editorEditText.setCodeHighlighting(next.codeHighlighting)
+    lastAddonsJson = addonsJson
+    addons = next
+    keyboardToolbarView.applyMentionTheme(
+        richTextView.editorEditText.theme?.mentions ?: addons.mentions?.theme
+    )
+    refreshMentionQuery()
+}
+
+internal fun NativeEditorExpoView.setAtomsJsonImpl(atomsJson: String?) {
+    if (lastAtomsJson == atomsJson && !hasPendingAtoms) return
+    pendingAtomsJson = atomsJson
+    hasPendingAtoms = true
+    pendingAtomsRetry.bind(richTextView.editorId)
+    pendingAtomsRetry.resetAttempts()
+    applyPendingAtomsIfNeeded()
+}
+
+internal fun NativeEditorExpoView.setRemoteSelectionsJsonImpl(remoteSelectionsJson: String?) {
+    if (lastRemoteSelectionsJson == remoteSelectionsJson) return
+    lastRemoteSelectionsJson = remoteSelectionsJson
+    richTextView.setRemoteSelections(
+        RemoteSelectionDecoration.fromJson(context, remoteSelectionsJson)
+    )
+}
+
+internal fun NativeEditorExpoView.setAutoFocusImpl(autoFocus: Boolean) {
+    autoFocusRequested = autoFocus
+    applyAutoFocusIfNeeded()
+}
+
+internal fun NativeEditorExpoView.applyAutoFocusIfNeeded() {
+    if (!autoFocusRequested || didApplyAutoFocus || !canFocusCurrentEditor()) return
+    didApplyAutoFocus = true
+    focus()
+}
+
+internal fun NativeEditorExpoView.setAutoCapitalizeImpl(autoCapitalize: String?) {
+    richTextView.editorEditText.setAutoCapitalize(autoCapitalize)
+}
+
+internal fun NativeEditorExpoView.setAutoCorrectImpl(autoCorrect: Boolean?) {
+    richTextView.editorEditText.setAutoCorrect(autoCorrect)
+}
+
+internal fun NativeEditorExpoView.setKeyboardTypeImpl(keyboardType: String?) {
+    richTextView.editorEditText.setKeyboardType(keyboardType)
+}
+
+internal fun NativeEditorExpoView.setAndroidInputOptionsJsonImpl(optionsJson: String?) {
+    val options = optionsJson?.let { runCatching { JSONObject(it) }.getOrNull() }
+    val privateImeOptions = options?.opt("privateImeOptions") as? String
+    richTextView.editorEditText.setPrivateImeOptionsForEditor(privateImeOptions)
+}
+
+internal fun NativeEditorExpoView.setEditableImpl(editable: Boolean) {
+    if (richTextView.editorEditText.isEditable == editable) return
+    if (!editable) {
+        cancelActiveExternalTextComposition("lifecycle")
+        cancelPendingToolbarRefocus()
+        clearPendingNativeActionRetry()
+    }
+    richTextView.editorEditText.isEditable = editable
+    updateKeyboardToolbarVisibility()
+}
+
+internal fun NativeEditorExpoView.setAccessibilityLabelImpl(label: String?) {
+    richTextView.editorEditText.contentDescription = label
+}
+
+internal fun NativeEditorExpoView.setAccessibilityHintImpl(hint: String?) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        richTextView.editorEditText.tooltipText = null
+    }
+    richTextView.editorEditText.setEditorAccessibilityHint(hint)
+}
+
+internal fun NativeEditorExpoView.setShowToolbarImpl(showToolbar: Boolean) {
+    if (showsToolbar == showToolbar) return
+    if (!showToolbar) {
+        cancelPendingToolbarRefocus()
+        clearPendingNativeActionRetry()
+    }
+    showsToolbar = showToolbar
+    updateKeyboardToolbarVisibility()
+}
+
+internal fun NativeEditorExpoView.setToolbarPlacementImpl(rawToolbarPlacement: String?) {
+    val nextPlacement = ToolbarPlacement.fromRaw(rawToolbarPlacement)
+    if (toolbarPlacement == nextPlacement) return
+    if (nextPlacement != ToolbarPlacement.KEYBOARD) {
+        cancelPendingToolbarRefocus()
+        clearPendingNativeActionRetry()
+    }
+    toolbarPlacement = nextPlacement
+    updateKeyboardToolbarVisibility()
+}
+
+internal fun NativeEditorExpoView.setAllowImageResizingImpl(allowImageResizing: Boolean) {
+    richTextView.setImageResizingEnabled(allowImageResizing)
+}
+
+internal fun NativeEditorExpoView.setToolbarItemsJsonImpl(toolbarItemsJson: String?) {
+    if (lastToolbarItemsJson == toolbarItemsJson) return
+    clearPendingNativeActionRetry()
+    lastToolbarItemsJson = toolbarItemsJson
+    keyboardToolbarView.setItems(NativeToolbarItem.fromJson(toolbarItemsJson))
+}
+
+internal fun NativeEditorExpoView.setToolbarFrameJsonImpl(toolbarFrameJson: String?) {
+    if (lastToolbarFrameJson == toolbarFrameJson) return
+    lastToolbarFrameJson = toolbarFrameJson
+    if (toolbarFrameJson.isNullOrBlank()) {
+        toolbarFramesInWindow = emptyList()
+        return
+    }
+
+    toolbarFramesInWindow = try {
+        val json = JSONObject(toolbarFrameJson)
+        val frames = json.optJSONArray("frames")
+        if (frames != null) {
+            buildList {
+                for (index in 0 until frames.length()) {
+                    frames.optJSONObject(index)?.toToolbarFrame()?.let { add(it) }
+                }
+            }
+        } else {
+            listOfNotNull(json.toToolbarFrame())
+        }
+    } catch (_: Throwable) {
+        emptyList()
+    }
+}
+
+private fun JSONObject.toToolbarFrame(): RectF? {
+    val x = optDouble("x", Double.NaN)
+    val y = optDouble("y", Double.NaN)
+    val width = optDouble("width", Double.NaN)
+    val height = optDouble("height", Double.NaN)
+    if (
+        x.isNaN() || x.isInfinite() ||
+        y.isNaN() || y.isInfinite() ||
+        width.isNaN() || width.isInfinite() ||
+        height.isNaN() || height.isInfinite()
+    ) {
+        return null
+    }
+    if (width <= 0.0 || height <= 0.0) {
+        return null
+    }
+
+    return RectF(
+        x.toFloat(),
+        y.toFloat(),
+        (x + width).toFloat(),
+        (y + height).toFloat()
+    )
+}