react-native-enriched-markdown-scaffold 1.0.2-scaffold.1 → 1.0.2-scaffold.10

package/android/src/main/java/com/swmansion/enriched/markdown/spans/LinkChipSpans.kt

@@ -0,0 +1,177 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import android.text.style.ReplacementSpan
+import com.swmansion.enriched.markdown.styles.LinkChipStyle
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * Reserves a link's `paddingHorizontal` at one outer edge. It covers one [LinkSpacers.CHAR]
+ * inserted by `LinkRenderer`: U+00A0 is line-break class GL, so a break is allowed before it
+ * after a space but never after it, and never before it after a non-space — the spacer always
+ * travels with the link's first (or last) glyph, never orphaned at a wrap.
+ *
+ * Layout-only: every text exit point strips spacers by this span ([LinkSpacers.strip]).
+ */
+class LinkSpacerSpan(
+  private val width: Float,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    // Keep the line metrics of the surrounding text.
+    if (fm != null) paint.getFontMetricsInt(fm)
+    return width.roundToInt()
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) = Unit
+}
+
+object LinkSpacers {
+  const val CHAR = '\u00A0'
+
+  /** [text] without link spacers (returns [text] itself when it has none). */
+  fun strip(text: CharSequence): CharSequence {
+    if (text !is Spanned) return text
+    val spacers = text.getSpans(0, text.length, LinkSpacerSpan::class.java)
+    if (spacers.isEmpty()) return text
+    val builder = SpannableStringBuilder(text)
+    spacers
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+      .filter { (start, end) -> start in 0 until end }
+      .sortedByDescending { it.first }
+      .forEach { (start, end) -> builder.delete(start, end) }
+    return builder
+  }
+
+  /** True when [start, end) lies inside a spacer (a segment exporters must skip). */
+  fun isSpacer(
+    text: Spanned,
+    start: Int,
+    end: Int,
+  ): Boolean = end > start && text.getSpans(start, end, LinkSpacerSpan::class.java).isNotEmpty()
+}
+
+/**
+ * Paints a link chip (background + border) behind the link glyphs. One instance per link,
+ * spanning the link including its spacers, so the chip already covers `paddingHorizontal`.
+ * Vertically the chip spans the link font's ascent..descent ± `paddingVertical`; the vertical
+ * padding only bleeds into the surrounding line spacing and never changes the line box.
+ */
+class LinkChipBackgroundSpan(
+  val chip: LinkChipStyle,
+) : LineBackgroundSpan {
+  private val rect = RectF()
+  private val path = Path()
+  private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val borderPaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.STROKE
+      strokeJoin = Paint.Join.ROUND
+      strokeCap = Paint.Cap.ROUND
+    }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (!chip.isVisible || text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd || spanEnd <= start || spanStart >= end) return
+
+    val isFirst = spanStart >= start
+    val isLast = spanEnd <= end
+
+    val leadingMargin = InlineChipPainter.leadingMarginAt(text, start)
+    val fragmentStart = max(spanStart, start)
+    val fragmentEnd = trimTrailingWhitespace(text, fragmentStart, min(spanEnd, end))
+    val startX = InlineChipPainter.horizontalOffset(text, start, end, fragmentStart, p, leadingMargin) + left
+    val endX = InlineChipPainter.horizontalOffset(text, start, end, fragmentEnd, p, leadingMargin) + left
+
+    val (ascent, descent) = linkFontMetrics(text, spanStart, spanEnd, p)
+    rect.set(
+      min(startX, endX),
+      baseline + ascent - chip.paddingVertical,
+      max(startX, endX),
+      baseline + descent + chip.paddingVertical,
+    )
+
+    backgroundPaint.color = chip.backgroundColor
+    borderPaint.color = chip.borderColor
+    borderPaint.strokeWidth = chip.borderWidth
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      chip.borderRadius,
+      backgroundPaint.takeIf { android.graphics.Color.alpha(chip.backgroundColor) > 0 },
+      borderPaint.takeIf { android.graphics.Color.alpha(chip.borderColor) > 0 && chip.borderWidth > 0f },
+      isFirst,
+      isLast,
+      strokeInset = true,
+    )
+  }
+
+  companion object {
+    /** A wrapped fragment ends before the whitespace the line break hangs. */
+    fun trimTrailingWhitespace(
+      text: CharSequence,
+      start: Int,
+      end: Int,
+    ): Int {
+      var index = end
+      while (index > start && text[index - 1] != LinkSpacers.CHAR && text[index - 1].isWhitespace()) index--
+      return index
+    }
+
+    /**
+     * Ascent/descent of the link's own font: [LinkSpan] sets its size and typeface at draw
+     * time only, so the base paint [p] alone would report the paragraph's metrics.
+     */
+    fun linkFontMetrics(
+      text: Spanned,
+      spanStart: Int,
+      spanEnd: Int,
+      p: Paint,
+    ): Pair<Float, Float> {
+      val paint = TextPaint(p)
+      text.getSpans(spanStart, spanEnd, LinkSpan::class.java).firstOrNull()?.updateDrawState(paint)
+      val metrics = paint.fontMetrics
+      return metrics.ascent to metrics.descent
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/LinkSpan.kt

@@ -1,7 +1,6 @@
 package com.swmansion.enriched.markdown.spans
 
 import android.content.Context
-import android.graphics.Color
 import android.text.TextPaint
 import android.text.style.ClickableSpan
 import android.view.View
@@ -57,10 +56,6 @@ class LinkSpan(
 
     textPaint.color = variant?.color ?: styleCache.linkColor
     textPaint.isUnderlineText = variant?.underline ?: styleCache.linkUnderline
-
-    val backgroundColor = variant?.backgroundColor ?: styleCache.linkBackgroundColor
-    if (Color.alpha(backgroundColor) > 0) {
-      textPaint.bgColor = backgroundColor
-    }
+    // The background is painted as a chip by LinkChipBackgroundSpan.
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/styles/InlineMathStyle.kt

@@ -1,12 +1,17 @@
 package com.swmansion.enriched.markdown.styles
 
 import com.facebook.react.bridge.ReadableMap
+import kotlin.math.ceil
 
 data class InlineMathStyle(
   val color: Int,
   val paddingVertical: Float,
   val fontWeight: String,
+  val glyphOverflow: Float = 0f,
 ) {
+  /** Line-box padding the span reports: author padding plus the ink headroom. */
+  val boxPaddingVertical: Float get() = paddingVertical + glyphOverflow
+
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
@@ -15,7 +20,17 @@ data class InlineMathStyle(
       val color = parser.parseColor(map, "color")
       val paddingVertical = parser.toPixelFromDIP(map.getDouble("paddingVertical").toFloat())
       val fontWeight = parser.parseString(map, "fontWeight", "normal")
-      return InlineMathStyle(color, paddingVertical, fontWeight)
+      val glyphOverflow = glyphOverflowPx(parser.parseOptionalDouble(map, "glyphOverflow").toFloat(), parser)
+      return InlineMathStyle(color, paddingVertical, fontWeight, glyphOverflow)
     }
   }
 }
+
+/**
+ * `glyphOverflow` in whole pixels. Rounded up so a measured box and the bitmap or
+ * canvas it holds always grow by the same integer amount on each side.
+ */
+internal fun glyphOverflowPx(
+  dip: Float,
+  parser: StyleParser,
+): Float = if (dip <= 0f) 0f else ceil(parser.toPixelFromDIP(dip))

package/android/src/main/java/com/swmansion/enriched/markdown/styles/LinkStyle.kt

@@ -7,6 +7,7 @@ data class LinkStyle(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
@@ -17,7 +18,41 @@ data class LinkStyle(
       val color = parser.parseColor(map, "color")
       val underline = map.getBoolean("underline")
       val backgroundColor = parser.parseColor(map, "backgroundColor")
-      return LinkStyle(fontFamily, color, underline, backgroundColor)
+      return LinkStyle(fontFamily, color, underline, backgroundColor, LinkChipStyle.fromReadableMap(map, parser, backgroundColor))
     }
   }
 }
+
+/**
+ * Chip ("box") properties of a link, in pixels. Never inherited from the base link
+ * style by variants — the JS normalizer fills missing values with 0 / transparent.
+ */
+data class LinkChipStyle(
+  val backgroundColor: Int,
+  val borderColor: Int,
+  val borderRadius: Float,
+  val borderWidth: Float,
+  val paddingHorizontal: Float,
+  val paddingVertical: Float,
+) {
+  val isVisible: Boolean
+    get() =
+      android.graphics.Color.alpha(backgroundColor) > 0 ||
+        (android.graphics.Color.alpha(borderColor) > 0 && borderWidth > 0f)
+
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+      backgroundColor: Int,
+    ): LinkChipStyle =
+      LinkChipStyle(
+        backgroundColor = backgroundColor,
+        borderColor = parser.parseOptionalColor(map, "borderColor") ?: 0,
+        borderRadius = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderRadius").toFloat()),
+        borderWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderWidth").toFloat()),
+        paddingHorizontal = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingHorizontal").toFloat()),
+        paddingVertical = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingVertical").toFloat()),
+      )
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/LinkVariantEntry.kt

@@ -13,17 +13,21 @@ data class LinkVariantEntry(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
-    ): LinkVariantEntry =
-      LinkVariantEntry(
+    ): LinkVariantEntry {
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return LinkVariantEntry(
         pattern = map.getString("pattern") ?: "",
         color = parser.parseColor(map, "color"),
         underline = parser.parseBoolean(map, "underline"),
-        backgroundColor = parser.parseColor(map, "backgroundColor"),
+        backgroundColor = backgroundColor,
+        chip = LinkChipStyle.fromReadableMap(map, parser, backgroundColor),
       )
+    }
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/styles/MathStyle.kt

@@ -11,6 +11,7 @@ data class MathStyle(
   val marginBottom: Float,
   val textAlign: String,
   val fontWeight: String,
+  val glyphOverflow: Float = 0f,
 ) {
   companion object {
     fun fromReadableMap(
@@ -25,6 +26,7 @@ data class MathStyle(
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
       val textAlign = parser.parseString(map, "textAlign", "center")
       val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      val glyphOverflow = glyphOverflowPx(parser.parseOptionalDouble(map, "glyphOverflow").toFloat(), parser)
       return MathStyle(
         fontSize,
         color,
@@ -34,6 +36,7 @@ data class MathStyle(
         marginBottom,
         textAlign,
         fontWeight,
+        glyphOverflow,
       )
     }
   }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt

@@ -7,11 +7,16 @@ import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.events.ContextMenuItemPressEvent
 import com.swmansion.enriched.markdown.events.CopyPressEvent
+import com.swmansion.enriched.markdown.events.CopyRequestEvent
+import com.swmansion.enriched.markdown.events.LinkLayoutEvent
 import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.events.SelectionChangeEvent
 import com.swmansion.enriched.markdown.events.TaskListItemPressEvent
 import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutFragment
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
+import com.swmansion.enriched.markdown.utils.text.view.SelectionSnapshot
 
 fun markdownEventTypeConstants(): MutableMap<String, Any> {
   val map = mutableMapOf<String, Any>()
@@ -22,11 +27,37 @@ fun markdownEventTypeConstants(): MutableMap<String, Any> {
     mapOf("registrationName" to TaskListItemPressEvent.EVENT_NAME)
   map[CopyPressEvent.EVENT_NAME] =
     mapOf("registrationName" to CopyPressEvent.EVENT_NAME)
+  map[CopyRequestEvent.EVENT_NAME] =
+    mapOf("registrationName" to CopyRequestEvent.EVENT_NAME)
   map[ContextMenuItemPressEvent.EVENT_NAME] =
     mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
+  map[LinkLayoutEvent.EVENT_NAME] =
+    mapOf("registrationName" to LinkLayoutEvent.EVENT_NAME)
+  map[SelectionChangeEvent.EVENT_NAME] =
+    mapOf("registrationName" to SelectionChangeEvent.EVENT_NAME)
   return map
 }
 
+fun emitLinkLayout(
+  view: View,
+  fragments: List<LinkLayoutFragment>,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(LinkLayoutEvent(surfaceId, view.id, fragments))
+}
+
+fun emitSelectionChange(
+  view: View,
+  snapshot: SelectionSnapshot,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(SelectionChangeEvent(surfaceId, view.id, snapshot))
+}
+
 fun emitLinkPress(
   view: View,
   url: String,
@@ -74,6 +105,21 @@ fun emitCopyPress(
   )
 }
 
+fun emitCopyRequest(
+  view: View,
+  source: String,
+  markdown: String,
+  text: String,
+  whole: Boolean,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    CopyRequestEvent(surfaceId, view.id, source, markdown, text, whole),
+  )
+}
+
 fun emitContextMenuItemPress(
   view: View,
   itemText: String,
@@ -128,6 +174,11 @@ fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
     copyImageUrlLabel = value.getString("copyImageUrlLabel") ?: "",
     copyImageUrlsLabel = value.getString("copyImageUrlsLabel") ?: "",
     copyImageUrlPluralTemplates = parseStringList(value.getArray("copyImageUrlPluralTemplates")),
+    copyEnabled = value.getBooleanOrDefault("copyEnabled", true),
+    copyFormatMarkdown = value.getBooleanOrDefault("copyFormatMarkdown", false),
+    systemItemsNone = value.getBooleanOrDefault("systemItemsNone", false),
+    codeBlockCopyButton = value.getBooleanOrDefault("codeBlockCopyButton", true),
+    interceptCopy = value.getBooleanOrDefault("interceptCopy", false),
   )
 }
 

package/android/src/main/java/com/swmansion/enriched/markdown/utils/input/PasteTextUtils.kt

@@ -2,10 +2,17 @@ package com.swmansion.enriched.markdown.utils.input
 
 /**
  * The pure half of the paste interception path. A `ClipData` cannot be built on
- * the JVM, so the joining rule lives here where a unit test can reach it; the
- * two call sites (context menu and `onReceiveContent`) only extract the items.
+ * the JVM, so the joining and matching rules live here where a unit test can
+ * reach them; the call sites (context menu, `onReceiveContent` and the IME
+ * commit) only extract the items.
  */
 object PasteTextUtils {
+  /**
+   * Shortest single-line IME commit that is compared against the clipboard.
+   * Longer than a word picked from the suggestion strip.
+   */
+  const val IME_PASTE_MIN_LENGTH = 16
+
   /**
    * Flattens a clip's items into one string. A clip regularly carries more than
    * one item — reading only `getItemAt(0)` silently drops items 2..n. Items
@@ -17,4 +24,29 @@ object PasteTextUtils {
       .mapNotNull { it?.toString() }
       .filter { it.isNotEmpty() }
       .joinToString("\n")
+
+  /**
+   * Whether an IME `commitText` is worth comparing against the clipboard.
+   *
+   * Reading the clip is not free: on Android 12+ a read can show the system
+   * "pasted from your clipboard" toast, so it must not happen while the user is
+   * just typing. Typing, autocorrect and suggestion picks commit a word at a
+   * time and stay below [IME_PASTE_MIN_LENGTH]. A shorter commit is still
+   * compared when it spans lines, since only a paste or a multi-line dictation
+   * produces one — but not a lone "\n", which some keyboards commit for Enter.
+   */
+  fun mayBeImePaste(committed: String): Boolean =
+    committed.length >= IME_PASTE_MIN_LENGTH ||
+      (committed.length > 1 && committed.contains('\n'))
+
+  /**
+   * Whether an IME commit is the keyboard pasting the clipboard. Only an exact
+   * match counts: anything the user typed or dictated differs from the clip.
+   * Text the keyboard changed on the way (trimmed, an older clipboard-history
+   * entry, one item of a multi-item clip) does not match and inserts inline.
+   */
+  fun isImePaste(
+    committed: String,
+    clip: String,
+  ): Boolean = clip.isNotEmpty() && clip == committed
 }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/HTMLGenerator.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -676,7 +677,7 @@ object HTMLGenerator {
           val segmentEnd = minOf(text.nextSpanTransition(i, end, Any::class.java), end)
           val segmentText = text.subSequence(i, segmentEnd).toString()
 
-          if (segmentText.isNotEmpty() && segmentText != "\n") {
+          if (segmentText.isNotEmpty() && segmentText != "\n" && !LinkSpacers.isSpacer(text, i, segmentEnd)) {
             appendStyledSegment(html, text, i, segmentEnd, segmentText, styles, isCodeBlock)
           }
           i = segmentEnd

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/MarkdownExtractor.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -55,6 +56,11 @@ object MarkdownExtractor {
     var i = start
     while (i < end) {
       val nextTransition = spannable.nextSpanTransition(i, end, Any::class.java)
+      // Link spacers only reserve layout space for chip padding.
+      if (LinkSpacers.isSpacer(spannable, i, nextTransition)) {
+        i = nextTransition
+        continue
+      }
       val segmentText = spannable.subSequence(i, nextTransition).toString()
 
       val handled =

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/HeadlessActionMode.kt

@@ -0,0 +1,88 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.view.ActionMode
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.View
+import android.widget.PopupMenu
+
+/**
+ * Stands in for the floating text-selection toolbar while `contextMenuHidden`
+ * is on. An empty menu only hides the AOSP FloatingToolbar; ROMs that draw
+ * their own selection popup (MIUI) still show it. Answering the Editor's
+ * startActionMode with this mode means no toolbar window is ever created.
+ *
+ * The callback is the Editor's TextActionModeCallback wrapping ours, so it
+ * still gets the full create/prepare/destroy lifecycle: Editor keeps the
+ * selection handles and its transient-state bookkeeping, and finish() clears
+ * the selection exactly as dismissing the real toolbar would.
+ */
+internal class HeadlessActionMode private constructor(
+  private val view: View,
+  private val callback: ActionMode.Callback,
+) : ActionMode() {
+  // A real framework menu: Editor populates it with MenuItem calls
+  // (setAlphabeticShortcut, setShowAsAction, setIntent) a stub can't take.
+  private val menu: Menu = PopupMenu(view.context, view).menu
+  private var finished = false
+
+  override fun setTitle(title: CharSequence?) = Unit
+
+  override fun setTitle(resId: Int) = Unit
+
+  override fun setSubtitle(subtitle: CharSequence?) = Unit
+
+  override fun setSubtitle(resId: Int) = Unit
+
+  override fun setCustomView(view: View?) = Unit
+
+  override fun invalidate() {
+    if (!finished) callback.onPrepareActionMode(this, menu)
+  }
+
+  override fun invalidateContentRect() = Unit
+
+  override fun hide(duration: Long) = Unit
+
+  override fun finish() {
+    if (finished) return
+    finished = true
+    callback.onDestroyActionMode(this)
+  }
+
+  override fun getMenu(): Menu = menu
+
+  override fun getTitle(): CharSequence? = null
+
+  override fun getSubtitle(): CharSequence? = null
+
+  override fun getCustomView(): View? = null
+
+  override fun getMenuInflater(): MenuInflater = MenuInflater(view.context)
+
+  companion object {
+    /** Mirrors the framework: null when the callback declines to start. */
+    fun start(
+      view: View,
+      callback: ActionMode.Callback,
+    ): ActionMode? {
+      val mode = HeadlessActionMode(view, callback)
+      mode.type = TYPE_FLOATING
+      if (!callback.onCreateActionMode(mode, mode.menu)) return null
+      callback.onPrepareActionMode(mode, mode.menu)
+      return mode
+    }
+  }
+}
+
+/**
+ * MIUI 12 (Android 10) replaces android.widget.Editor: text selection never reaches
+ * startActionMode or the custom ActionMode callback, so HeadlessActionMode is never used.
+ * Its own popup is shown by Editor$HandleView.showActionPopupWindow, which posts a runnable
+ * on the TextView (Editor$HandleView$2). Dropping that runnable is the only hook left while
+ * `contextMenuHidden` is on.
+ */
+private const val ROM_SELECTION_POPUP_SHOWER_PREFIX = "android.widget.Editor\$HandleView"
+
+internal fun isRomSelectionPopupShower(action: Runnable?): Boolean =
+  action != null && action.javaClass.name.startsWith(ROM_SELECTION_POPUP_SHOWER_PREFIX)