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

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

@@ -0,0 +1,314 @@
+package com.apollohg.editor
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.util.AttributeSet
+import android.util.TypedValue
+import androidx.appcompat.content.res.AppCompatResources
+import org.json.JSONArray
+
+data class RemoteSelectionDecoration(
+    val clientId: String,
+    val anchor: Int,
+    val head: Int,
+    val color: Int,
+    val name: String?,
+    val isFocused: Boolean
+) {
+    companion object {
+        fun fromJson(context: Context, json: String?): List<RemoteSelectionDecoration> {
+            if (json.isNullOrBlank()) return emptyList()
+            val array = try {
+                JSONArray(json)
+            } catch (_: Throwable) {
+                return emptyList()
+            }
+            val fallbackColor = resolveFallbackColor(context)
+
+            return buildList {
+                for (index in 0 until array.length()) {
+                    val item = array.optJSONObject(index) ?: continue
+                    val clientId = canonicalV2U64(item.opt("clientId") as? String) ?: continue
+                    val anchor = exactV2ScalarInt(item.opt("anchor") as? Number) ?: continue
+                    val head = exactV2ScalarInt(item.opt("head") as? Number) ?: continue
+                    val color = parseColor(item.optString("color", ""), fallbackColor)
+                    add(
+                        RemoteSelectionDecoration(
+                            clientId = clientId,
+                            anchor = anchor,
+                            head = head,
+                            color = color,
+                            name = item.optString("name").takeIf { it.isNotBlank() },
+                            isFocused = item.optBoolean("isFocused", false)
+                        )
+                    )
+                }
+            }
+        }
+
+        private fun parseColor(raw: String, fallbackColor: Int): Int = try {
+            Color.parseColor(raw)
+        } catch (_: Throwable) {
+            fallbackColor
+        }
+
+        private fun resolveFallbackColor(context: Context): Int {
+            val typedValue = TypedValue()
+            val attrs = intArrayOf(
+                androidx.appcompat.R.attr.colorPrimary,
+                androidx.appcompat.R.attr.colorAccent,
+                android.R.attr.colorAccent,
+                android.R.attr.textColorPrimary
+            )
+            for (attr in attrs) {
+                if (!context.theme.resolveAttribute(attr, typedValue, true)) {
+                    continue
+                }
+                if (typedValue.resourceId != 0) {
+                    AppCompatResources.getColorStateList(context, typedValue.resourceId)
+                        ?.defaultColor
+                        ?.let { return it }
+                } else if (typedValue.type in
+                    TypedValue.TYPE_FIRST_COLOR_INT..TypedValue.TYPE_LAST_COLOR_INT
+                ) {
+                    return typedValue.data
+                }
+            }
+            return Color.TRANSPARENT
+        }
+    }
+}
+
+data class RemoteSelectionDebugSnapshot(val clientId: String, val caretRect: RectF?)
+
+class RemoteSelectionOverlayView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : PointerTransparentView(context, attrs, defStyleAttr) {
+    private data class CachedSelectionGeometry(
+        val clientId: String,
+        val selectionPath: Path?,
+        val selectionColor: Int,
+        val caretRect: RectF?,
+        val caretColor: Int
+    )
+
+    private data class GeometrySnapshot(
+        val editorId: Long,
+        val text: String,
+        val layoutWidth: Int,
+        val layoutHeight: Int,
+        val baseX: Int,
+        val baseY: Int,
+        val width: Int,
+        val height: Int,
+        val selections: List<RemoteSelectionDecoration>
+    )
+
+    private data class GeometryContext(
+        val snapshot: GeometrySnapshot,
+        val layout: android.text.Layout,
+        val caretWidth: Float
+    )
+
+    private var editorView: RichTextEditorView? = null
+    private var remoteSelections: List<RemoteSelectionDecoration> = emptyList()
+    private var cachedSnapshot: GeometrySnapshot? = null
+    private var cachedGeometry: List<CachedSelectionGeometry> = emptyList()
+    internal var editorIdOverrideForTesting: Long? = null
+    internal var docToScalarResolver: (Long, Int) -> Int = { editorId, docPos ->
+        EditorV2Registry.adapterForViewToken(editorId)?.scalarPositionForDoc(docPos) ?: 0
+    }
+    private val selectionPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.FILL
+    }
+    private val caretPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.FILL
+    }
+
+    init {
+        setWillNotDraw(false)
+        isClickable = false
+        isFocusable = false
+    }
+
+    fun bind(editorView: RichTextEditorView) {
+        this.editorView = editorView
+        invalidateGeometry()
+    }
+
+    fun setRemoteSelections(selections: List<RemoteSelectionDecoration>) {
+        if (remoteSelections == selections) {
+            return
+        }
+        remoteSelections = selections
+        invalidateGeometry()
+        refreshGeometry()
+    }
+
+    fun refreshGeometry() {
+        ensureGeometry()
+        invalidate()
+    }
+
+    fun hasSelectionsOrCachedGeometry(): Boolean =
+        remoteSelections.isNotEmpty() || cachedGeometry.isNotEmpty()
+
+    fun debugSnapshotsForTesting(): List<RemoteSelectionDebugSnapshot> =
+        ensureGeometry().map { geometry ->
+            RemoteSelectionDebugSnapshot(
+                clientId = geometry.clientId,
+                caretRect = geometry.caretRect?.let(::RectF)
+            )
+        }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        val geometry = ensureGeometry()
+        if (geometry.isEmpty()) return
+
+        for (entry in geometry) {
+            entry.selectionPath?.let { path ->
+                selectionPaint.color = entry.selectionColor
+                canvas.drawPath(path, selectionPaint)
+            }
+
+            entry.caretRect?.let { caretRect ->
+                caretPaint.color = entry.caretColor
+                val cornerRadius = maxOf(1f, caretRect.width() / 2f)
+                canvas.drawRoundRect(
+                    caretRect.left,
+                    caretRect.top,
+                    caretRect.right,
+                    caretRect.bottom,
+                    cornerRadius,
+                    cornerRadius,
+                    caretPaint
+                )
+            }
+        }
+    }
+
+    private fun ensureGeometry(): List<CachedSelectionGeometry> {
+        val context = buildGeometryContext() ?: run {
+            cachedSnapshot = null
+            cachedGeometry = emptyList()
+            return emptyList()
+        }
+        if (cachedSnapshot == context.snapshot) {
+            return cachedGeometry
+        }
+
+        val text = context.snapshot.text
+        val editorId = context.snapshot.editorId
+        val geometry = remoteSelections.map { selection ->
+            val startDoc = minOf(selection.anchor, selection.head)
+            val endDoc = maxOf(selection.anchor, selection.head)
+            val startScalar = docToScalarResolver(editorId, startDoc)
+            val endScalar = docToScalarResolver(editorId, endDoc)
+            val startUtf16 = PositionBridge.scalarToUtf16(
+                startScalar,
+                text
+            ).coerceIn(0, text.length)
+            val endUtf16 = PositionBridge.scalarToUtf16(endScalar, text).coerceIn(0, text.length)
+
+            val selectionPath = if (startUtf16 != endUtf16) {
+                Path().apply {
+                    context.layout.getSelectionPath(startUtf16, endUtf16, this)
+                    offset(context.snapshot.baseX.toFloat(), context.snapshot.baseY.toFloat())
+                }
+            } else {
+                null
+            }
+
+            CachedSelectionGeometry(
+                clientId = selection.clientId,
+                selectionPath = selectionPath,
+                selectionColor = withAlpha(selection.color, 0.18f),
+                caretRect = caretRectForOffset(
+                    endUtf16 = endUtf16,
+                    textLength = text.length,
+                    layout = context.layout,
+                    baseX = context.snapshot.baseX.toFloat(),
+                    baseY = context.snapshot.baseY.toFloat(),
+                    caretWidth = context.caretWidth,
+                    isFocused = selection.isFocused
+                ),
+                caretColor = selection.color
+            )
+        }
+
+        cachedSnapshot = context.snapshot
+        cachedGeometry = geometry
+        return geometry
+    }
+
+    private fun buildGeometryContext(): GeometryContext? {
+        val editorView = editorView ?: return null
+        val editorId = resolvedEditorId(editorView)
+        if (editorId == 0L || remoteSelections.isEmpty()) return null
+
+        val editText = editorView.editorEditText
+        val layout = editText.layout ?: return null
+        val text = editText.text?.toString() ?: return null
+        val baseX =
+            editorView.editorViewport.left + editorView.editorScrollView.left + editText.left +
+                editText.compoundPaddingLeft
+        val baseY = editorView.editorViewport.top + editorView.editorScrollView.top + editText.top +
+            editText.compoundPaddingTop - editorView.editorScrollView.scrollY
+        val caretWidth = maxOf(2f, resources.displayMetrics.density)
+
+        return GeometryContext(
+            snapshot = GeometrySnapshot(
+                editorId = editorId,
+                text = text,
+                layoutWidth = layout.width,
+                layoutHeight = layout.height,
+                baseX = baseX,
+                baseY = baseY,
+                width = width,
+                height = height,
+                selections = remoteSelections
+            ),
+            layout = layout,
+            caretWidth = caretWidth
+        )
+    }
+
+    private fun invalidateGeometry() {
+        cachedSnapshot = null
+    }
+
+    private fun caretRectForOffset(
+        endUtf16: Int,
+        textLength: Int,
+        layout: android.text.Layout,
+        baseX: Float,
+        baseY: Float,
+        caretWidth: Float,
+        isFocused: Boolean
+    ): RectF? {
+        if (!isFocused) return null
+
+        val clampedOffset = endUtf16.coerceIn(0, textLength)
+        val line = layout.getLineForOffset(clampedOffset)
+        val horizontal = layout.getPrimaryHorizontal(clampedOffset)
+        val caretLeft = baseX + horizontal
+        val caretTop = baseY + layout.editorTextLineTop(line)
+        val caretBottom = baseY + layout.editorTextLineBottom(line)
+        return RectF(caretLeft, caretTop, caretLeft + caretWidth, caretBottom)
+    }
+
+    private fun withAlpha(color: Int, alphaFraction: Float): Int {
+        val alpha = (255f * alphaFraction).toInt().coerceIn(0, 255)
+        return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color))
+    }
+
+    private fun resolvedEditorId(editorView: RichTextEditorView): Long =
+        editorIdOverrideForTesting ?: editorView.editorId
+}

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

@@ -0,0 +1,314 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+import android.text.Annotation
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+import android.text.style.LineBackgroundSpan
+import android.text.style.ReplacementSpan
+
+class BlockquoteSpan(
+    private val baseIndentPx: Int,
+    private val totalIndentPx: Int,
+    private val stripeColor: Int,
+    private val stripeWidthPx: Int,
+    private val gapWidthPx: Int
+) : LeadingMarginSpan {
+
+    override fun getLeadingMargin(first: Boolean): Int = totalIndentPx
+
+    override fun drawLeadingMargin(
+        canvas: Canvas,
+        paint: Paint,
+        x: Int,
+        dir: Int,
+        top: Int,
+        baseline: Int,
+        bottom: Int,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        first: Boolean,
+        layout: android.text.Layout?
+    ) {
+        if (!lineContainsQuotedContent(text, start, end)) {
+            return
+        }
+
+        val savedColor = paint.color
+        val savedStyle = paint.style
+
+        paint.color = stripeColor
+        paint.style = Paint.Style.FILL
+
+        val stripeStart = x + (dir * baseIndentPx)
+        val stripeLeft = if (dir >
+            0
+        ) {
+            stripeStart.toFloat()
+        } else {
+            (stripeStart - stripeWidthPx).toFloat()
+        }
+        val stripeRight = if (dir > 0) stripeLeft + stripeWidthPx else stripeLeft + stripeWidthPx
+        val stripeBottom = resolvedStripeBottom(
+            text = text,
+            start = start,
+            end = end,
+            baseline = baseline,
+            bottom = bottom,
+            layout = layout,
+            paint = paint
+        )
+        canvas.drawRect(
+            stripeLeft,
+            top.toFloat(),
+            stripeRight,
+            stripeBottom,
+            paint
+        )
+
+        paint.color = savedColor
+        paint.style = savedStyle
+    }
+
+    private fun lineContainsQuotedContent(text: CharSequence, start: Int, end: Int): Boolean {
+        if (start >= end || text !is Spanned) return true
+        for (index in start until end.coerceAtMost(text.length)) {
+            val ch = text[index]
+            if (ch == '\n' || ch == '\r') continue
+            val quoted = text.getSpans(index, index + 1, Annotation::class.java).any {
+                it.key == RenderBridge.NATIVE_BLOCKQUOTE_ANNOTATION
+            }
+            if (quoted) {
+                return true
+            }
+        }
+        return false
+    }
+
+    internal fun resolvedStripeBottom(
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        baseline: Int,
+        bottom: Int,
+        layout: android.text.Layout?,
+        paint: Paint? = null
+    ): Float {
+        if (layout == null || text.isEmpty()) {
+            return bottom.toFloat()
+        }
+        val lineIndex = safeLineForOffset(layout, start, text.length)
+        val nextLine = lineIndex + 1
+        if (nextLine >= layout.lineCount) {
+            return trimmedTextBottom(baseline, layout, lineIndex, paint)
+        }
+
+        val nextLineStart = layout.getLineStart(nextLine)
+        val nextLineEnd = layout.getLineEnd(nextLine)
+        return if (lineContainsQuotedContent(text, nextLineStart, nextLineEnd)) {
+            bottom.toFloat()
+        } else {
+            trimmedTextBottom(baseline, layout, lineIndex, paint)
+        }
+    }
+
+    private fun trimmedTextBottom(
+        baseline: Int,
+        layout: Layout,
+        lineIndex: Int,
+        paint: Paint?
+    ): Float {
+        val fontDescent = paint?.fontMetrics?.descent
+        return if (fontDescent != null) {
+            baseline + fontDescent
+        } else {
+            (baseline + layout.getLineDescent(lineIndex)).toFloat()
+        }
+    }
+
+    private fun safeLineForOffset(layout: Layout, offset: Int, textLength: Int): Int {
+        if (textLength <= 0) return 0
+        val safeStart = offset.coerceIn(0, textLength - 1)
+        return layout.getLineForOffset(safeStart)
+    }
+}
+
+class CodeBlockSpan(
+    private val backgroundColor: Int,
+    private val cornerRadiusPx: Float,
+    private val paddingHorizontalPx: Int,
+    private val paddingVerticalPx: Int
+) : LeadingMarginSpan,
+    LineBackgroundSpan {
+    internal val documentBox: EditorBoxStyle get() = EditorBoxStyle(
+        backgroundColor = backgroundColor,
+        padding = EditorEdges(
+            paddingVerticalPx.toFloat(),
+            paddingHorizontalPx.toFloat(),
+            paddingVerticalPx.toFloat(),
+            paddingHorizontalPx.toFloat()
+        ),
+        corners = EditorCorners(cornerRadiusPx, cornerRadiusPx, cornerRadiusPx, cornerRadiusPx)
+    )
+    override fun getLeadingMargin(first: Boolean): Int = paddingHorizontalPx
+
+    override fun drawLeadingMargin(
+        canvas: Canvas,
+        paint: Paint,
+        x: Int,
+        dir: Int,
+        top: Int,
+        baseline: Int,
+        bottom: Int,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        first: Boolean,
+        layout: Layout
+    ) = Unit
+
+    override fun drawBackground(
+        canvas: Canvas,
+        paint: Paint,
+        left: Int,
+        right: Int,
+        top: Int,
+        baseline: Int,
+        bottom: Int,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        lineNumber: Int
+    ) {
+        val spanned = text as? Spanned ?: return
+        val spanStart = spanned.getSpanStart(this)
+        val spanEnd = spanned.getSpanEnd(this)
+        if (spanStart < 0 || start >= spanEnd || end <= spanStart) return
+
+        val isFirstLine = start <= spanStart
+        val isLastLine = end >= spanEnd
+        val rect = RectF(
+            left.toFloat(),
+            if (isFirstLine) top.toFloat() - paddingVerticalPx else top.toFloat(),
+            (right - paddingHorizontalPx).toFloat(),
+            if (isLastLine) bottom.toFloat() + paddingVerticalPx else bottom.toFloat()
+        )
+
+        val savedColor = paint.color
+        val savedStyle = paint.style
+        paint.color = backgroundColor
+        paint.style = Paint.Style.FILL
+
+        when {
+            isFirstLine && isLastLine -> canvas.drawRoundRect(
+                rect,
+                cornerRadiusPx,
+                cornerRadiusPx,
+                paint
+            )
+
+            isFirstLine -> {
+                canvas.drawRoundRect(rect, cornerRadiusPx, cornerRadiusPx, paint)
+                canvas.drawRect(rect.left, rect.centerY(), rect.right, rect.bottom, paint)
+            }
+
+            isLastLine -> {
+                canvas.drawRoundRect(rect, cornerRadiusPx, cornerRadiusPx, paint)
+                canvas.drawRect(rect.left, rect.top, rect.right, rect.centerY(), paint)
+            }
+
+            else -> canvas.drawRect(rect, paint)
+        }
+
+        paint.color = savedColor
+        paint.style = savedStyle
+    }
+}
+
+class HorizontalRuleSpan(
+    private val lineColor: Int,
+    private val lineHeight: Float = LayoutConstants.HORIZONTAL_RULE_HEIGHT,
+    private val verticalPadding: Float = LayoutConstants.HORIZONTAL_RULE_VERTICAL_PADDING,
+    private val boxInset: EditorEdges = EditorEdges()
+) : ReplacementSpan(),
+    LeadingMarginSpan {
+
+    override fun getLeadingMargin(first: Boolean): Int = 0
+
+    override fun getSize(
+        paint: Paint,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        fm: Paint.FontMetricsInt?
+    ): Int {
+        if (fm != null) {
+            val totalHeight = kotlin.math.ceil(lineHeight + (verticalPadding * 2)).toInt()
+            val halfHeight = totalHeight / 2
+            fm.ascent = -halfHeight
+            fm.top = fm.ascent
+            fm.descent = totalHeight - halfHeight
+            fm.bottom = fm.descent
+        }
+        // Keep the placeholder atom in the text model without reserving
+        // visible glyph width, so Android does not paint a tofu/OBJ box.
+        return 0
+    }
+
+    override fun drawLeadingMargin(
+        canvas: Canvas,
+        paint: Paint,
+        x: Int,
+        dir: Int,
+        top: Int,
+        baseline: Int,
+        bottom: Int,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        first: Boolean,
+        layout: android.text.Layout?
+    ) {
+        val savedColor = paint.color
+        val savedStyle = paint.style
+
+        paint.color = lineColor
+        paint.style = Paint.Style.FILL
+
+        val owned =
+            text is Spanned &&
+                text.getSpans(start, end, EditorOwnedBlockGeometrySpan::class.java).isNotEmpty()
+        val inset = if (owned) EditorEdges() else boxInset
+        val lineY = (top + inset.top + bottom - inset.bottom) / 2f
+        val lineWidth = (layout?.width?.toFloat() ?: canvas.width.toFloat()) - inset.right
+        canvas.drawRect(
+            x.toFloat(),
+            lineY - lineHeight / 2f,
+            lineWidth,
+            lineY + lineHeight / 2f,
+            paint
+        )
+
+        paint.color = savedColor
+        paint.style = savedStyle
+    }
+
+    override fun draw(
+        canvas: Canvas,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        x: Float,
+        top: Int,
+        y: Int,
+        bottom: Int,
+        paint: Paint
+    ) {
+        // Intentionally empty: drawLeadingMargin renders the separator line,
+        // and ReplacementSpan suppresses drawing the underlying FFFC glyph.
+    }
+}