@june24/expo-pdf-reader 0.1.17 → 0.1.19

package/android/src/main/java/expo/modules/pdfreader/ExpoPdfReaderView.kt

@@ -2,11 +2,20 @@ package expo.modules.pdfreader
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.graphics.*
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PointF
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.graphics.drawable.BitmapDrawable
 import android.graphics.pdf.PdfRenderer
 import android.os.ParcelFileDescriptor
-import android.text.TextPaint
-import android.view.*
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
 import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.LinearLayout
@@ -18,36 +27,47 @@ import java.io.File
 import java.net.URL
 import kotlinx.coroutines.*
 
-// Annotation types matching iOS
+/** Annotation type string matching iOS. */
 enum class AnnotationTool { PEN, HIGHLIGHTER, TEXT, NOTE, ERASER, LINE }
 
-// In-memory annotation model (Android has no PDFKit annotations)
+/** Single annotation (pen/highlighter/line/text/note). */
 data class Annotation(
-    val type: String, // "pen", "highlighter", "line", "text", "note"
+    val type: String,
     val bounds: RectF,
     var color: Int,
-    var strokeWidth: Float = 2f,
-    val paths: MutableList<MutableList<PointF>> = mutableListOf(),
-    var contents: String = " ",
-    var fontSize: Float = 14f,
-    var bold: Boolean = false,
-    var italic: Boolean = false
+    var strokeWidth: Float,
+    val paths: MutableList<MutableList<PointF>>,
+    var contents: String,
+    var fontSize: Float,
+    var bold: Boolean,
+    var italic: Boolean
 )
 
-private data class UndoEntry(val annotation: Annotation, val pageIndex: Int)
+/** Undo/redo entry. */
+data class UndoEntry(val annotation: Annotation, val pageIndex: Int)
 
+/** ScrollView that respects currentTool: scroll only when no tool selected. */
 @SuppressLint("ViewConstructor")
-class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+private class ToolAwareScrollView(
+    context: Context,
+    private val isScrollEnabledProvider: () -> Boolean
+) : ScrollView(context) {
+    override fun onTouchEvent(ev: MotionEvent): Boolean {
+        if (!isScrollEnabledProvider()) return false
+        return super.onTouchEvent(ev)
+    }
 
-    private inner class ToolAwareScrollView(ctx: Context) : ScrollView(ctx) {
-        var scrollEnabled: Boolean = true
-        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-            if (!scrollEnabled) return false
-            return super.onInterceptTouchEvent(ev)
-        }
+    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+        if (!isScrollEnabledProvider()) return false
+        return super.onInterceptTouchEvent(ev)
     }
+}
 
-    private val scrollView = ToolAwareScrollView(context)
+/** Android PDF viewer with full annotation support matching iOS. */
+@SuppressLint("ViewConstructor")
+class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+
+    private val scrollView = ToolAwareScrollView(context) { currentTool == null }
     private val container = LinearLayout(context).apply {
         orientation = LinearLayout.VERTICAL
     }
@@ -56,9 +76,11 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     private var fileDescriptor: ParcelFileDescriptor? = null
     private val scope = CoroutineScope(Dispatchers.Main + Job())
 
-    private var displayMode = "continuous"
-    private var initialPage: Int = 0
+    private var initialPage = 0
     private var pdfUrl: String? = null
+    private var renderPdfRetryCount = 0
+    private val maxRenderPdfRetries = 30
+    private var displayMode = "continuous"
 
     private val onPageChange = ViewEvent<Map<String, Any>>("onPageChange", this, null)
     private val onAnnotationChange = ViewEvent<Map<String, Any>>("onAnnotationChange", this, null)
@@ -66,313 +88,275 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     private val onNotePress = ViewEvent<Map<String, Any>>("onNotePress", this, null)
     private val onTextPress = ViewEvent<Map<String, Any>>("onTextPress", this, null)
 
-    // Per-page annotations (same structure as iOS, but we store in memory)
-    private var pageAnnotations: MutableList<MutableList<Annotation>> = mutableListOf()
-    private var appliedAnnotationsFingerprint: String? = null
-    private var pendingAnnotations: List<Map<String, Any>>? = null
-
-    private var currentTool: AnnotationTool? = null
-    private var strokeColor: Int = Color.RED
-    private var strokeWidth: Float = 2f
-    private var textContent: String = ""
-    private var textColor: Int = Color.BLACK
-    private var textFontSize: Float = 14f
-    private var textBold: Boolean = false
-    private var textItalic: Boolean = false
-    private var noteColor: Int = Color.YELLOW
-
-    private val undoStack = mutableListOf<UndoEntry>()
-    private val redoStack = mutableListOf<UndoEntry>()
-
     private var pageHeights = mutableListOf<Int>()
     private var pageWidthsPdf = mutableListOf<Float>()
     private var pageHeightsPdf = mutableListOf<Float>()
     private var pageViews = mutableListOf<ImageView?>()
     private var overlayViews = mutableListOf<AnnotationOverlayView?>()
-    private var renderGeneration = 0
     private var lastEmittedPageIndex = -1
     private var totalPageCount = 0
 
-    // Drawing state (like iOS currentPath, activePage, startPoint, preview)
+    private val renderWindowBefore = 8
+    private val renderWindowAfter = 16
+
+    // Annotation state
+    private val pageAnnotations = mutableListOf<MutableList<Annotation>>()
+    private var currentTool: AnnotationTool? = null
+    private var strokeColor = Color.RED
+    private var strokeWidth = 2f
+    private var textContent = ""
+    private var textColor = Color.BLACK
+    private var textFontSize = 14f
+    private var textBold = false
+    private var textItalic = false
+    private var noteColor = Color.YELLOW
+
     private var currentPath: Path? = null
-    private var currentPathPoints: MutableList<PointF>? = null
-    private var activePageIndex: Int = -1
+    private val currentPathPoints = mutableListOf<PointF>()
+    private var activePageIndex = -1
     private var startPoint: PointF? = null
     private var draggingAnnotation: Annotation? = null
-    private var draggingPageIndex: Int = -1
+    private var draggingPageIndex = -1
     private var dragStartBounds: RectF? = null
     private var dragStartTouch: PointF? = null
 
-    inner class AnnotationOverlayView(context: Context, val pageIndex: Int) : View(context) {
-        private fun scale(): Float {
-            val w = pageWidthsPdf.getOrNull(pageIndex) ?: 1f
-            return (width.toFloat() / w).coerceAtLeast(0.01f)
-        }
-        private val pathPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    private val undoStack = mutableListOf<UndoEntry>()
+    private val redoStack = mutableListOf<UndoEntry>()
+    private var appliedAnnotationsFingerprint: String? = null
+    private var pendingAnnotations: List<Map<String, Any>>? = null
+    private var renderJob: Job? = null
+
+    inner class AnnotationOverlayView(
+        context: Context,
+        val pageIndex: Int
+    ) : View(context) {
+
+        private val pathPaint = Paint().apply {
+            isAntiAlias = true
             style = Paint.Style.STROKE
-            strokeCap = Paint.Cap.ROUND
             strokeJoin = Paint.Join.ROUND
+            strokeCap = Paint.Cap.ROUND
+        }
+        private val textPaint = Paint().apply {
+            isAntiAlias = true
+            textAlign = Paint.Align.LEFT
+        }
+        private val noteFillPaint = Paint().apply {
+            style = Paint.Style.FILL
+            isAntiAlias = true
+        }
+        private val noteStrokePaint = Paint().apply {
+            style = Paint.Style.STROKE
             isAntiAlias = true
+            strokeWidth = 1f
         }
-        private val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
-        private var previewPath: Path? = null
-        private var previewPaint: Paint? = null
 
-        override fun onDraw(canvas: Canvas) {
-            val anns = getAnnotationsForPage(pageIndex)
-            for (ann in anns) {
-                drawAnnotation(canvas, ann)
-            }
-            // Drawing preview (current stroke)
-            if (activePageIndex == pageIndex && currentPath != null && previewPaint != null) {
-                canvas.drawPath(currentPath!!, previewPaint!!)
-            }
+        fun scale(): Float {
+            val pw = pageWidthsPdf.getOrNull(pageIndex) ?: 1f
+            if (pw <= 0f) return 1f
+            return width / pw
         }
 
-        private fun drawAnnotation(canvas: Canvas, ann: Annotation) {
+        override fun onDraw(canvas: Canvas) {
+            super.onDraw(canvas)
             val s = scale()
-            when (ann.type) {
-                "pen", "highlighter", "line" -> {
-                    pathPaint.color = ann.color
-                    pathPaint.strokeWidth = ann.strokeWidth * s
-                    if (ann.type == "highlighter") {
-                        pathPaint.alpha = (Color.alpha(ann.color) * 0.4f).toInt().coerceIn(0, 255)
-                    }
-                    for (pathPoints in ann.paths) {
-                        if (pathPoints.size < 2) continue
-                        val path = Path()
-                        path.moveTo(pathPoints[0].x * s, pathPoints[0].y * s)
-                        for (i in 1 until pathPoints.size) {
-                            path.lineTo(pathPoints[i].x * s, pathPoints[i].y * s)
+            if (s <= 0f) return
+
+            for (ann in getAnnotationsForPage(pageIndex)) {
+                val left = ann.bounds.left * s
+                val top = ann.bounds.top * s
+                val right = ann.bounds.right * s
+                val bottom = ann.bounds.bottom * s
+                when (ann.type) {
+                    "pen", "highlighter", "line" -> {
+                        pathPaint.color = ann.color
+                        pathPaint.strokeWidth = ann.strokeWidth * s
+                        pathPaint.alpha = if (ann.type == "highlighter") 102 else 255
+                        for (pathPoints in ann.paths) {
+                            if (pathPoints.size < 2) continue
+                            val path = Path()
+                            path.moveTo(pathPoints[0].x * s, pathPoints[0].y * s)
+                            for (i in 1 until pathPoints.size) {
+                                path.lineTo(pathPoints[i].x * s, pathPoints[i].y * s)
+                            }
+                            canvas.drawPath(path, pathPaint)
                         }
-                        canvas.drawPath(path, pathPaint)
                     }
-                    pathPaint.alpha = 255
-                }
-                "text" -> {
-                    textPaint.color = ann.color
-                    textPaint.textSize = ann.fontSize * s
-                    textPaint.typeface = Typeface.create(
-                        Typeface.DEFAULT,
-                        when {
-                            ann.bold && ann.italic -> Typeface.BOLD_ITALIC
-                            ann.bold -> Typeface.BOLD
-                            ann.italic -> Typeface.ITALIC
-                            else -> Typeface.NORMAL
+                    "text" -> {
+                        textPaint.color = ann.color
+                        textPaint.textSize = ann.fontSize * s
+                        textPaint.typeface = when {
+                            ann.bold && ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC)
+                            ann.bold -> Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+                            ann.italic -> Typeface.create(Typeface.DEFAULT, Typeface.ITALIC)
+                            else -> Typeface.DEFAULT
                         }
-                    )
-                    val text = ann.contents.ifEmpty { " " }
-                    val x = ann.bounds.left * s + 4
-                    val y = ann.bounds.top * s + ann.fontSize * s + 4
-                    canvas.drawText(text, x, y, textPaint)
-                }
-                "note" -> {
-                    pathPaint.color = ann.color
-                    pathPaint.style = Paint.Style.FILL
-                    val r = RectF(ann.bounds.left * s, ann.bounds.top * s, ann.bounds.right * s, ann.bounds.bottom * s)
-                    canvas.drawRect(r, pathPaint)
-                    pathPaint.style = Paint.Style.STROKE
-                    pathPaint.color = Color.argb(128, 0, 0, 0)
-                    pathPaint.strokeWidth = 1f
-                    canvas.drawRect(r, pathPaint)
-                    pathPaint.style = Paint.Style.STROKE
-                    textPaint.color = Color.BLACK
-                    textPaint.textSize = 10f * s
-                    canvas.drawText(ann.contents.ifEmpty { " " }.take(20), r.left + 4, r.top + 12f * s, textPaint)
+                        val text = ann.contents.ifEmpty { " " }
+                        canvas.drawText(text, left + 4f, top + ann.fontSize * s - 2f, textPaint)
+                    }
+                    "note" -> {
+                        noteFillPaint.color = ann.color
+                        noteStrokePaint.color = Color.BLACK
+                        canvas.drawRect(left, top, right, bottom, noteFillPaint)
+                        canvas.drawRect(left, top, right, bottom, noteStrokePaint)
+                        textPaint.color = Color.BLACK
+                        textPaint.textSize = 10f * s
+                        textPaint.typeface = Typeface.DEFAULT
+                        val text = ann.contents.ifEmpty { " " }
+                        canvas.drawText(text, left + 4f, top + 12f * s, textPaint)
+                    }
                 }
             }
-        }
 
-        fun setPreview(path: Path?, paint: Paint?) {
-            previewPath = path
-            previewPaint = paint
-            invalidate()
+            // Preview path for current stroke
+            if (activePageIndex == pageIndex && currentPath != null && currentPathPoints.isNotEmpty()) {
+                pathPaint.color = strokeColor
+                pathPaint.strokeWidth = strokeWidth * s
+                pathPaint.alpha = if (currentTool == AnnotationTool.HIGHLIGHTER) 102 else 255
+                val path = Path()
+                path.moveTo(currentPathPoints[0].x * s, currentPathPoints[0].y * s)
+                for (i in 1 until currentPathPoints.size) {
+                    path.lineTo(currentPathPoints[i].x * s, currentPathPoints[i].y * s)
+                }
+                canvas.drawPath(path, pathPaint)
+            }
         }
 
+        @SuppressLint("ClickableViewAccessibility")
         override fun onTouchEvent(event: MotionEvent): Boolean {
-            if (pageIndex >= pageHeights.size) return false
-            val x = event.x
-            val y = event.y
+            val s = scale()
+            if (s <= 0f) return false
+            val pdfX = event.x / s
+            val pdfY = event.y / s
+
             if (currentTool != null) {
-                return handleToolTouch(event, x, y)
+                return handleToolTouch(event, pdfX, pdfY, s)
             }
-            return handleTapAndDrag(event, x, y)
+            return handleTapAndDrag(event, pdfX, pdfY, s)
         }
 
-        private fun handleToolTouch(event: MotionEvent, x: Float, y: Float): Boolean {
-            val tool = currentTool ?: return false
-            when (event.action) {
+        private fun handleToolTouch(event: MotionEvent, pdfX: Float, pdfY: Float, scale: Float): Boolean {
+            when (event.actionMasked) {
                 MotionEvent.ACTION_DOWN -> {
+                    val tool = currentTool ?: return false
+                    activePageIndex = pageIndex
+                    startPoint = PointF(pdfX, pdfY)
                     when (tool) {
                         AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER, AnnotationTool.LINE -> {
-                            activePageIndex = pageIndex
-                            startPoint = PointF(x, y)
-                            currentPath = Path().apply { moveTo(x, y) }
-                            currentPathPoints = mutableListOf(PointF(x, y))
-                            val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-                                style = Paint.Style.STROKE
-                                strokeCap = Paint.Cap.ROUND
-                                strokeJoin = Paint.Join.ROUND
-                                color = strokeColor
-                                strokeWidth = this@ExpoPdfReaderView.strokeWidth
-                                if (tool == AnnotationTool.HIGHLIGHTER) alpha = (0.4f * 255).toInt()
-                            }
-                            setPreview(currentPath, paint)
-                            invalidate()
+                            currentPath = Path()
+                            currentPathPoints.clear()
+                            currentPathPoints.add(PointF(pdfX, pdfY))
+                            currentPath?.moveTo(pdfX, pdfY)
                         }
                         AnnotationTool.TEXT, AnnotationTool.NOTE -> {
-                            val s = scale()
-                            addInstantAnnotation(pageIndex, x / s, y / s, tool)
+                            addInstantAnnotation(pageIndex, pdfX, pdfY, tool)
                         }
                         AnnotationTool.ERASER -> {
-                            val s = scale()
-                            eraseAt(pageIndex, x / s, y / s)
+                            eraseAt(pageIndex, pdfX, pdfY)
                         }
                     }
+                    invalidate()
                     return true
                 }
                 MotionEvent.ACTION_MOVE -> {
+                    val tool = currentTool ?: return true
                     when (tool) {
                         AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER -> {
-                            if (activePageIndex == pageIndex && currentPath != null && currentPathPoints != null) {
-                                currentPath!!.lineTo(x, y)
-                                currentPathPoints!!.add(PointF(x, y))
-                                invalidate()
-                            }
+                            currentPathPoints.add(PointF(pdfX, pdfY))
+                            currentPath?.lineTo(pdfX, pdfY)
                         }
                         AnnotationTool.LINE -> {
-                            if (activePageIndex == pageIndex && startPoint != null && currentPath != null && currentPathPoints != null) {
-                                currentPath!!.reset()
-                                currentPath!!.moveTo(startPoint!!.x, startPoint!!.y)
-                                currentPath!!.lineTo(x, y)
-                                currentPathPoints!!.clear()
-                                currentPathPoints!!.add(PointF(startPoint!!.x, startPoint!!.y))
-                                currentPathPoints!!.add(PointF(x, y))
-                                invalidate()
-                            }
-                        }
-                        AnnotationTool.ERASER -> {
-                            val s = scale()
-                            eraseAt(pageIndex, x / s, y / s)
+                            val start = startPoint ?: return true
+                            currentPathPoints.clear()
+                            currentPathPoints.add(PointF(start.x, start.y))
+                            currentPathPoints.add(PointF(pdfX, pdfY))
+                            currentPath?.reset()
+                            currentPath?.moveTo(start.x, start.y)
+                            currentPath?.lineTo(pdfX, pdfY)
                         }
+                        AnnotationTool.ERASER -> eraseAt(pageIndex, pdfX, pdfY)
                         else -> {}
                     }
+                    invalidate()
                     return true
                 }
                 MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
-                    when (tool) {
+                    when (currentTool) {
                         AnnotationTool.PEN, AnnotationTool.HIGHLIGHTER, AnnotationTool.LINE -> {
-                            if (activePageIndex == pageIndex && currentPathPoints != null && currentPathPoints!!.size >= 2) {
-                                commitStroke(tool)
+                            if (currentPathPoints.size >= 2) {
+                                commitStroke(currentTool!!)
                             }
-                            setPreview(null, null)
                             currentPath = null
-                            currentPathPoints = null
-                            activePageIndex = -1
-                            startPoint = null
-                            invalidate()
+                            currentPathPoints.clear()
                         }
                         else -> {}
                     }
+                    activePageIndex = -1
+                    startPoint = null
+                    invalidate()
                     return true
                 }
             }
             return false
         }
 
-        private fun commitStroke(tool: AnnotationTool) {
-            var pts = currentPathPoints ?: return
-            if (tool == AnnotationTool.LINE && startPoint != null && pts.size >= 1) {
-                pts = mutableListOf(PointF(startPoint!!.x, startPoint!!.y), pts.last())
-            }
-            if (pts.size < 2) return
-            val s = scale()
-            val ptsPdf = pts.map { PointF(it.x / s, it.y / s) }.toMutableList()
-            val pathBounds = RectF()
-            val path = Path().apply {
-                moveTo(ptsPdf[0].x, ptsPdf[0].y)
-                for (i in 1 until ptsPdf.size) lineTo(ptsPdf[i].x, ptsPdf[i].y)
-            }
-            path.computeBounds(pathBounds, true)
-            pathBounds.inset(-strokeWidth / s, -strokeWidth / s)
-            val color = if (tool == AnnotationTool.HIGHLIGHTER) Color.argb(102, Color.red(strokeColor), Color.green(strokeColor), Color.blue(strokeColor)) else strokeColor
-            val ann = Annotation(
-                type = when (tool) {
-                    AnnotationTool.PEN -> "pen"
-                    AnnotationTool.HIGHLIGHTER -> "highlighter"
-                    AnnotationTool.LINE -> "line"
-                    else -> "pen"
-                },
-                bounds = RectF(pathBounds),
-                color = color,
-                strokeWidth = strokeWidth / s,
-                paths = mutableListOf(ptsPdf)
-            )
-            addAnnotationToPage(pageIndex, ann)
-        }
-
-        private fun handleTapAndDrag(event: MotionEvent, x: Float, y: Float): Boolean {
-            val s = scale()
-            val pdfX = x / s
-            val pdfY = y / s
-            val anns = getAnnotationsForPage(pageIndex)
-            when (event.action) {
+        private fun handleTapAndDrag(event: MotionEvent, pdfX: Float, pdfY: Float, scale: Float): Boolean {
+            when (event.actionMasked) {
                 MotionEvent.ACTION_DOWN -> {
-                    for ((idx, ann) in anns.withIndex()) {
-                        if (ann.bounds.contains(pdfX, pdfY)) {
-                            when (ann.type) {
-                                "text" -> {
-                                    onTextPress(mapOf(
-                                        "page" to pageIndex,
-                                        "index" to idx,
-                                        "bounds" to mapOf(
-                                            "x" to ann.bounds.left,
-                                            "y" to ann.bounds.top,
-                                            "width" to ann.bounds.width(),
-                                            "height" to ann.bounds.height()
-                                        ),
-                                        "contents" to (ann.contents)
-                                    ))
-                                    return true
-                                }
-                                "note" -> {
-                                    onNotePress(mapOf(
-                                        "page" to pageIndex,
-                                        "index" to idx,
-                                        "bounds" to mapOf(
-                                            "x" to ann.bounds.left,
-                                            "y" to ann.bounds.top,
-                                            "width" to ann.bounds.width(),
-                                            "height" to ann.bounds.height()
-                                        ),
-                                        "contents" to (ann.contents)
-                                    ))
-                                    return true
-                                }
-                                else -> {}
-                            }
-                            draggingAnnotation = ann
-                            draggingPageIndex = pageIndex
-                            dragStartBounds = RectF(ann.bounds)
-                            dragStartTouch = PointF(x, y)
+                    val list = getAnnotationsForPage(pageIndex)
+                    for (i in list.indices.reversed()) {
+                        val ann = list[i]
+                        if (!ann.bounds.contains(pdfX, pdfY)) continue
+                        if (ann.type == "text") {
+                            onTextPress(mapOf(
+                                "page" to pageIndex,
+                                "index" to i,
+                                "bounds" to mapOf(
+                                    "x" to ann.bounds.left,
+                                    "y" to ann.bounds.top,
+                                    "width" to ann.bounds.width(),
+                                    "height" to ann.bounds.height()
+                                ),
+                                "contents" to (ann.contents.ifEmpty { " " })
+                            ))
                             return true
                         }
+                        if (ann.type == "note") {
+                            onNotePress(mapOf(
+                                "page" to pageIndex,
+                                "index" to i,
+                                "bounds" to mapOf(
+                                    "x" to ann.bounds.left,
+                                    "y" to ann.bounds.top,
+                                    "width" to ann.bounds.width(),
+                                    "height" to ann.bounds.height()
+                                ),
+                                "contents" to (ann.contents.ifEmpty { " " })
+                            ))
+                            return true
+                        }
+                        draggingAnnotation = ann
+                        draggingPageIndex = pageIndex
+                        dragStartBounds = RectF(ann.bounds)
+                        dragStartTouch = PointF(pdfX, pdfY)
+                        return true
                     }
+                    return false
                 }
                 MotionEvent.ACTION_MOVE -> {
-                    if (draggingAnnotation != null && draggingPageIndex == pageIndex && dragStartTouch != null && dragStartBounds != null) {
-                        val dx = (x - dragStartTouch!!.x) / s
-                        val dy = (y - dragStartTouch!!.y) / s
-                        draggingAnnotation!!.bounds.set(
-                            dragStartBounds!!.left + dx,
-                            dragStartBounds!!.top + dy,
-                            dragStartBounds!!.right + dx,
-                            dragStartBounds!!.bottom + dy
-                        )
-                        dragStartTouch!!.set(x, y)
-                        dragStartBounds!!.set(draggingAnnotation!!.bounds)
-                        invalidate()
-                    }
+                    val ann = draggingAnnotation ?: return false
+                    val start = dragStartTouch ?: return true
+                    val startB = dragStartBounds ?: return true
+                    val dx = pdfX - start.x
+                    val dy = pdfY - start.y
+                    ann.bounds.set(
+                        startB.left + dx,
+                        startB.top + dy,
+                        startB.right + dx,
+                        startB.bottom + dy
+                    )
+                    invalidate()
+                    return true
                 }
                 MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                     if (draggingAnnotation != null) {
@@ -383,43 +367,60 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
                     draggingPageIndex = -1
                     dragStartBounds = null
                     dragStartTouch = null
+                    return false
                 }
             }
-            return draggingAnnotation != null
+            return false
         }
     }
 
     init {
         setBackgroundColor(Color.WHITE)
-        scrollView.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        scrollView.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
         scrollView.isFillViewport = true
-        container.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)
+        container.layoutParams = LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
         scrollView.addView(container)
         addView(scrollView)
         scrollView.viewTreeObserver.addOnScrollChangedListener {
             notifyPageChange()
         }
         viewTreeObserver.addOnGlobalLayoutListener {
-            if (width > 0 && pdfUrl != null && pdfRenderer == null) {
+            if (width <= 0) {
+                if (pdfUrl != null && pdfRenderer == null) {
+                    loadPdfFromUrl(pdfUrl!!)
+                } else if (pdfRenderer != null && renderPdfRetryCount < maxRenderPdfRetries) {
+                    renderPdfRetryCount++
+                    postDelayed({ renderPdf() }, 50)
+                }
+                return@addOnGlobalLayoutListener
+            }
+            renderPdfRetryCount = 0
+            if (pdfUrl != null && pdfRenderer == null) {
                 loadPdfFromUrl(pdfUrl!!)
+            } else if (pdfRenderer != null) {
+                renderPdf()
             }
         }
     }
 
-    fun setUrl(url: String) {
-        if (pdfUrl == url) return
-        pdfUrl = url
-        if (width > 0) loadPdfFromUrl(url)
+    override fun onSizeChanged(w: Int, h: Int, oldW: Int, oldH: Int) {
+        super.onSizeChanged(w, h, oldW, oldH)
+        if (w > 0 && pdfRenderer != null && pageHeights.isEmpty()) {
+            renderPdf()
+        }
+    }
+
+    fun setUrl(url: String?) {
+        val u = url?.takeIf { it.isNotBlank() } ?: return
+        if (pdfUrl == u && pdfRenderer != null) return
+        pdfUrl = u
+        loadPdfFromUrl(u)
     }
 
     fun setDisplayMode(mode: String) {
-        displayMode = when (mode) {
-            "single" -> "single"
-            "continuous" -> "continuous"
-            "twoUp" -> "twoUp"
-            "twoUpContinuous" -> "twoUpContinuous"
-            else -> "continuous"
-        }
+        if (displayMode == mode) return
+        displayMode = mode
+        pageHeights.clear()
         pdfRenderer?.let { renderPdf() }
     }
 
@@ -429,26 +430,41 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     }
 
     fun setTool(tool: String?) {
-        currentTool = when (tool?.lowercase()) {
-            "pen" -> AnnotationTool.PEN
-            "highlighter" -> AnnotationTool.HIGHLIGHTER
-            "text" -> AnnotationTool.TEXT
-            "note" -> AnnotationTool.NOTE
-            "eraser" -> AnnotationTool.ERASER
-            "line" -> AnnotationTool.LINE
-            else -> null
-        }
-        scrollView.scrollEnabled = (currentTool == null)
-    }
-
-    fun setStrokeColor(hex: String) { strokeColor = parseHexColor(hex) }
-    fun setStrokeWidth(width: Float) { strokeWidth = width }
-    fun setTextContent(text: String) { textContent = text }
-    fun setTextColor(hex: String) { textColor = parseHexColor(hex) }
-    fun setTextFontSize(size: Float) { textFontSize = size }
-    fun setTextBold(value: Boolean) { textBold = value }
-    fun setTextItalic(value: Boolean) { textItalic = value }
-    fun setNoteColor(hex: String) { noteColor = parseHexColor(hex) }
+        currentTool = tool?.let { runCatching { AnnotationTool.valueOf(it.uppercase()) }.getOrNull() }
+        // ToolAwareScrollView uses isScrollEnabledProvider { currentTool == null } — no property to set
+    }
+
+    fun setStrokeColor(hex: String) {
+        strokeColor = parseHexColor(hex)
+    }
+
+    fun setStrokeWidth(width: Float) {
+        strokeWidth = width
+    }
+
+    fun setTextContent(text: String) {
+        textContent = text
+    }
+
+    fun setTextColor(hex: String) {
+        textColor = parseHexColor(hex)
+    }
+
+    fun setTextFontSize(size: Float) {
+        textFontSize = size
+    }
+
+    fun setTextBold(value: Boolean) {
+        textBold = value
+    }
+
+    fun setTextItalic(value: Boolean) {
+        textItalic = value
+    }
+
+    fun setNoteColor(hex: String) {
+        noteColor = parseHexColor(hex)
+    }
 
     fun setInitialAnnotations(annotations: List<Map<String, Any>>) {
         if (pdfRenderer == null) {
@@ -458,13 +474,14 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         val fp = fingerprintAnnotations(annotations)
         if (appliedAnnotationsFingerprint == fp) return
         appliedAnnotationsFingerprint = fp
-        val pageCount = pdfRenderer!!.pageCount
-        pageAnnotations = MutableList(pageCount) { mutableListOf() }
+        pageAnnotations.clear()
+        while (pageAnnotations.size < totalPageCount) {
+            pageAnnotations.add(mutableListOf())
+        }
         for (data in annotations) {
             val pageIndex = (data["page"] as? Number)?.toInt() ?: continue
-            if (pageIndex < 0 || pageIndex >= pageCount) continue
             val typeStr = data["type"] as? String ?: continue
-            val b = data["bounds"] as? Map<String, Any> ?: continue
+            val b = data["bounds"] as? Map<*, *> ?: continue
             val x = (b["x"] as? Number)?.toFloat() ?: 0f
             val y = (b["y"] as? Number)?.toFloat() ?: 0f
             val w = (b["width"] as? Number)?.toFloat() ?: 0f
@@ -472,41 +489,36 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
             val bounds = RectF(x, y, x + w, y + h)
             val color = (data["color"] as? String)?.let { parseHexColor(it) } ?: Color.BLACK
             val strokeW = (data["strokeWidth"] as? Number)?.toFloat() ?: 2f
-            val contents = data["contents"] as? String ?: " "
-            val ann = Annotation(
-                type = typeStr,
-                bounds = bounds,
-                color = color,
-                strokeWidth = strokeW,
-                contents = contents,
-                fontSize = (data["fontSize"] as? Number)?.toFloat() ?: textFontSize,
-                bold = data["bold"] as? Boolean ?: false,
-                italic = data["italic"] as? Boolean ?: false
-            )
-            if (typeStr == "pen" || typeStr == "highlighter" || typeStr == "line") {
-                @Suppress("UNCHECKED_CAST")
-                val paths = data["paths"] as? List<List<Map<String, Any>>> ?: emptyList()
-                for (pathData in paths) {
-                    val points = pathData.map { pt ->
-                        PointF(
-                            (pt["x"] as? Number)?.toFloat() ?: 0f,
-                            (pt["y"] as? Number)?.toFloat() ?: 0f
-                        )
-                    }.toMutableList()
-                    if (points.isNotEmpty()) ann.paths.add(points)
+            val paths = mutableListOf<MutableList<PointF>>()
+            @Suppress("UNCHECKED_CAST")
+            (data["paths"] as? List<*>)?.forEach { pathData ->
+                val points = mutableListOf<PointF>()
+                (pathData as? List<*>)?.forEach { pt ->
+                    val m = pt as? Map<*, *> ?: return@forEach
+                    val px = (m["x"] as? Number)?.toFloat() ?: 0f
+                    val py = (m["y"] as? Number)?.toFloat() ?: 0f
+                    points.add(PointF(px, py))
                 }
+                if (points.isNotEmpty()) paths.add(points)
+            }
+            val contents = data["contents"] as? String ?: ""
+            val fontSize = (data["fontSize"] as? Number)?.toFloat() ?: 14f
+            val bold = data["bold"] as? Boolean ?: false
+            val italic = data["italic"] as? Boolean ?: false
+            val ann = Annotation(typeStr, bounds, color, strokeW, paths, contents, fontSize, bold, italic)
+            if (pageIndex in 0 until pageAnnotations.size) {
+                pageAnnotations[pageIndex].add(ann)
             }
-            pageAnnotations[pageIndex].add(ann)
         }
         overlayViews.forEach { it?.invalidate() }
+        notifyAnnotationChange()
     }
 
     fun undo() {
         val entry = undoStack.removeLastOrNull() ?: return
         redoStack.add(entry)
-        if (entry.pageIndex in pageAnnotations.indices) {
-            pageAnnotations[entry.pageIndex].remove(entry.annotation)
-        }
+        val list = pageAnnotations.getOrNull(entry.pageIndex) ?: return
+        list.remove(entry.annotation)
         overlayViews.getOrNull(entry.pageIndex)?.invalidate()
         notifyAnnotationChange()
         notifyUndoRedoStateChange()
@@ -515,153 +527,29 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     fun redo() {
         val entry = redoStack.removeLastOrNull() ?: return
         undoStack.add(entry)
-        if (entry.pageIndex in pageAnnotations.indices) {
-            pageAnnotations[entry.pageIndex].add(entry.annotation)
+        while (pageAnnotations.size <= entry.pageIndex) {
+            pageAnnotations.add(mutableListOf())
         }
+        pageAnnotations[entry.pageIndex].add(entry.annotation)
         overlayViews.getOrNull(entry.pageIndex)?.invalidate()
         notifyAnnotationChange()
         notifyUndoRedoStateChange()
     }
 
-    fun updateText(page: Int, index: Int, contents: String) {
-        if (page !in pageAnnotations.indices || index !in pageAnnotations[page].indices) return
-        val ann = pageAnnotations[page][index]
-        if (ann.type != "text") return
-        ann.contents = if (contents.isEmpty()) " " else contents
-        overlayViews.getOrNull(page)?.invalidate()
-        notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
     fun updateNote(page: Int, index: Int, contents: String) {
-        if (page !in pageAnnotations.indices || index !in pageAnnotations[page].indices) return
-        val ann = pageAnnotations[page][index]
-        if (ann.type != "note") return
-        ann.contents = if (contents.isEmpty()) " " else contents
+        val list = pageAnnotations.getOrNull(page) ?: return
+        if (index !in list.indices) return
+        list[index].contents = contents.ifEmpty { " " }
         overlayViews.getOrNull(page)?.invalidate()
         notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    private fun parseHexColor(hex: String): Int {
-        var s = hex.trim().removePrefix("#")
-        if (s.length == 6) s = "FF$s"
-        return try {
-            Color.parseColor("#$s")
-        } catch (_: Exception) {
-            Color.BLACK
-        }
-    }
-
-    private fun fingerprintAnnotations(annotations: List<Map<String, Any>>): String {
-        return annotations.mapNotNull { data ->
-            val page = data["page"] as? Int ?: return@mapNotNull null
-            val type = data["type"] as? String ?: return@mapNotNull null
-            val b = data["bounds"] as? Map<*, *> ?: return@mapNotNull null
-            val x = (b["x"] as? Number)?.toDouble() ?: 0.0
-            val y = (b["y"] as? Number)?.toDouble() ?: 0.0
-            val w = (b["width"] as? Number)?.toDouble() ?: 0.0
-            val h = (b["height"] as? Number)?.toDouble() ?: 0.0
-            "$page|$type|$x,$y,$w,$h"
-        }.sorted().joinToString("||")
     }
 
-    private fun getAnnotationsForPage(pageIndex: Int): List<Annotation> {
-        if (pageIndex !in pageAnnotations.indices) return emptyList()
-        return pageAnnotations[pageIndex]
-    }
-
-    private fun addAnnotationToPage(pageIndex: Int, ann: Annotation) {
-        while (pageAnnotations.size <= pageIndex) pageAnnotations.add(mutableListOf())
-        pageAnnotations[pageIndex].add(ann)
-        undoStack.add(UndoEntry(ann, pageIndex))
-        redoStack.clear()
-        overlayViews.getOrNull(pageIndex)?.invalidate()
+    fun updateText(page: Int, index: Int, contents: String) {
+        val list = pageAnnotations.getOrNull(page) ?: return
+        if (index !in list.indices) return
+        list[index].contents = contents.ifEmpty { " " }
+        overlayViews.getOrNull(page)?.invalidate()
         notifyAnnotationChange()
-        notifyUndoRedoStateChange()
-    }
-
-    private fun addInstantAnnotation(pageIndex: Int, pdfX: Float, pdfY: Float, tool: AnnotationTool) {
-        val isNote = (tool == AnnotationTool.NOTE)
-        val bounds = if (isNote) {
-            RectF(pdfX, pdfY, pdfX + 32, pdfY + 32)
-        } else {
-            RectF(pdfX, pdfY, pdfX + 180, pdfY + 40)
-        }
-        val ann = Annotation(
-            type = if (isNote) "note" else "text",
-            bounds = bounds,
-            color = if (isNote) noteColor else textColor,
-            contents = if (textContent.isEmpty()) " " else textContent,
-            fontSize = textFontSize,
-            bold = textBold,
-            italic = textItalic
-        )
-        addAnnotationToPage(pageIndex, ann)
-    }
-
-    private fun eraseAt(pageIndex: Int, x: Float, y: Float) {
-        if (pageIndex !in pageAnnotations.indices) return
-        val toRemove = pageAnnotations[pageIndex].filter { it.bounds.contains(x, y) }
-        for (ann in toRemove) {
-            pageAnnotations[pageIndex].remove(ann)
-            val idx = undoStack.indexOfFirst { it.annotation === ann }
-            if (idx >= 0) undoStack.removeAt(idx)
-        }
-        if (toRemove.isNotEmpty()) {
-            overlayViews.getOrNull(pageIndex)?.invalidate()
-            notifyAnnotationChange()
-            notifyUndoRedoStateChange()
-        }
-    }
-
-    private fun notifyAnnotationChange() {
-        val renderer = pdfRenderer ?: return
-        val list = mutableListOf<Map<String, Any>>()
-        for (pageIndex in 0 until renderer.pageCount) {
-            val anns = getAnnotationsForPage(pageIndex)
-            for ((idx, ann) in anns.withIndex()) {
-                val map = mutableMapOf<String, Any>(
-                    "page" to pageIndex,
-                    "bounds" to mapOf(
-                        "x" to ann.bounds.left,
-                        "y" to ann.bounds.top,
-                        "width" to ann.bounds.width(),
-                        "height" to ann.bounds.height()
-                    ),
-                    "type" to ann.type,
-                    "color" to colorToHex(ann.color),
-                    "contents" to (ann.contents)
-                )
-                if (ann.type == "pen" || ann.type == "highlighter" || ann.type == "line") {
-                    map["paths"] = ann.paths.map { path ->
-                        path.map { p -> mapOf("x" to p.x, "y" to p.y) }
-                    }
-                    map["strokeWidth"] = ann.strokeWidth
-                }
-                if (ann.type == "text") {
-                    map["fontSize"] = ann.fontSize
-                    map["bold"] = ann.bold
-                    map["italic"] = ann.italic
-                }
-                list.add(map)
-            }
-        }
-        onAnnotationChange(mapOf("annotations" to list))
-    }
-
-    private fun colorToHex(color: Int): String {
-        val r = Color.red(color)
-        val g = Color.green(color)
-        val b = Color.blue(color)
-        return String.format("#%02x%02x%02x", r, g, b)
-    }
-
-    private fun notifyUndoRedoStateChange() {
-        onUndoRedoStateChange(mapOf(
-            "canUndo" to undoStack.isNotEmpty(),
-            "canRedo" to redoStack.isNotEmpty()
-        ))
     }
 
     private fun scrollToPage(pageIndex: Int) {
@@ -677,23 +565,24 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         scope.launch {
             try {
                 resetRenderer()
+                val decodedUrl = runCatching { java.net.URLDecoder.decode(url, "UTF-8") }.getOrElse { url }
                 val file = withContext(Dispatchers.IO) {
                     when {
-                        url.startsWith("file://") -> File(url.removePrefix("file://"))
-                        url.startsWith("/") -> File(url)
-                        else -> downloadFile(url)
+                        decodedUrl.startsWith("file://") -> File(decodedUrl.removePrefix("file://"))
+                        decodedUrl.startsWith("/") -> File(decodedUrl)
+                        else -> downloadFile(decodedUrl)
                     }
                 }
                 if (file.exists()) {
                     fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
                     pdfRenderer = PdfRenderer(fileDescriptor!!)
                     totalPageCount = pdfRenderer!!.pageCount
-                    undoStack.clear()
-                    redoStack.clear()
-                    appliedAnnotationsFingerprint = null
-                    notifyUndoRedoStateChange()
                     renderPdf()
-                    pendingAnnotations?.let { setInitialAnnotations(it); pendingAnnotations = null }
+                    post { renderPdf() }
+                    pendingAnnotations?.let { ann ->
+                        pendingAnnotations = null
+                        setInitialAnnotations(ann)
+                    }
                 }
             } catch (e: Exception) {
                 android.util.Log.e("ExpoPdfReader", "Error loading PDF", e)
@@ -707,34 +596,70 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         fileDescriptor?.close()
         fileDescriptor = null
         pageHeights.clear()
+        pageWidthsPdf.clear()
+        pageHeightsPdf.clear()
         pageViews.clear()
         overlayViews.clear()
-        pageAnnotations.clear()
         container.removeAllViews()
+        pageAnnotations.clear()
+        undoStack.clear()
+        redoStack.clear()
+        appliedAnnotationsFingerprint = null
+        pendingAnnotations = null
+        currentPath = null
+        currentPathPoints.clear()
+        activePageIndex = -1
+        startPoint = null
+        draggingAnnotation = null
+        draggingPageIndex = -1
+        dragStartBounds = null
+        dragStartTouch = null
     }
 
     private fun renderPdf() {
         val renderer = pdfRenderer ?: return
-        if (width <= 0) return
-        renderGeneration++
-        computePageHeights(renderer)
-        ensurePlaceholders(renderer)
-        updateVisiblePages()
-        setInitialPage(initialPage.coerceIn(0, (renderer.pageCount - 1).coerceAtLeast(0)))
-    }
-
-    private fun computePageHeights(renderer: PdfRenderer) {
-        pageHeights.clear()
-        pageWidthsPdf.clear()
-        pageHeightsPdf.clear()
-        val w = width.coerceAtLeast(1)
-        for (i in 0 until renderer.pageCount) {
-            val page = renderer.openPage(i)
-            pageWidthsPdf.add(page.width.toFloat())
-            pageHeightsPdf.add(page.height.toFloat())
-            val h = (w.toFloat() * page.height / page.width).toInt()
-            pageHeights.add(h)
-            page.close()
+        if (width <= 0) {
+            if (renderPdfRetryCount < maxRenderPdfRetries) {
+                renderPdfRetryCount++
+                post { renderPdf() }
+            }
+            return
+        }
+        renderPdfRetryCount = 0
+        if (pageHeights.isNotEmpty()) {
+            updateVisiblePages()
+            return
+        }
+        scope.launch {
+            val w = width.coerceAtLeast(1)
+            val result = withContext(Dispatchers.Default) {
+                (0 until renderer.pageCount).map { i ->
+                    val page = renderer.openPage(i)
+                    try {
+                        Triple(
+                            i,
+                            (w.toFloat() * page.height / page.width).toInt(),
+                            Pair(page.width.toFloat(), page.height.toFloat())
+                        )
+                    } finally {
+                        page.close()
+                    }
+                }
+            }
+            if (!isActive) return@launch
+            withContext(Dispatchers.Main) {
+                pageHeights.clear()
+                pageWidthsPdf.clear()
+                pageHeightsPdf.clear()
+                for ((_, h, pdfSize) in result) {
+                    pageHeights.add(h)
+                    pageWidthsPdf.add(pdfSize.first)
+                    pageHeightsPdf.add(pdfSize.second)
+                }
+                ensurePlaceholders(renderer)
+                scrollToPage(initialPage.coerceIn(0, (renderer.pageCount - 1).coerceAtLeast(0)))
+                updateVisiblePages()
+            }
         }
     }
 
@@ -743,7 +668,9 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         val pageCount = renderer.pageCount
         pageViews = MutableList(pageCount) { null }
         overlayViews = MutableList(pageCount) { null }
-        while (pageAnnotations.size < pageCount) pageAnnotations.add(mutableListOf())
+        while (pageAnnotations.size < pageCount) {
+            pageAnnotations.add(mutableListOf())
+        }
         for (i in 0 until pageCount) {
             val frame = FrameLayout(context).apply {
                 layoutParams = LinearLayout.LayoutParams(
@@ -764,25 +691,45 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         }
     }
 
+    private fun currentPageFromScroll(): Int {
+        if (pageHeights.isEmpty()) return 0
+        val scrollY = scrollView.scrollY
+        var offset = 0
+        for (i in pageHeights.indices) {
+            if (scrollY < offset + pageHeights[i] / 2) return i
+            offset += pageHeights[i] + 16
+        }
+        return (pageHeights.size - 1).coerceAtLeast(0)
+    }
+
     private fun updateVisiblePages() {
         val renderer = pdfRenderer ?: return
-        val scrollY = scrollView.scrollY
-        val viewportHeight = height
-        var currentOffset = 0
-        for (i in 0 until renderer.pageCount) {
-            val pageH = pageHeights[i]
-            if (currentOffset + pageH > scrollY - viewportHeight && currentOffset < scrollY + viewportHeight * 2) {
-                renderPageToView(i)
-            }
-            currentOffset += pageH + 16
+        val currentPage = currentPageFromScroll()
+        val from = (currentPage - renderWindowBefore).coerceAtLeast(0)
+        val to = (currentPage + renderWindowAfter).coerceAtMost(renderer.pageCount - 1)
+
+        for (i in pageViews.indices) {
+            if (i in from..to) continue
+            val iv = pageViews.getOrNull(i) ?: continue
+            val frame = container.getChildAt(i) as? FrameLayout ?: continue
+            val bmp = (iv.drawable as? BitmapDrawable)?.bitmap
+            iv.setImageBitmap(null)
+            bmp?.recycle()
+            frame.removeView(iv)
+            pageViews[i] = null
         }
+
+        val order = (from..to).sortedBy { kotlin.math.abs(it - currentPage) }
+        for (i in order) {
+            renderPageToView(i)
+        }
+        container.post { container.invalidate() }
     }
 
     private fun renderPageToView(pageIndex: Int) {
         val renderer = pdfRenderer ?: return
-        if (pageIndex >= container.childCount) return
         val frame = container.getChildAt(pageIndex) as? FrameLayout ?: return
-        if (frame.childCount > 1) return // already has image + overlay
+        // Frame always has overlay; only skip if we already have an ImageView for this page
         if (pageViews.getOrNull(pageIndex) != null) return
         val page = renderer.openPage(pageIndex)
         val w = width.coerceAtLeast(1)
@@ -798,11 +745,11 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
                 FrameLayout.LayoutParams.MATCH_PARENT
             )
         }
-        val overlay = overlayViews[pageIndex]
         frame.addView(imageView, 0)
         pageViews[pageIndex] = imageView
-        overlay?.bringToFront()
-        overlay?.invalidate()
+        overlayViews.getOrNull(pageIndex)?.bringToFront()
+        frame.requestLayout()
+        frame.invalidate()
     }
 
     private fun notifyPageChange() {
@@ -828,25 +775,161 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         updateVisiblePages()
     }
 
-    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-        if (currentTool != null) {
-            val frame = findPageFrameAt(ev.rawX, ev.rawY)
-            if (frame != null) return false
+    private fun getAnnotationsForPage(pageIndex: Int): List<Annotation> {
+        return pageAnnotations.getOrNull(pageIndex).orEmpty()
+    }
+
+    private fun addAnnotationToPage(pageIndex: Int, ann: Annotation) {
+        while (pageAnnotations.size <= pageIndex) {
+            pageAnnotations.add(mutableListOf())
+        }
+        pageAnnotations[pageIndex].add(ann)
+        overlayViews.getOrNull(pageIndex)?.invalidate()
+    }
+
+    private fun addInstantAnnotation(pageIndex: Int, pdfX: Float, pdfY: Float, tool: AnnotationTool) {
+        val isNote = (tool == AnnotationTool.NOTE)
+        val rect = if (isNote) {
+            RectF(pdfX, pdfY, pdfX + 32, pdfY + 32)
+        } else {
+            RectF(pdfX, pdfY, pdfX + 180, pdfY + 40)
+        }
+        val typeStr = if (isNote) "note" else "text"
+        val contents = if (textContent.isEmpty()) " " else textContent
+        val ann = Annotation(
+            type = typeStr,
+            bounds = rect,
+            color = if (isNote) noteColor else textColor,
+            strokeWidth = 0f,
+            paths = mutableListOf(),
+            contents = contents,
+            fontSize = textFontSize,
+            bold = textBold,
+            italic = textItalic
+        )
+        addAnnotationToPage(pageIndex, ann)
+        undoStack.add(UndoEntry(ann, pageIndex))
+        redoStack.clear()
+        notifyAnnotationChange()
+        notifyUndoRedoStateChange()
+    }
+
+    private fun eraseAt(pageIndex: Int, pdfX: Float, pdfY: Float) {
+        val list = pageAnnotations.getOrNull(pageIndex) ?: return
+        var erased = false
+        val toRemove = list.filter { it.bounds.contains(pdfX, pdfY) }
+        for (ann in toRemove) {
+            list.remove(ann)
+            undoStack.removeAll { it.annotation == ann }
+            erased = true
+        }
+        if (erased) {
+            overlayViews.getOrNull(pageIndex)?.invalidate()
+            notifyAnnotationChange()
+            notifyUndoRedoStateChange()
+        }
+    }
+
+    private fun commitStroke(tool: AnnotationTool) {
+        if (currentPathPoints.size < 2) return
+        val minX = currentPathPoints.minOf { it.x } - strokeWidth
+        val minY = currentPathPoints.minOf { it.y } - strokeWidth
+        val maxX = currentPathPoints.maxOf { it.x } + strokeWidth
+        val maxY = currentPathPoints.maxOf { it.y } + strokeWidth
+        val bounds = RectF(minX, minY, maxX, maxY)
+        val paths = mutableListOf<MutableList<PointF>>()
+        val points = currentPathPoints.map { PointF(it.x, it.y) }.toMutableList()
+        paths.add(points)
+        val typeStr = when (tool) {
+            AnnotationTool.PEN -> "pen"
+            AnnotationTool.HIGHLIGHTER -> "highlighter"
+            AnnotationTool.LINE -> "line"
+            else -> "pen"
+        }
+        val color = if (tool == AnnotationTool.HIGHLIGHTER) {
+            Color.argb(102, Color.red(strokeColor), Color.green(strokeColor), Color.blue(strokeColor))
+        } else {
+            strokeColor
+        }
+        val ann = Annotation(typeStr, bounds, color, strokeWidth, paths, "", 0f, false, false)
+        addAnnotationToPage(activePageIndex, ann)
+        undoStack.add(UndoEntry(ann, activePageIndex))
+        redoStack.clear()
+        notifyAnnotationChange()
+        notifyUndoRedoStateChange()
+    }
+
+    private fun notifyAnnotationChange() {
+        val list = mutableListOf<Map<String, Any>>()
+        for (pageIndex in pageAnnotations.indices) {
+            for (ann in getAnnotationsForPage(pageIndex)) {
+                list.add(mapOf(
+                    "page" to pageIndex,
+                    "bounds" to mapOf(
+                        "x" to ann.bounds.left,
+                        "y" to ann.bounds.top,
+                        "width" to ann.bounds.width(),
+                        "height" to ann.bounds.height()
+                    ),
+                    "type" to ann.type,
+                    "color" to colorToHex(ann.color),
+                    "contents" to ann.contents,
+                    "paths" to ann.paths.map { path ->
+                        path.map { p -> mapOf("x" to p.x, "y" to p.y) }
+                    },
+                    "strokeWidth" to ann.strokeWidth,
+                    "fontSize" to ann.fontSize,
+                    "bold" to ann.bold,
+                    "italic" to ann.italic
+                ))
+            }
         }
-        return false
+        onAnnotationChange(mapOf("annotations" to list))
     }
 
-    private fun findPageFrameAt(rawX: Float, rawY: Float): View? {
-        val loc = IntArray(2)
-        for (i in 0 until container.childCount) {
-            val child = container.getChildAt(i)
-            child.getLocationOnScreen(loc)
-            if (rawX >= loc[0] && rawX < loc[0] + child.width &&
-                rawY >= loc[1] && rawY < loc[1] + child.height) {
-                return child
+    private fun notifyUndoRedoStateChange() {
+        onUndoRedoStateChange(mapOf(
+            "canUndo" to undoStack.isNotEmpty(),
+            "canRedo" to redoStack.isNotEmpty()
+        ))
+    }
+
+    private fun parseHexColor(hex: String): Int {
+        var s = hex.trim().uppercase()
+        if (s.startsWith("#")) s = s.removePrefix("#")
+        val v = s.toLongOrNull(16) ?: 0L
+        val r = ((v shr 16) and 0xFF).toInt()
+        val g = ((v shr 8) and 0xFF).toInt()
+        val b = (v and 0xFF).toInt()
+        return Color.rgb(r, g, b)
+    }
+
+    private fun fingerprintAnnotations(annotations: List<Map<String, Any>>): String {
+        val items = annotations.mapNotNull { data ->
+            val pageIndex = (data["page"] as? Number)?.toInt() ?: return@mapNotNull null
+            val typeStr = data["type"] as? String ?: return@mapNotNull null
+            val b = data["bounds"] as? Map<*, *> ?: return@mapNotNull null
+            val x = (b["x"] as? Number)?.toDouble() ?: 0.0
+            val y = (b["y"] as? Number)?.toDouble() ?: 0.0
+            val w = (b["width"] as? Number)?.toDouble() ?: 0.0
+            val h = (b["height"] as? Number)?.toDouble() ?: 0.0
+            val color = data["color"] as? String ?: ""
+            val strokeW = data["strokeWidth"] as? Double ?: 0.0
+            val contents = data["contents"] as? String ?: ""
+            var ptsCount = 0
+            (data["paths"] as? List<*>)?.forEach { pathData ->
+                (pathData as? List<*>)?.forEach { ptsCount++ }
             }
+            "$pageIndex|$typeStr|$x,$y,$w,$h|$color|$strokeW|$contents|pts:$ptsCount"
         }
-        return null
+        return items.sorted().joinToString("||")
+    }
+
+    private fun colorToHex(color: Int): String {
+        val r = Color.red(color)
+        val g = Color.green(color)
+        val b = Color.blue(color)
+        return String.format("#%02x%02x%02x", r, g, b)
     }
 
     private suspend fun downloadFile(urlStr: String): File = withContext(Dispatchers.IO) {