react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

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

@@ -0,0 +1,205 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.text.Spannable
+import android.view.ActionMode
+import android.view.Menu
+import android.view.MenuItem
+import android.view.ViewParent
+import android.widget.TextView
+import com.swmansion.enriched.markdown.EnrichedMarkdown
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.common.layout.isLayoutRTL
+import com.swmansion.enriched.markdown.utils.text.conversion.HTMLGenerator
+import com.swmansion.enriched.markdown.utils.text.conversion.MarkdownExtractor
+
+private const val MENU_ITEM_COPY_MARKDOWN = 1000
+private const val MENU_ITEM_COPY_IMAGE_URL = 1001
+private const val MENU_ITEM_CUSTOM_BASE = 2000
+private const val MENU_ITEM_CUSTOM_GROUP = 2001
+
+data class SelectionMenuConfig(
+  val copyAsMarkdown: Boolean = true,
+  val copyImageUrl: Boolean = true,
+)
+
+/**
+ * Creates an ActionMode.Callback that adds custom copy options and
+ * overrides the default "Copy" action to include HTML for rich text support.
+ */
+fun createSelectionActionModeCallback(
+  textView: TextView,
+  getCustomItemTexts: () -> List<String> = { emptyList() },
+  getSelectionMenuConfig: () -> SelectionMenuConfig = { SelectionMenuConfig() },
+  onCustomItemPress: (itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit =
+    { _, _, _, _ -> },
+): ActionMode.Callback =
+  object : ActionMode.Callback {
+    override fun onCreateActionMode(
+      mode: ActionMode?,
+      menu: Menu?,
+    ): Boolean = true
+
+    override fun onPrepareActionMode(
+      mode: ActionMode?,
+      menu: Menu?,
+    ): Boolean {
+      if (menu == null) return false
+
+      menu.removeItem(MENU_ITEM_COPY_MARKDOWN)
+      menu.removeItem(MENU_ITEM_COPY_IMAGE_URL)
+      menu.removeGroup(MENU_ITEM_CUSTOM_GROUP)
+
+      val selectionMenuConfig = getSelectionMenuConfig()
+
+      if (
+        selectionMenuConfig.copyAsMarkdown &&
+        textView.selectionStart >= 0 &&
+        textView.selectionEnd > textView.selectionStart
+      ) {
+        menu.add(Menu.NONE, MENU_ITEM_COPY_MARKDOWN, Menu.NONE, "Copy as Markdown")
+      }
+
+      if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
+        val customItems = getCustomItemTexts()
+        customItems.forEachIndexed { index, text ->
+          menu
+            .add(MENU_ITEM_CUSTOM_GROUP, MENU_ITEM_CUSTOM_BASE + index, index, text)
+            .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        }
+      }
+
+      val imageUrls =
+        if (selectionMenuConfig.copyImageUrl) {
+          textView.getImageUrlsInSelection()
+        } else {
+          emptyList()
+        }
+      if (imageUrls.isNotEmpty()) {
+        val title =
+          if (imageUrls.size == 1) {
+            "Copy Image URL"
+          } else {
+            "Copy ${imageUrls.size} Image URLs"
+          }
+        menu.add(Menu.NONE, MENU_ITEM_COPY_IMAGE_URL, Menu.NONE, title)
+      }
+
+      return true
+    }
+
+    override fun onActionItemClicked(
+      mode: ActionMode?,
+      item: MenuItem?,
+    ): Boolean {
+      val itemId = item?.itemId ?: return false
+
+      when (itemId) {
+        android.R.id.copy -> {
+          textView.copyWithHTML()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_MARKDOWN -> {
+          textView.copyMarkdownToClipboard()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_IMAGE_URL -> {
+          textView.copyImageUrlsToClipboard()
+          mode?.finish()
+          return true
+        }
+      }
+
+      val customItems = getCustomItemTexts()
+      val customIndex = itemId - MENU_ITEM_CUSTOM_BASE
+      if (customIndex in customItems.indices) {
+        val start = textView.selectionStart
+        val end = textView.selectionEnd
+        val selectedText = if (start >= 0 && end > start) textView.text.substring(start, end) else ""
+        onCustomItemPress(customItems[customIndex], selectedText, start, end)
+        mode?.finish()
+        return true
+      }
+
+      return false
+    }
+
+    override fun onDestroyActionMode(mode: ActionMode?) {}
+  }
+
+/** Copies selection as both plain text and HTML with inline styles. */
+private fun TextView.copyWithHTML() {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end < 0 || start >= end) return
+
+  val spannable = text as? Spannable ?: return
+  val selectedText = spannable.subSequence(start, end)
+  val plainText = selectedText.toString()
+
+  val styleConfig =
+    (this as? EnrichedMarkdownText)?.markdownStyle
+      ?: findParentMarkdownStyle()
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+
+  if (styleConfig != null && selectedText is Spannable) {
+    // Density values convert device pixels back to CSS pixels
+    val displayMetrics = context.resources.displayMetrics
+    val isRTL = context.resources.isLayoutRTL()
+    val html =
+      HTMLGenerator.generateHTML(
+        selectedText,
+        styleConfig,
+        displayMetrics.scaledDensity,
+        displayMetrics.density,
+        isRTL,
+      )
+    clipboard.setPrimaryClip(ClipData.newHtmlText("EnrichedMarkdown", plainText, html))
+  } else {
+    clipboard.setPrimaryClip(ClipData.newPlainText("Text", plainText))
+  }
+}
+
+private fun TextView.copyMarkdownToClipboard() {
+  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: return
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Markdown", markdown))
+}
+
+/** Returns remote image URLs (http/https only) from the current selection. */
+private fun TextView.getImageUrlsInSelection(): List<String> {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end < 0 || start >= end) return emptyList()
+
+  val spannable = text as? Spannable ?: return emptyList()
+  return spannable
+    .getSpans(start, end, ImageSpan::class.java)
+    .mapNotNull { it.imageUrl }
+    .filter { it.startsWith("http://") || it.startsWith("https://") }
+}
+
+private fun TextView.copyImageUrlsToClipboard() {
+  val urls = getImageUrlsInSelection()
+  if (urls.isEmpty()) return
+
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Image URLs", urls.joinToString("\n")))
+}
+
+private fun TextView.findParentMarkdownStyle(): StyleConfig? {
+  var current: ViewParent? = parent
+  while (current != null) {
+    if (current is EnrichedMarkdown) return current.markdownStyle
+    current = current.parent
+  }
+  return null
+}

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

@@ -0,0 +1,48 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.util.Log
+import android.widget.TextView
+import androidx.annotation.ColorInt
+import androidx.core.graphics.drawable.DrawableCompat
+
+private const val TAG = "TextSelectionColors"
+
+private typealias HandleGetter = (TextView) -> Drawable?
+private typealias HandleSetter = (TextView, Drawable) -> Unit
+
+/**
+ * Applies selection highlight and (where supported) handle tinting to a [TextView].
+ *
+ * Handle drawables are only tinted on API 29+ where the framework exposes getters;
+ * on older versions the handle theme defaults remain unchanged.
+ */
+fun TextView.applySelectionColors(
+  selectionColor: Int?,
+  selectionHandleColor: Int?,
+) {
+  selectionColor?.let { highlightColor = it }
+  selectionHandleColor?.let { applySelectionHandleTint(it) }
+}
+
+private fun TextView.applySelectionHandleTint(
+  @ColorInt color: Int,
+) {
+  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return
+
+  val handles: List<Pair<HandleGetter, HandleSetter>> =
+    listOf(
+      TextView::getTextSelectHandleLeft to { tv, d -> tv.setTextSelectHandleLeft(d) },
+      TextView::getTextSelectHandle to { tv, d -> tv.setTextSelectHandle(d) },
+      TextView::getTextSelectHandleRight to { tv, d -> tv.setTextSelectHandleRight(d) },
+    )
+
+  handles.forEach { (getter, setter) ->
+    try {
+      getter(this)?.mutate()?.also { DrawableCompat.setTint(it, color) }?.let { setter(this, it) }
+    } catch (e: LinkageError) {
+      Log.w(TAG, "Selection handle tint skipped: ${e.message}")
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.graphics.Color
+import android.os.Build
+import android.view.textclassifier.TextClassifier
+import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.view.ViewCompat
+import com.swmansion.enriched.markdown.accessibility.AccessibleMarkdownTextView
+
+fun AccessibleMarkdownTextView.setupAsMarkdownTextView() {
+  setBackgroundColor(Color.TRANSPARENT)
+  includeFontPadding = false
+  movementMethod = LinkLongPressMovementMethod.createInstance()
+  setTextIsSelectable(true)
+  customSelectionActionModeCallback = createSelectionActionModeCallback(this)
+  // SmartSelectSprite crashes with "Center point is not inside any of the
+  // rectangles!" when Layout.getSelection returns empty rects near an
+  // ImageSpan (ReplacementSpan). NO_OP makes skipTextClassification() return
+  // true, bypassing the entire SmartSelectSprite code path. Regular text
+  // selection (long-press, handles, copy/paste) still works; only automatic
+  // entity detection (phone numbers, addresses) is disabled.
+  //
+  // TODO: Add an Android-only `enableSmartTextSelection` prop that skips this
+  // NO_OP override. This would let users who don't render images opt in to
+  // entity detection. The prop should default to false and its docs should
+  // warn that enabling it with markdown containing images will crash.
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+    setTextClassifier(TextClassifier.NO_OP)
+  }
+  isVerticalScrollBarEnabled = false
+  isHorizontalScrollBarEnabled = false
+  ViewCompat.setAccessibilityDelegate(this, accessibilityHelper)
+}
+
+fun AppCompatTextView.applySelectableState(selectable: Boolean) {
+  if (isTextSelectable == selectable) return
+  setTextIsSelectable(selectable)
+  movementMethod = LinkLongPressMovementMethod.createInstance()
+  if (!selectable && !isClickable) isClickable = true
+}

package/android/src/main/java/com/swmansion/enriched/markdown/views/BlockSegmentView.kt

@@ -0,0 +1,10 @@
+package com.swmansion.enriched.markdown.views
+
+/**
+ * Interface for block-level segment views that declare their own margins
+ * for layout by EnrichedMarkdown.
+ */
+interface BlockSegmentView {
+  val segmentMarginTop: Int get() = 0
+  val segmentMarginBottom: Int get() = 0
+}

package/android/src/main/java/com/swmansion/enriched/markdown/views/ContextMenuPopup.kt

@@ -0,0 +1,214 @@
+package com.swmansion.enriched.markdown.views
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.PixelFormat
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.GradientDrawable
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.View
+import android.view.View.MeasureSpec
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.PopupWindow
+import android.widget.TextView
+import kotlin.math.roundToInt
+
+object ContextMenuPopup {
+  private var activePopup: PopupWindow? = null
+
+  fun dismiss() {
+    activePopup?.dismiss()
+  }
+
+  enum class Icon { COPY, DOCUMENT }
+
+  class Builder internal constructor() {
+    internal val items = mutableListOf<MenuItem>()
+
+    fun item(
+      icon: Icon,
+      label: String,
+      onClick: () -> Unit,
+    ) {
+      items.add(MenuItem(icon, label, onClick))
+    }
+  }
+
+  internal data class MenuItem(
+    val icon: Icon,
+    val label: String,
+    val onClick: () -> Unit,
+  )
+
+  private var density = 1f
+  private val Float.dp get() = (this * density).roundToInt()
+
+  fun show(
+    anchor: View,
+    parent: View,
+    block: Builder.() -> Unit,
+  ) {
+    activePopup?.dismiss()
+
+    val context = anchor.context
+    density = context.resources.displayMetrics.density
+    val builder = Builder().apply(block)
+    if (builder.items.isEmpty()) return
+
+    val container =
+      LinearLayout(context).apply {
+        orientation = LinearLayout.VERTICAL
+        elevation = 12f.dp.toFloat()
+        setPadding(4f.dp, 12f.dp, 4f.dp, 12f.dp)
+        background =
+          GradientDrawable().apply {
+            setColor(Color.WHITE)
+            cornerRadius = 14f.dp.toFloat()
+          }
+      }
+
+    builder.items.forEachIndexed { index, item ->
+      if (index > 0) container.addView(createDivider(context))
+      container.addView(createMenuItemView(context, item))
+    }
+
+    val popup =
+      PopupWindow(
+        container,
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        true,
+      ).apply {
+        elevation = 24f.dp.toFloat()
+        isOutsideTouchable = true
+        setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
+        setOnDismissListener {
+          activePopup = null
+        }
+      }
+
+    container.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED)
+
+    val location = IntArray(2).also { anchor.getLocationOnScreen(it) }
+    val centerX = location[0] + anchor.width / 2
+    val topY = location[1]
+
+    val screenW = context.resources.displayMetrics.widthPixels
+    val margin = 8f.dp
+
+    val x =
+      (centerX - container.measuredWidth / 2)
+        .coerceIn(margin, screenW - container.measuredWidth - margin)
+    val y =
+      (topY - container.measuredHeight - margin)
+        .coerceAtLeast(margin)
+
+    activePopup = popup
+    popup.showAtLocation(parent, Gravity.NO_GRAVITY, x, y)
+  }
+
+  private fun createMenuItemView(
+    context: Context,
+    item: MenuItem,
+  ) = LinearLayout(context).apply {
+    orientation = LinearLayout.HORIZONTAL
+    gravity = Gravity.CENTER_VERTICAL
+    setPadding(16f.dp, 0, 16f.dp, 0)
+    minimumHeight = 48f.dp
+    isClickable = true
+    isFocusable = true
+
+    val outValue = TypedValue()
+    context.theme.resolveAttribute(android.R.attr.selectableItemBackground, outValue, true)
+    foreground = context.getDrawable(outValue.resourceId)
+
+    addView(
+      ImageView(context).apply {
+        setImageDrawable(createIconDrawable(item.icon))
+        setColorFilter(Color.parseColor("#333333"))
+      },
+      LinearLayout.LayoutParams(20f.dp, 20f.dp),
+    )
+
+    addView(
+      TextView(context).apply {
+        text = item.label
+        textSize = 16f
+        setTextColor(Color.parseColor("#1C1C1E"))
+        typeface = Typeface.create("sans-serif-medium", Typeface.NORMAL)
+      },
+      LinearLayout
+        .LayoutParams(
+          ViewGroup.LayoutParams.WRAP_CONTENT,
+          ViewGroup.LayoutParams.WRAP_CONTENT,
+        ).apply { marginStart = 12f.dp },
+    )
+
+    setOnClickListener {
+      item.onClick()
+      dismiss()
+    }
+  }
+
+  private fun createDivider(context: Context) =
+    View(context).apply {
+      setBackgroundColor(Color.parseColor("#E5E5EA"))
+      layoutParams =
+        LinearLayout
+          .LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            1f.dp.coerceAtLeast(1),
+          ).apply {
+            setMargins(16f.dp, 0, 16f.dp, 0)
+          }
+    }
+
+  private fun createIconDrawable(icon: Icon): Drawable =
+    object : Drawable() {
+      private val paint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+          style = Paint.Style.STROKE
+          strokeWidth = 1.5f * density
+          strokeJoin = Paint.Join.ROUND
+          strokeCap = Paint.Cap.ROUND
+          color = Color.parseColor("#333333")
+        }
+
+      override fun draw(canvas: Canvas) {
+        val u = bounds.width() / 24f
+        if (icon == Icon.COPY) {
+          canvas.drawRoundRect(RectF(8 * u, 2 * u, 22 * u, 16 * u), 2 * u, 2 * u, paint)
+          canvas.drawRoundRect(RectF(2 * u, 8 * u, 16 * u, 22 * u), 2 * u, 2 * u, paint)
+        } else {
+          canvas.drawRoundRect(RectF(4 * u, 2 * u, 20 * u, 22 * u), 2 * u, 2 * u, paint)
+          canvas.drawLine(8 * u, 8 * u, 16 * u, 8 * u, paint)
+          canvas.drawLine(8 * u, 12 * u, 16 * u, 12 * u, paint)
+          canvas.drawLine(8 * u, 16 * u, 13 * u, 16 * u, paint)
+        }
+      }
+
+      override fun getIntrinsicWidth() = 24f.dp
+
+      override fun getIntrinsicHeight() = 24f.dp
+
+      override fun setAlpha(alpha: Int) {
+        paint.alpha = alpha
+      }
+
+      override fun setColorFilter(colorFilter: ColorFilter?) {
+        paint.colorFilter = colorFilter
+      }
+
+      @Deprecated("Deprecated in Java")
+      override fun getOpacity() = PixelFormat.TRANSLUCENT
+    }
+}