@june24/expo-pdf-reader 0.1.24 → 0.1.26

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

@@ -91,13 +91,15 @@ class ExpoPdfReaderView(
         private set
 
     // ── Lazy / chunked rendering ──────────────────────────────────────────────
-    private var renderedUpTo = -1          // last rendered page index
+    private var renderedUpTo = -1          // last rendered page index (absolute)
+    private var windowStart = 0            // pageEntries[0]-н absolute page index
     private var chunkLoading = false       // chunk дуусах хүртэл дахин trigger хийхгүй
     private var currentViewWidth = 0       // chunk load-д дахин хэрэглэнэ
     private var loadingFooter: View? = null
 
     companion object {
-        private const val PAGE_CHUNK = 10  // нэг удаа render хийх хуудасны тоо
+        private const val PAGE_CHUNK = 10           // нэг удаа render хийх хуудасны тоо
+        private const val MAX_RENDERED = PAGE_CHUNK * 2  // санах ойд байлгах дээд хязгаар (20 хуудас)
     }
 
     // ── Annotation state ─────────────────────────────────────────────────────
@@ -117,7 +119,8 @@ class ExpoPdfReaderView(
     private var appliedFingerprint: String? = null
 
     // ── Page view entries (continuous/twoUp modes) ───────────────────────────
-    data class PageEntry(val canvasView: AnnotationCanvasView)
+    // frame: container-аас устгахад шууд reference, bmpHeight: layout болохоос өмнө scroll тооцооны тулд
+    data class PageEntry(val frame: FrameLayout, val canvasView: AnnotationCanvasView, val bmpHeight: Int)
     val pageEntries = mutableListOf<PageEntry>()
 
     // ── Single-page pager (single mode) ──────────────────────────────────────
@@ -160,10 +163,10 @@ class ExpoPdfReaderView(
             maybeTriggerChunkLoad(scrollY)
         }
 
-        // Single-page pager: RecyclerView + PagerSnapHelper (horizontal)
-        pager = RecyclerView(context).apply {
+        // Single-page pager: ZoomRecyclerView + PagerSnapHelper (vertical)
+        pager = ZoomRecyclerView(context).apply {
             layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-            layoutManager = LinearLayoutManager(context, LinearLayoutManager.HORIZONTAL, false)
+            layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
             PagerSnapHelper().attachToRecyclerView(this)
             setBackgroundColor(Color.parseColor("#E8E8E8"))
             visibility = View.GONE
@@ -175,6 +178,8 @@ class ExpoPdfReaderView(
                             .takeIf { it >= 0 } ?: return
                         if (pos != currentPageIndex) {
                             currentPageIndex = pos
+                            // Хуудас солигдоход zoom-г reset хийнэ
+                            (pager as? ZoomRecyclerView)?.resetZoom()
                             onPageChange(mapOf("currentPage" to pos, "totalPage" to totalPages))
                         }
                     }
@@ -248,7 +253,18 @@ class ExpoPdfReaderView(
     fun setInitialPage(page: Int) {
         if (page < 0 || page >= totalPages) return
         currentPageIndex = page
-        post { scrollToPage(page, smooth = false) }
+        if (displayMode == "single") {
+            post { scrollToPage(page, smooth = false) }
+            return
+        }
+        val windowEnd = windowStart + pageEntries.size - 1
+        if (page in windowStart..windowEnd) {
+            // Хуудас render хийгдсэн window дотор байна → зүгээр scroll хийнэ
+            post { scrollToPage(page, smooth = false) }
+        } else {
+            // Хуудас render хийгдээгүй → window-г тухайн хуудас руу шилжүүлнэ
+            jumpToPage(page)
+        }
     }
 
     fun setMinZoom(v: Double) { minZoom = v.toFloat() }
@@ -405,7 +421,8 @@ class ExpoPdfReaderView(
         if (displayMode == "single") {
             singlePageCanvases[pageIndex]?.invalidate()
         } else {
-            pageEntries.getOrNull(pageIndex)?.canvasView?.invalidate()
+            // continuous mode: pageEntries[0] = page windowStart → relative index
+            pageEntries.getOrNull(pageIndex - windowStart)?.canvasView?.invalidate()
         }
     }
 
@@ -466,17 +483,86 @@ class ExpoPdfReaderView(
     // Scroll / page detection
     // ─────────────────────────────────────────────────────────────────────────
 
+    /** twoupcontinuous: нэг мөр = хос entry (хуудас дараалсан), эсвэл эцсийн ганц entry. */
+    private fun twoupStrideAt(entryIdx: Int): Int {
+        if (displayMode != "twoupcontinuous") return 1
+        if (entryIdx >= pageEntries.size) return 0
+        if (entryIdx + 1 < pageEntries.size) {
+            val a = pageEntries[entryIdx].canvasView.pageIndex
+            val b = pageEntries[entryIdx + 1].canvasView.pageIndex
+            if (b == a + 1) return 2
+        }
+        return 1
+    }
+
+    /** scrollView доторх pageIndex хуудасны мөрийн дээд ирмэгийн Y (continuous / twoupcontinuous). */
+    private fun scrollYForScrollModePage(pageIndex: Int): Int {
+        if (pageEntries.isEmpty()) return 0
+        val lastAbsPage = windowStart + pageEntries.size - 1
+        val clamped = pageIndex.coerceIn(windowStart, lastAbsPage.coerceAtLeast(windowStart))
+        if (displayMode != "twoupcontinuous") {
+            val rel = (clamped - windowStart).coerceIn(0, maxOf(0, pageEntries.size - 1))
+            var y = 0
+            for (i in 0 until rel) {
+                y += (pageEntries[i].bmpHeight.takeIf { it > 0 } ?: 0) + 12
+            }
+            return y
+        }
+        var y = 0
+        var idx = 0
+        while (idx < pageEntries.size) {
+            val stride = twoupStrideAt(idx)
+            val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
+            val p0 = pageEntries[idx].canvasView.pageIndex
+            val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
+            if (clamped in p0..p1) return y
+            y += rowH + 12
+            idx += stride
+        }
+        return y
+    }
+
     private fun detectCurrentPage(scrollY: Int) {
         if (pageEntries.isEmpty()) return
-        val centerY = scrollY + height / 2
+        val viewH = scrollView.height.takeIf { it > 0 } ?: height
+        val centerY = scrollY + viewH / 2
+        if (displayMode == "twoupcontinuous") {
+            var accY = 0
+            var idx = 0
+            while (idx < pageEntries.size) {
+                val stride = twoupStrideAt(idx)
+                val rowH = pageEntries[idx].bmpHeight.takeIf { it > 0 } ?: 0
+                val nextY = accY + rowH + 12
+                val p0 = pageEntries[idx].canvasView.pageIndex
+                val p1 = if (stride == 2) pageEntries[idx + 1].canvasView.pageIndex else p0
+                if (centerY <= nextY || idx + stride >= pageEntries.size) {
+                    val vx = scrollView.width.takeIf { it > 0 } ?: width
+                    val absPage = if (stride == 2 && p1 > p0 && vx > 0) {
+                        val midPix = vx / 2
+                        val centerX = scrollView.scrollX + midPix
+                        if (centerX < midPix) p0 else p1
+                    } else p0
+                    if (currentPageIndex != absPage) {
+                        currentPageIndex = absPage
+                        onPageChange(mapOf("currentPage" to absPage, "totalPage" to totalPages))
+                    }
+                    break
+                }
+                accY = nextY
+                idx += stride
+            }
+            return
+        }
+        // continuous — entry бүр нэг босоо мөр
         var accY = 0
         for (i in pageEntries.indices) {
-            val h = pageEntries[i].canvasView.height.takeIf { it > 0 } ?: continue
+            val h = pageEntries[i].bmpHeight.takeIf { it > 0 } ?: continue
             accY += h + 12
             if (centerY <= accY || i == pageEntries.size - 1) {
-                if (currentPageIndex != i) {
-                    currentPageIndex = i
-                    onPageChange(mapOf("currentPage" to i, "totalPage" to totalPages))
+                val absolutePage = windowStart + i
+                if (currentPageIndex != absolutePage) {
+                    currentPageIndex = absolutePage
+                    onPageChange(mapOf("currentPage" to absolutePage, "totalPage" to totalPages))
                 }
                 break
             }
@@ -492,10 +578,7 @@ class ExpoPdfReaderView(
             return
         }
         if (pageEntries.isEmpty()) return
-        var y = 0
-        for (i in 0 until pageIndex.coerceAtMost(pageEntries.size - 1)) {
-            y += (pageEntries[i].canvasView.height.takeIf { it > 0 } ?: 0) + 12
-        }
+        val y = scrollYForScrollModePage(pageIndex)
         if (smooth) scrollView.smoothScrollTo(0, y) else scrollView.scrollTo(0, y)
         currentPageIndex = pageIndex
         onPageChange(mapOf("currentPage" to pageIndex, "totalPage" to totalPages))
@@ -517,8 +600,9 @@ class ExpoPdfReaderView(
                     renderer = PdfRenderer(fileDescriptor!!)
                     val r = renderer!!
                     totalPages = r.pageCount
-                    pagePdfW = IntArray(totalPages) { i -> r.openPage(i).use { it.width } }
-                    pagePdfH = IntArray(totalPages) { i -> r.openPage(i).use { it.height } }
+                    // Хэмжээг энд бүгдийг нь уншихгүй — renderPageBitmap нээх бүрт бөглөнө (анхны ачаалал хурдан).
+                    pagePdfW = IntArray(totalPages) { 0 }
+                    pagePdfH = IntArray(totalPages) { 0 }
                 }
                 // annotationMap is intentionally NOT cleared here.
                 // setAnnotations() may have already populated it before startLoad() runs
@@ -559,6 +643,7 @@ class ExpoPdfReaderView(
         // Chunk state reset
         currentViewWidth = viewWidth
         renderedUpTo = -1
+        windowStart = 0
         chunkLoading = false
 
         withContext(Dispatchers.Main) {
@@ -570,7 +655,12 @@ class ExpoPdfReaderView(
         when (displayMode) {
             "single" -> renderSingleMode()
             "twoup" -> renderAllPages(pdf, pageCount, viewWidth)
-            else -> renderFirstChunk(pdf, pageCount, viewWidth)  // continuous / twoUpContinuous
+            else -> renderScrollModeAround(
+                pdf,
+                pageCount,
+                viewWidth,
+                currentPageIndex.coerceIn(0, pageCount - 1)
+            )
         }
 
         // onReady: Main thread дээр шууд дуудна
@@ -623,34 +713,53 @@ class ExpoPdfReaderView(
         withContext(Dispatchers.Main) { renderedUpTo = pageCount - 1 }
     }
 
-    // continuous / twoUpContinuous — эхний PAGE_CHUNK хуудсыг render хийнэ
-    private suspend fun renderFirstChunk(pdf: PdfRenderer, pageCount: Int, viewWidth: Int) {
+    /**
+     * continuous / twoupcontinuous — [anchorPage]-ийн эргэн тойронд MAX_RENDERED хүртэлх цонх.
+     * Горим солиход одоогийн хуудас хадгалагдана.
+     */
+    private suspend fun renderScrollModeAround(
+        pdf: PdfRenderer,
+        pageCount: Int,
+        viewWidth: Int,
+        anchorPage: Int
+    ) {
         withContext(Dispatchers.Main) {
             scrollView.visibility = View.VISIBLE
             pager.visibility = View.GONE
         }
-        val end = minOf(PAGE_CHUNK, pageCount)
+        val target = anchorPage.coerceIn(0, pageCount - 1)
+        val newStart = maxOf(0, target - PAGE_CHUNK / 2)
+        val newEnd = minOf(pageCount, newStart + MAX_RENDERED)
+        withContext(Dispatchers.Main) {
+            windowStart = newStart
+            renderedUpTo = newStart - 1
+        }
         if (displayMode == "twoupcontinuous") {
-            renderTwoUpRange(pdf, pageCount, viewWidth, 0, end)
-            // Хос тул renderedUpTo-г тэгш болгоно
+            renderTwoUpRange(pdf, pageCount, viewWidth, newStart, newEnd)
             withContext(Dispatchers.Main) {
-                renderedUpTo = if (end % 2 == 0) end - 1 else end - 2
+                val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
+                renderedUpTo = rawUpTo.coerceIn(0, pageCount - 1)
                 if (renderedUpTo < pageCount - 1) showLoadingFooter()
                 forceLayoutScrollView()
+                post { scrollToPage(target, smooth = false) }
             }
         } else {
-            for (i in 0 until end) {
+            for (i in newStart until newEnd) {
                 val bmp = renderPageBitmap(pdf, i, viewWidth)
                 val idx = i
                 withContext(Dispatchers.Main) {
-                    addPageRow(bmp, idx, pagePdfW.getOrElse(idx) { 1 }.toFloat(),
-                        pagePdfH.getOrElse(idx) { 1 }.toFloat())
+                    addPageRow(
+                        bmp, idx,
+                        pagePdfW.getOrElse(idx) { 1 }.toFloat(),
+                        pagePdfH.getOrElse(idx) { 1 }.toFloat()
+                    )
                 }
             }
             withContext(Dispatchers.Main) {
-                renderedUpTo = end - 1
-                if (end < pageCount) showLoadingFooter()
-                forceLayoutScrollView()   // pages-г шууд харагдуулна
+                renderedUpTo = (newEnd - 1).coerceIn(0, pageCount - 1)
+                if (newEnd < pageCount) showLoadingFooter()
+                forceLayoutScrollView()
+                post { scrollToPage(target, smooth = false) }
             }
         }
     }
@@ -692,18 +801,32 @@ class ExpoPdfReaderView(
 
     private fun maybeTriggerChunkLoad(scrollY: Int) {
         if (chunkLoading) return
-        if (renderedUpTo >= totalPages - 1) return
         if (displayMode !in listOf("continuous", "twoupcontinuous")) return
 
-        // Render хийгдсэн хэсгийн 2 дэлгэцийн өмнөөс дараагийн chunk-г эхлүүлнэ
         val visibleBottom = scrollY + scrollView.height
-        val trigger = container.height - scrollView.height * 2
-        if (visibleBottom >= trigger) {
+
+        // Доош scroll: дараагийн chunk ачаална
+        if (renderedUpTo < totalPages - 1) {
+            val forwardTrigger = container.height - scrollView.height * 2
+            if (visibleBottom >= forwardTrigger) {
+                chunkLoading = true
+                scope.launch {
+                    try { loadNextChunk() }
+                    catch (e: CancellationException) { throw e }
+                    catch (e: Exception) { Log.e("ExpoPdfReader", "Chunk load error", e) }
+                    finally { chunkLoading = false }
+                }
+                return
+            }
+        }
+
+        // Дээш scroll: өмнөх chunk (continuous = нэг багана; twoupcontinuous = хос мөр prepend).
+        if (windowStart > 0 && scrollY <= scrollView.height * 2) {
             chunkLoading = true
             scope.launch {
-                try { loadNextChunk() }
+                try { loadPrevChunk() }
                 catch (e: CancellationException) { throw e }
-                catch (e: Exception) { Log.e("ExpoPdfReader", "Chunk load error", e) }
+                catch (e: Exception) { Log.e("ExpoPdfReader", "Prev chunk load error", e) }
                 finally { chunkLoading = false }
             }
         }
@@ -736,12 +859,271 @@ class ExpoPdfReaderView(
             }
             withContext(Dispatchers.Main) {
                 renderedUpTo = end - 1
+                // Sliding window: MAX_RENDERED-с илүү болвол дээд хэсгийг устга
+                val excess = pageEntries.size - MAX_RENDERED
+                if (excess > 0) {
+                    val removed = pruneTopPages(excess)
+                    scrollView.scrollBy(0, -removed)
+                }
                 if (end < totalPages) showLoadingFooter()
                 forceLayoutScrollView()
             }
         }
     }
 
+    /**
+     * Дээд хэсгийн [count] хуудсыг устгаж, bitmap санах ойг чөлөөлнэ.
+     * @return устгагдсан хуудсуудын нийт өндөр (px) — scroll тохируулахад ашиглана
+     */
+    private fun pruneTopPages(count: Int): Int {
+        var removedHeight = 0
+        repeat(count) {
+            val entry = pageEntries.removeFirstOrNull() ?: return@repeat
+            removedHeight += entry.bmpHeight + 12  // +12 нь margin (дээш 6 + доош 6)
+            // Bitmap-г чөлөөлнэ
+            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(entry.frame)
+        }
+        windowStart += count
+        return removedHeight
+    }
+
+    /**
+     * Өмнөх [PAGE_CHUNK] хуудсыг дээр нэмж, доод хэсгийг цэвэрлэнэ.
+     */
+    private suspend fun loadPrevChunk() {
+        val pdf = renderer ?: return
+        if (displayMode == "twoupcontinuous") {
+            loadPrevChunkTwoup(pdf)
+            return
+        }
+        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
+        val prevEnd = windowStart
+        if (prevStart >= prevEnd) return
+        val viewWidth = currentViewWidth
+
+        data class PageBmp(val bmp: Bitmap, val idx: Int, val pdfW: Float, val pdfH: Float)
+        val pages = mutableListOf<PageBmp>()
+        for (i in prevStart until prevEnd) {
+            val bmp = renderPageBitmap(pdf, i, viewWidth)
+            pages.add(PageBmp(bmp, i,
+                pagePdfW.getOrElse(i) { 1 }.toFloat(),
+                pagePdfH.getOrElse(i) { 1 }.toFloat()))
+        }
+
+        withContext(Dispatchers.Main) {
+            var insertedHeight = 0
+            // Reverse order-оор insert хийж эцэст нь зөв дараалал гарна
+            // (бүгд index 0-д insert хийгддэг тул)
+            for (page in pages.reversed()) {
+                prependPageFrame(page.bmp, page.idx, page.pdfW, page.pdfH)
+                insertedHeight += page.bmp.height + 12
+            }
+            windowStart = prevStart
+            renderedUpTo = maxOf(renderedUpTo, windowStart + pageEntries.size - 1)
+
+            // Доод хэсгийг цэвэрлэнэ
+            val excess = pageEntries.size - MAX_RENDERED
+            if (excess > 0) pruneBottomPages(excess)
+
+            // Дээр нэмсэн өндрийг scroll-д нэмж харагдах хэсгийг хэвээр үлдээнэ
+            scrollView.scrollBy(0, insertedHeight)
+            forceLayoutScrollView()
+        }
+    }
+
+    /** twoupcontinuous: өмнөх chunk-ийг хос мөрөөр дээр нэмнэ. */
+    private suspend fun loadPrevChunkTwoup(pdf: PdfRenderer) {
+        val prevStart = maxOf(0, windowStart - PAGE_CHUNK)
+        val prevEnd = windowStart
+        if (prevStart >= prevEnd) return
+        val viewWidth = currentViewWidth
+        val halfW = viewWidth / 2
+
+        data class RowBmps(val leftIdx: Int, val leftBmp: Bitmap, val rightBmp: Bitmap?)
+        val rows = mutableListOf<RowBmps>()
+        var i = prevStart
+        while (i < prevEnd) {
+            val leftBmp = renderPageBitmap(pdf, i, halfW)
+            val rightBmp = if (i + 1 < minOf(prevEnd, totalPages))
+                renderPageBitmap(pdf, i + 1, halfW) else null
+            rows.add(RowBmps(i, leftBmp, rightBmp))
+            i += 2
+        }
+
+        withContext(Dispatchers.Main) {
+            var insertedHeight = 0
+            for (rb in rows.asReversed()) {
+                prependTwoupRowToContainer(
+                    rb.leftBmp, rb.leftIdx,
+                    rb.rightBmp,
+                    if (rb.rightBmp != null) rb.leftIdx + 1 else null,
+                    viewWidth
+                )
+                insertedHeight += rb.leftBmp.height + 12
+            }
+            windowStart = prevStart
+            renderedUpTo = windowStart + pageEntries.size - 1
+
+            while (pageEntries.size > MAX_RENDERED) {
+                pruneBottomTwoupOneRow()
+            }
+
+            scrollView.scrollBy(0, insertedHeight)
+            forceLayoutScrollView()
+        }
+    }
+
+    /** twoup мөрийг container + pageEntries-ийн эхэнд оруулна (дээд chunk). */
+    private fun prependTwoupRowToContainer(
+        leftBmp: Bitmap, li: Int,
+        rightBmp: Bitmap?, ri: Int?,
+        viewWidth: Int
+    ) {
+        val rowH = leftBmp.height
+        val row = LinearLayout(context).apply {
+            orientation = LinearLayout.HORIZONTAL
+            layoutParams = LinearLayout.LayoutParams(viewWidth, rowH)
+                .apply { setMargins(0, 6, 0, 6) }
+        }
+        val (leftFrame, leftEntry) = buildPageFrameDetached(
+            leftBmp, li,
+            pagePdfW.getOrElse(li) { 1 }.toFloat(),
+            pagePdfH.getOrElse(li) { 1 }.toFloat(),
+            1f
+        )
+        row.addView(leftFrame)
+        if (rightBmp != null && ri != null) {
+            val (rightFrame, rightEntry) = buildPageFrameDetached(
+                rightBmp, ri,
+                pagePdfW.getOrElse(ri) { 1 }.toFloat(),
+                pagePdfH.getOrElse(ri) { 1 }.toFloat(),
+                1f
+            )
+            row.addView(rightFrame)
+            pageEntries.add(0, rightEntry)
+            pageEntries.add(0, leftEntry)
+        } else {
+            row.addView(View(context).apply {
+                layoutParams = LinearLayout.LayoutParams(0, rowH, 1f)
+            })
+            pageEntries.add(0, leftEntry)
+        }
+        container.addView(row, 0)
+    }
+
+    /** twoupcontinuous: доод талын нэг мөрийг (эсвэл сүүлийн entry) устгана. */
+    private fun pruneBottomTwoupOneRow() {
+        val last = pageEntries.lastOrNull() ?: return
+        val row = last.frame.parent as? LinearLayout
+        if (row != null && row.parent === container && row.childCount > 0) {
+            val removeList = pageEntries.filter { it.frame.parent === row }
+            for (e in removeList) {
+                (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+                pageEntries.remove(e)
+            }
+            container.removeView(row)
+        } else {
+            val e = pageEntries.removeLastOrNull() ?: return
+            (e.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(e.frame)
+        }
+        renderedUpTo = windowStart + pageEntries.size - 1
+    }
+
+    /**
+     * Дээр (index 0) шинэ хуудас оруулна. windowStart-г дуудагч тал шинэчилнэ.
+     */
+    private fun prependPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) {
+        val bmpW = bmp.width
+        val bmpH = bmp.height
+        val frame = FrameLayout(context).apply {
+            layoutParams = LinearLayout.LayoutParams(bmpW, bmpH).apply { setMargins(0, 6, 0, 6) }
+        }
+        val iv = ImageView(context).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            scaleType = ImageView.ScaleType.FIT_XY
+            setImageBitmap(bmp)
+        }
+        val canvasView = AnnotationCanvasView(context, pageIdx, pdfW, pdfH).apply {
+            layoutParams = FrameLayout.LayoutParams(bmpW, bmpH)
+            translationZ = 1f
+        }
+        frame.addView(iv)
+        frame.addView(canvasView)
+        container.addView(frame, 0)
+        pageEntries.add(0, PageEntry(frame, canvasView, bmpH))
+    }
+
+    /**
+     * Доод хэсгийн [count] хуудсыг устгаж bitmap санах ойг чөлөөлнэ.
+     * renderedUpTo-г буулгаж дараагийн доош scroll-д re-render хийгдэхийг зөвшөөрнэ.
+     */
+    private fun pruneBottomPages(count: Int) {
+        repeat(count) {
+            val entry = pageEntries.removeLastOrNull() ?: return@repeat
+            (entry.frame.getChildAt(0) as? ImageView)?.setImageBitmap(null)
+            container.removeView(entry.frame)
+        }
+        renderedUpTo = windowStart + pageEntries.size - 1
+    }
+
+    /**
+     * Render хийгдээгүй хуудас руу үсрэх.
+     * Бүх одоогийн view-г цэвэрлэж, targetPage-ийн эргэн тойрны хуудсуудыг render хийнэ.
+     */
+    private fun jumpToPage(targetPage: Int) {
+        val pdf = renderer ?: return
+        val viewWidth = currentViewWidth.takeIf { it > 0 } ?: width.takeIf { it > 0 } ?: return
+        renderJob?.cancel()
+        renderJob = scope.launch {
+            try {
+                // Шинэ window: targetPage-ийн хагас chunk өмнөөс эхэлнэ
+                val newStart = maxOf(0, targetPage - PAGE_CHUNK / 2)
+                val newEnd = minOf(totalPages, newStart + MAX_RENDERED)
+
+                withContext(Dispatchers.Main) {
+                    container.removeAllViews()
+                    pageEntries.clear()
+                    loadingFooter = null
+                    windowStart = newStart
+                    renderedUpTo = newStart - 1
+                    chunkLoading = false
+                }
+
+                if (displayMode == "twoupcontinuous") {
+                    renderTwoUpRange(pdf, totalPages, viewWidth, newStart, newEnd)
+                    withContext(Dispatchers.Main) {
+                        val rawUpTo = if (newEnd % 2 == 0) newEnd - 1 else newEnd - 2
+                        renderedUpTo = rawUpTo.coerceIn(0, totalPages - 1)
+                        if (renderedUpTo < totalPages - 1) showLoadingFooter()
+                        forceLayoutScrollView()
+                        post { scrollToPage(targetPage, smooth = false) }
+                    }
+                } else {
+                    for (i in newStart until newEnd) {
+                        val bmp = renderPageBitmap(pdf, i, viewWidth)
+                        val idx = i
+                        withContext(Dispatchers.Main) {
+                            addPageRow(
+                                bmp, idx,
+                                pagePdfW.getOrElse(idx) { 1 }.toFloat(),
+                                pagePdfH.getOrElse(idx) { 1 }.toFloat()
+                            )
+                        }
+                    }
+                    withContext(Dispatchers.Main) {
+                        renderedUpTo = newEnd - 1
+                        if (newEnd < totalPages) showLoadingFooter()
+                        forceLayoutScrollView()
+                        post { scrollToPage(targetPage, smooth = false) }
+                    }
+                }
+            } catch (e: CancellationException) { throw e }
+            catch (e: Exception) { Log.e("ExpoPdfReader", "JumpToPage error", e) }
+        }
+    }
+
     /**
      * React Native Fabric нь child view-н requestLayout()-г таслах тул
      * addView() дараа layout pass автоматаар ажиллахгүй.
@@ -777,9 +1159,9 @@ class ExpoPdfReaderView(
     private fun addPageRow(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float) =
         container.addView(buildPageFrame(bmp, pageIdx, pdfW, pdfH))
 
-    private fun buildPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f): FrameLayout {
-        // MATCH_PARENT нь React Native managed view дотор layout pass болохоос өмнө
-        // width = 0 авдаг тул explicit pixel dimension ашиглана → шууд харагдана
+    private fun buildPageFrameDetached(
+        bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f
+    ): Pair<FrameLayout, PageEntry> {
         val bmpW = bmp.width
         val bmpH = bmp.height
         val frame = FrameLayout(context).apply {
@@ -800,13 +1182,22 @@ class ExpoPdfReaderView(
         }
         frame.addView(iv)
         frame.addView(canvasView)
-        pageEntries.add(PageEntry(canvasView))
+        return frame to PageEntry(frame, canvasView, bmpH)
+    }
+
+    private fun buildPageFrame(bmp: Bitmap, pageIdx: Int, pdfW: Float, pdfH: Float, weight: Float = 0f): FrameLayout {
+        val (frame, entry) = buildPageFrameDetached(bmp, pageIdx, pdfW, pdfH, weight)
+        pageEntries.add(entry)
         return frame
     }
 
     private suspend fun renderPageBitmap(pdf: PdfRenderer, index: Int, targetWidth: Int): Bitmap =
         withContext(pdfDispatcher) {
             pdf.openPage(index).use { page ->
+                if (index < pagePdfW.size) {
+                    pagePdfW[index] = page.width
+                    pagePdfH[index] = page.height
+                }
                 val s = targetWidth.toFloat() / page.width.toFloat()
                 val h = (page.height * s).toInt().coerceAtLeast(1)
                 val bmp = Bitmap.createBitmap(targetWidth, h, Bitmap.Config.ARGB_8888)
@@ -844,8 +1235,9 @@ class ExpoPdfReaderView(
 
     // ─────────────────────────────────────────────────────────────────────────
     // SinglePageAdapter  — RecyclerView adapter for "single" display mode
-    //   • horizontal PagerSnapHelper → iOS usePageViewController(true) шиг
-    //   • lazy bitmap loading (зөвхөн харагдаж буй + хажуугийн хуудсуудыг)
+    //   • vertical PagerSnapHelper — босоо scroll-оор хуудас солих
+    //   • ZoomRecyclerView zoom-г удирдана (adapter энгийн FrameLayout ашиглана)
+    //   • lazy bitmap loading
     // ─────────────────────────────────────────────────────────────────────────
 
     inner class SinglePageAdapter : RecyclerView.Adapter<SinglePageAdapter.Holder>() {
@@ -867,9 +1259,6 @@ class ExpoPdfReaderView(
                 )
                 setBackgroundColor(Color.parseColor("#E8E8E8"))
             }
-            // ImageView starts WRAP_CONTENT; sized to bitmap in onBindViewHolder so that
-            // the AnnotationCanvasView can use the same pixel dimensions — no FIT_CENTER
-            // offset mis-alignment.
             val iv = ImageView(context).apply {
                 layoutParams = FrameLayout.LayoutParams(
                     FrameLayout.LayoutParams.WRAP_CONTENT,
@@ -886,51 +1275,43 @@ class ExpoPdfReaderView(
             holder.boundPage = position
             holder.loadJob?.cancel()
             holder.imageView.setImageBitmap(null)
+            // Recycle хийгдсэн view-н zoom transform-г цэвэрлэнэ
+            holder.frame.scaleX = 1f; holder.frame.scaleY = 1f
+            holder.frame.translationX = 0f; holder.frame.translationY = 0f
 
-            // Remove old canvas and register new one for this page
             holder.currentCanvas?.let {
                 singlePageCanvases.remove(it.pageIndex)
                 holder.frame.removeView(it)
             }
-            val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
-            val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
-            // Canvas starts with placeholder size; resized to exact bitmap dims after load.
-            // translationZ ensures canvas always renders above ImageView regardless of layout order.
-            val canvas = AnnotationCanvasView(context, position, pdfW, pdfH).apply {
-                layoutParams = FrameLayout.LayoutParams(
-                    FrameLayout.LayoutParams.WRAP_CONTENT,
-                    FrameLayout.LayoutParams.WRAP_CONTENT,
-                    android.view.Gravity.CENTER
-                )
-                translationZ = 1f
-            }
-            holder.frame.addView(canvas)
-            holder.currentCanvas = canvas
-            singlePageCanvases[position] = canvas
+            holder.currentCanvas = null
 
-            // Lazy bitmap rendering
             holder.loadJob = scope.launch {
                 val pdf = renderer ?: return@launch
                 val bmp = renderPageBitmap(pdf, position, this@ExpoPdfReaderView.width)
+                val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
+                val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
                 withContext(Dispatchers.Main) {
-                    if (holder.boundPage == position) {
-                        // Size both ImageView and AnnotationCanvasView to the exact bitmap
-                        // pixel dimensions so annotation coordinates match perfectly.
-                        val lp = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
-                        holder.imageView.layoutParams = lp
-                        holder.imageView.setImageBitmap(bmp)
-                        holder.currentCanvas?.layoutParams = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
-                        // React Native Fabric blocks requestLayout() on child views.
-                        // Manually measure+layout the frame so the updated layoutParams
-                        // take effect immediately without waiting for the next Fabric pass.
-                        val fw = this@ExpoPdfReaderView.width.takeIf { it > 0 } ?: return@withContext
-                        val fh = this@ExpoPdfReaderView.height.takeIf { it > 0 } ?: return@withContext
-                        holder.frame.measure(
-                            MeasureSpec.makeMeasureSpec(fw, MeasureSpec.EXACTLY),
-                            MeasureSpec.makeMeasureSpec(fh, MeasureSpec.EXACTLY)
+                    if (holder.boundPage != position) return@withContext
+                    val canvas = AnnotationCanvasView(context, position, pdfW, pdfH).apply {
+                        layoutParams = FrameLayout.LayoutParams(
+                            bmp.width, bmp.height,
+                            android.view.Gravity.CENTER
                         )
-                        holder.frame.layout(0, 0, fw, fh)
+                        translationZ = 1f
                     }
+                    holder.frame.addView(canvas)
+                    holder.currentCanvas = canvas
+                    singlePageCanvases[position] = canvas
+                    val lp = FrameLayout.LayoutParams(bmp.width, bmp.height, android.view.Gravity.CENTER)
+                    holder.imageView.layoutParams = lp
+                    holder.imageView.setImageBitmap(bmp)
+                    val fw = this@ExpoPdfReaderView.width.takeIf { it > 0 } ?: return@withContext
+                    val fh = this@ExpoPdfReaderView.height.takeIf { it > 0 } ?: return@withContext
+                    holder.frame.measure(
+                        MeasureSpec.makeMeasureSpec(fw, MeasureSpec.EXACTLY),
+                        MeasureSpec.makeMeasureSpec(fh, MeasureSpec.EXACTLY)
+                    )
+                    holder.frame.layout(0, 0, fw, fh)
                 }
             }
         }
@@ -946,6 +1327,101 @@ class ExpoPdfReaderView(
         }
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // ZoomRecyclerView — single mode-д pinch-to-zoom + pan дэмждэг RecyclerView
+    //
+    // Яагаад RecyclerView subclass хийх шаардлагатай вэ:
+    //   AnnotationCanvasView ACTION_DOWN-д false буцаана → RecyclerView
+    //   gesture-г эзэмшиж авна → дараагийн ACTION_POINTER_DOWN (2-р хуруу)
+    //   шууд RecyclerView.onTouchEvent-д очдог.
+    //   RecyclerView subclass хийснээр onTouchEvent-д multi-touch-г зохицуулна.
+    //
+    // Zoom тооцоо (pivot=0,0 + translation):
+    //   Item view point (px,py) → дэлгэц: (px*scale + tx, py*scale + ty)
+    //   Focus (fx,fy) тогтвортой байхад: new_tx = fx - (fx - tx) * scaleFactor
+    // ─────────────────────────────────────────────────────────────────────────
+
+    inner class ZoomRecyclerView(context: Context) : RecyclerView(context) {
+        private var currentScale = 1f
+        private var tx = 0f
+        private var ty = 0f
+        private var panX = 0f
+        private var panY = 0f
+
+        private val zoomDetector = ScaleGestureDetector(context,
+            object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+                override fun onScale(d: ScaleGestureDetector): Boolean {
+                    val newScale = (currentScale * d.scaleFactor).coerceIn(minZoom, maxZoom)
+                    val af = newScale / currentScale
+                    // Focus point тогтвортой байхын zoom-to-point тооцоо
+                    tx = d.focusX - (d.focusX - tx) * af
+                    ty = d.focusY - (d.focusY - ty) * af
+                    currentScale = newScale
+                    clampAndApply()
+                    return true
+                }
+            }
+        )
+
+        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+            // Zoom хийгдсэн + tool идэвхгүй → pan хийхийн тулд ACTION_DOWN-г intercept
+            if (currentScale > 1f && activeTool == null && ev.action == MotionEvent.ACTION_DOWN) {
+                return true
+            }
+            return super.onInterceptTouchEvent(ev)
+        }
+
+        override fun onTouchEvent(ev: MotionEvent): Boolean {
+            zoomDetector.onTouchEvent(ev)
+
+            // 2 хуруу байвал RecyclerView scroll хийхгүйгээр zoom-г л хийнэ
+            if (ev.pointerCount >= 2 || zoomDetector.isInProgress) {
+                return true
+            }
+
+            // Zoom хийгдсэн үед нэг хуруугаар pan (tool идэвхгүй)
+            if (currentScale > 1f && activeTool == null) {
+                when (ev.actionMasked) {
+                    MotionEvent.ACTION_DOWN -> { panX = ev.x; panY = ev.y }
+                    MotionEvent.ACTION_MOVE -> {
+                        tx += ev.x - panX
+                        ty += ev.y - panY
+                        panX = ev.x; panY = ev.y
+                        clampAndApply()
+                    }
+                    MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { }
+                }
+                return true
+            }
+
+            return super.onTouchEvent(ev)
+        }
+
+        fun resetZoom() {
+            currentScale = 1f; tx = 0f; ty = 0f
+            applyToCurrentItem()
+        }
+
+        private fun clampAndApply() {
+            val w = width.toFloat(); val h = height.toFloat()
+            if (w > 0f && h > 0f) {
+                val sw = w * currentScale; val sh = h * currentScale
+                tx = if (sw > w) tx.coerceIn(w - sw, 0f) else 0f
+                ty = if (sh > h) ty.coerceIn(h - sh, 0f) else 0f
+            }
+            applyToCurrentItem()
+        }
+
+        private fun applyToCurrentItem() {
+            val lm = layoutManager as? LinearLayoutManager ?: return
+            val pos = lm.findFirstVisibleItemPosition().takeIf { it >= 0 } ?: return
+            val itemView = lm.findViewByPosition(pos) ?: return
+            itemView.pivotX = 0f; itemView.pivotY = 0f
+            itemView.scaleX = currentScale; itemView.scaleY = currentScale
+            itemView.translationX = tx; itemView.translationY = ty
+        }
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
     // AnnotationCanvasView  (inner class — full access to outer view state)
     // ─────────────────────────────────────────────────────────────────────────

package/ios/ExpoPdfReaderView.swift

@@ -53,6 +53,9 @@ final class ExpoPdfReaderView: ExpoView {
     private var draggingPage: PDFPage?
     private var dragStartPagePoint: CGPoint?
     private var dragStartBounds: CGRect?
+    // Zoom range: minZoom=1.0 (fit width), maxZoom=5.0 → pinch-to-zoom дэмжинэ
+    private var minZoom: CGFloat = 1.0
+    private var maxZoom: CGFloat = 5.0
 
     required init(appContext: AppContext? = nil) {
         super.init(appContext: appContext)
@@ -141,11 +144,12 @@ final class ExpoPdfReaderView: ExpoView {
 
         guard viewWidth > 0, pageBounds.width > 0 else { return }
 
-        let scale = viewWidth / pageBounds.width
-        // Lock both min/max to same scale so user cannot zoom → no horizontal scroll
-        pdfView.minScaleFactor = scale
-        pdfView.maxScaleFactor = scale
-        pdfView.scaleFactor = scale
+        let fitScale = viewWidth / pageBounds.width
+        // min/max өөр байх ёстой — pinch-to-zoom ажиллана (Android-тай ижил)
+        pdfView.minScaleFactor = fitScale * minZoom
+        pdfView.maxScaleFactor = fitScale * maxZoom
+        // Анхны scale = fit width. PDFView default scaleFactor=1.0 байдаг тул үргэлж fitScale тохируулна
+        pdfView.scaleFactor = fitScale
 
         // Also make sure the underlying scroll view never scrolls horizontally
         if let scrollView = findScrollView(in: pdfView) {
@@ -291,8 +295,19 @@ final class ExpoPdfReaderView: ExpoView {
         lastPageIndex = index
     }
 
-    func setMinZoom(_ v: Double) { pdfView.minScaleFactor = CGFloat(v) }
-    func setMaxZoom(_ v: Double) { pdfView.maxScaleFactor = CGFloat(v) }
+    func setMinZoom(_ v: Double) {
+        minZoom = CGFloat(v)
+        // scaleToFitWidth дахин дуудагдаагүй бол одоогийн fitScale-аар тооцоо
+        if pdfView.document != nil {
+            scaleToFitWidth()
+        }
+    }
+    func setMaxZoom(_ v: Double) {
+        maxZoom = CGFloat(v)
+        if pdfView.document != nil {
+            scaleToFitWidth()
+        }
+    }
 
     func setTool(_ tool: String?) {
         currentTool = tool != nil ? AnnotationTool(rawValue: tool!) : nil

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@june24/expo-pdf-reader",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "A PDF reader for Expo apps with annotation and zoom controls",
   "homepage": "git@gitlab.com:june_241/expo-pdf-reader.git",
   "main": "build/index.js",