@apollohg/react-native-prose-editor 0.3.0 → 0.4.1

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

@@ -8,25 +8,22 @@ import android.icu.text.BreakIterator
  * cursor inside a composed character.
  */
 object PositionBridge {
+    private data class ConversionTable(
+        val utf16ToScalar: IntArray,
+        val scalarToUtf16: IntArray,
+    )
+
+    private val cacheLock = Any()
+    @Volatile private var cachedText: String? = null
+    @Volatile private var cachedTable: ConversionTable? = null
 
     /**
      * Counts code points from the start of the string up to the given UTF-16 offset.
      */
     fun utf16ToScalar(utf16Offset: Int, text: String): Int {
-        if (utf16Offset <= 0) return 0
-
-        val endIndex = minOf(utf16Offset, text.length)
-        var scalarCount = 0
-        var utf16Pos = 0
-
-        while (utf16Pos < endIndex) {
-            val codePoint = Character.codePointAt(text, utf16Pos)
-            val charCount = Character.charCount(codePoint)
-            utf16Pos += charCount
-            scalarCount++
-        }
-
-        return scalarCount
+        val conversionTable = conversionTableFor(text)
+        val endIndex = utf16Offset.coerceIn(0, conversionTable.utf16ToScalar.size - 1)
+        return conversionTable.utf16ToScalar[endIndex]
     }
 
     /**
@@ -35,19 +32,9 @@ object PositionBridge {
     fun scalarToUtf16(scalarOffset: Int, text: String): Int {
         if (scalarOffset <= 0) return 0
 
-        var utf16Len = 0
-        var scalarsSeen = 0
-
-        var i = 0
-        while (i < text.length && scalarsSeen < scalarOffset) {
-            val codePoint = Character.codePointAt(text, i)
-            val charCount = Character.charCount(codePoint)
-            utf16Len += charCount
-            scalarsSeen++
-            i += charCount
-        }
-
-        return utf16Len
+        val conversionTable = conversionTableFor(text)
+        val clampedScalar = scalarOffset.coerceIn(0, conversionTable.scalarToUtf16.size - 1)
+        return conversionTable.scalarToUtf16[clampedScalar]
     }
 
     /**
@@ -73,4 +60,47 @@ object PositionBridge {
         val nextBoundary = breakIterator.following(clampedOffset)
         return if (nextBoundary == BreakIterator.DONE) text.length else nextBoundary
     }
+
+    private fun conversionTableFor(text: String): ConversionTable {
+        val lastText = cachedText
+        val lastTable = cachedTable
+        if (lastText == text && lastTable != null) {
+            return lastTable
+        }
+
+        synchronized(cacheLock) {
+            val synchronizedText = cachedText
+            val synchronizedTable = cachedTable
+            if (synchronizedText == text && synchronizedTable != null) {
+                return synchronizedTable
+            }
+
+            val scalarCount = text.codePointCount(0, text.length)
+            val utf16ToScalar = IntArray(text.length + 1)
+            val scalarToUtf16 = IntArray(scalarCount + 1)
+
+            var utf16Pos = 0
+            var scalarPos = 0
+            while (utf16Pos < text.length) {
+                val codePoint = Character.codePointAt(text, utf16Pos)
+                val charCount = Character.charCount(codePoint)
+                val nextUtf16Pos = utf16Pos + charCount
+                scalarPos += 1
+
+                for (offset in (utf16Pos + 1)..nextUtf16Pos) {
+                    utf16ToScalar[offset] = scalarPos
+                }
+                scalarToUtf16[scalarPos] = nextUtf16Pos
+                utf16Pos = nextUtf16Pos
+            }
+
+            return ConversionTable(
+                utf16ToScalar = utf16ToScalar,
+                scalarToUtf16 = scalarToUtf16,
+            ).also {
+                cachedText = text
+                cachedTable = it
+            }
+        }
+    }
 }

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

@@ -10,7 +10,6 @@ import android.util.AttributeSet
 import android.util.TypedValue
 import android.view.View
 import androidx.appcompat.content.res.AppCompatResources
-import com.google.android.material.R as MaterialR
 import org.json.JSONArray
 import uniffi.editor_core.editorDocToScalar
 
@@ -61,8 +60,8 @@ data class RemoteSelectionDecoration(
         private fun resolveFallbackColor(context: Context): Int {
             val typedValue = TypedValue()
             val attrs = intArrayOf(
-                MaterialR.attr.colorPrimary,
-                MaterialR.attr.colorSecondary,
+                androidx.appcompat.R.attr.colorPrimary,
+                androidx.appcompat.R.attr.colorAccent,
                 android.R.attr.colorAccent,
                 android.R.attr.textColorPrimary
             )
@@ -93,14 +92,40 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
     attrs: AttributeSet? = null,
     defStyleAttr: Int = 0,
 ) : View(context, attrs, defStyleAttr) {
+    private data class CachedSelectionGeometry(
+        val clientId: Int,
+        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 ->
         editorDocToScalar(editorId.toULong(), docPos.toUInt()).toInt()
     }
-    private val selectionPath = Path()
     private val selectionPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
         style = Paint.Style.FILL
     }
@@ -116,60 +141,76 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
 
     fun bind(editorView: RichTextEditorView) {
         this.editorView = editorView
+        invalidateGeometry()
     }
 
     fun setRemoteSelections(selections: List<RemoteSelectionDecoration>) {
+        if (remoteSelections == selections) {
+            return
+        }
         remoteSelections = selections
-        invalidate()
+        invalidateGeometry()
+        refreshGeometry()
     }
 
-    fun debugSnapshotsForTesting(): List<RemoteSelectionDebugSnapshot> {
-        val editorView = editorView ?: return emptyList()
-        val editorId = resolvedEditorId(editorView)
-        if (editorId == 0L || remoteSelections.isEmpty()) return emptyList()
+    fun refreshGeometry() {
+        ensureGeometry()
+        invalidate()
+    }
 
-        val editText = editorView.editorEditText
-        val layout = editText.layout ?: return emptyList()
-        val text = editText.text?.toString() ?: return emptyList()
-        val baseX = (editorView.editorViewport.left + editorView.editorScrollView.left + editText.left).toFloat() +
-            editText.compoundPaddingLeft
-        val baseY = (editorView.editorViewport.top + editorView.editorScrollView.top + editText.top).toFloat() +
-            editText.compoundPaddingTop - editorView.editorScrollView.scrollY
-        val caretWidth = maxOf(2f, 2f * resources.displayMetrics.density / 2f)
+    fun hasSelectionsOrCachedGeometry(): Boolean {
+        return remoteSelections.isNotEmpty() || cachedGeometry.isNotEmpty()
+    }
 
-        return remoteSelections.map { selection ->
+    fun debugSnapshotsForTesting(): List<RemoteSelectionDebugSnapshot> {
+        return ensureGeometry().map { geometry ->
             RemoteSelectionDebugSnapshot(
-                clientId = selection.clientId,
-                caretRect = caretRectForSelection(
-                    selection = selection,
-                    editorId = editorId,
-                    text = text,
-                    layout = layout,
-                    baseX = baseX,
-                    baseY = baseY,
-                    caretWidth = caretWidth,
-                ),
+                clientId = geometry.clientId,
+                caretRect = geometry.caretRect?.let(::RectF),
             )
         }
     }
 
     override fun onDraw(canvas: Canvas) {
         super.onDraw(canvas)
+        val geometry = ensureGeometry()
+        if (geometry.isEmpty()) return
 
-        val editorView = editorView ?: return
-        val editorId = resolvedEditorId(editorView)
-        if (editorId == 0L || remoteSelections.isEmpty()) return
+        for (entry in geometry) {
+            entry.selectionPath?.let { path ->
+                selectionPaint.color = entry.selectionColor
+                canvas.drawPath(path, selectionPaint)
+            }
 
-        val editText = editorView.editorEditText
-        val layout = editText.layout ?: return
-        val text = editText.text?.toString() ?: return
-        val baseX = (editorView.editorViewport.left + editorView.editorScrollView.left + editText.left).toFloat() +
-            editText.compoundPaddingLeft
-        val baseY = (editorView.editorViewport.top + editorView.editorScrollView.top + editText.top).toFloat() +
-            editText.compoundPaddingTop - editorView.editorScrollView.scrollY
-        val caretWidth = maxOf(2f, 2f * resources.displayMetrics.density / 2f)
+            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
+                )
+            }
+        }
+    }
 
-        for (selection in remoteSelections) {
+    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)
@@ -177,59 +218,87 @@ class RemoteSelectionOverlayView @JvmOverloads constructor(
             val startUtf16 = PositionBridge.scalarToUtf16(startScalar, text).coerceIn(0, text.length)
             val endUtf16 = PositionBridge.scalarToUtf16(endScalar, text).coerceIn(0, text.length)
 
-            selectionPaint.color = withAlpha(selection.color, 0.18f)
-            caretPaint.color = selection.color
-
-            if (startUtf16 != endUtf16) {
-                selectionPath.reset()
-                layout.getSelectionPath(startUtf16, endUtf16, selectionPath)
-                canvas.save()
-                canvas.translate(baseX, baseY)
-                canvas.drawPath(selectionPath, selectionPaint)
-                canvas.restore()
+            val selectionPath = if (startUtf16 != endUtf16) {
+                Path().apply {
+                    context.layout.getSelectionPath(startUtf16, endUtf16, this)
+                    offset(context.snapshot.baseX.toFloat(), context.snapshot.baseY.toFloat())
+                }
+            } else {
+                null
             }
 
-            if (!selection.isFocused) {
-                continue
-            }
+            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 caretRect = caretRectForSelection(
-                selection = selection,
+        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,
-                layout = layout,
+                layoutWidth = layout.width,
+                layoutHeight = layout.height,
                 baseX = baseX,
                 baseY = baseY,
-                caretWidth = caretWidth,
-            ) ?: continue
-            canvas.drawRoundRect(
-                caretRect.left,
-                caretRect.top,
-                caretRect.right,
-                caretRect.bottom,
-                caretWidth / 2f,
-                caretWidth / 2f,
-                caretPaint
-            )
-        }
+                width = width,
+                height = height,
+                selections = remoteSelections,
+            ),
+            layout = layout,
+            caretWidth = caretWidth,
+        )
+    }
+
+    private fun invalidateGeometry() {
+        cachedSnapshot = null
     }
 
-    private fun caretRectForSelection(
-        selection: RemoteSelectionDecoration,
-        editorId: Long,
-        text: String,
+    private fun caretRectForOffset(
+        endUtf16: Int,
+        textLength: Int,
         layout: android.text.Layout,
         baseX: Float,
         baseY: Float,
         caretWidth: Float,
+        isFocused: Boolean,
     ): RectF? {
-        if (!selection.isFocused) return null
+        if (!isFocused) return null
 
-        val endDoc = maxOf(selection.anchor, selection.head)
-        val endScalar = docToScalarResolver(editorId, endDoc)
-        val endUtf16 = PositionBridge.scalarToUtf16(endScalar, text).coerceIn(0, text.length)
-        val line = layout.getLineForOffset(endUtf16.coerceAtMost(maxOf(text.length - 1, 0)))
-        val horizontal = layout.getPrimaryHorizontal(endUtf16)
+        val clampedOffset = endUtf16.coerceIn(0, textLength)
+        val lineLookupOffset = clampedOffset.coerceAtMost(maxOf(textLength - 1, 0))
+        val line = layout.getLineForOffset(lineLookupOffset)
+        val horizontal = layout.getPrimaryHorizontal(clampedOffset)
         val caretLeft = baseX + horizontal
         val caretTop = baseY + layout.getLineTop(line)
         val caretBottom = baseY + layout.getLineBottom(line)