@june24/expo-pdf-reader 0.1.25 → 0.1.27

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

@@ -132,19 +132,87 @@ class ExpoPdfReaderView(
     private var minZoom = 1.0f
     private var maxZoom = 5.0f
     private var currentZoom = 1.0f
-    private val scaleDetector = ScaleGestureDetector(
-        context,
-        object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
-            override fun onScale(d: ScaleGestureDetector): Boolean {
-                if (activeTool != null) return true
-                applyZoom((currentZoom * d.scaleFactor).coerceIn(minZoom, maxZoom))
+
+    /**
+     * continuous / twoup / twoupcontinuous — pinch + zoom үед зөвхөн pan (босоо scroll унтрах).
+     * Pinch-ийг [dispatchTouchEvent]-ийн эхэнд дуудаж хүү canvas POINTER_DOWN-д баригдахаас өмнө 2 хуруу хүлээнэ.
+     */
+    private inner class ZoomableScrollView(ctx: Context) : ScrollView(ctx) {
+        /** ScrollView-д [isScrollEnabled] байхгүй тул: false үед босоо scroll (super) ажиллахгүй. */
+        var allowVerticalScrollFromTouch = true
+
+        private val pinch = ScaleGestureDetector(
+            ctx,
+            object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+                override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+                    if (activeTool != null) return false
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                    return true
+                }
+
+                override fun onScale(detector: ScaleGestureDetector): Boolean {
+                    if (activeTool != null) return false
+                    applyZoom((currentZoom * detector.scaleFactor).coerceIn(minZoom, maxZoom))
+                    return true
+                }
+
+                override fun onScaleEnd(detector: ScaleGestureDetector) {
+                    parent?.requestDisallowInterceptTouchEvent(false)
+                }
+            }
+        )
+        private var panLastX = 0f
+        private var panLastY = 0f
+
+        override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onInterceptTouchEvent(ev)
+            // 2+ хуруу эсвэл pinch эхэлсэн үед ScrollView босоо scroll intercept хийхгүй (scroll + zoom өрсөлдөнө)
+            if (!allowVerticalScrollFromTouch) return false
+            if (ev.pointerCount > 1 || pinch.isInProgress) return false
+            return super.onInterceptTouchEvent(ev)
+        }
+
+        override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool == null) {
+                pinch.onTouchEvent(ev)
+                if (ev.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+                    stopNestedScroll()
+                }
+                if (pinch.isInProgress || ev.pointerCount > 1) {
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+            }
+            return super.dispatchTouchEvent(ev)
+        }
+
+        override fun onTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onTouchEvent(ev)
+            if (pinch.isInProgress || ev.pointerCount > 1) {
                 return true
             }
+            if (currentZoom > 1.02f) {
+                when (ev.actionMasked) {
+                    MotionEvent.ACTION_DOWN -> {
+                        panLastX = ev.x
+                        panLastY = ev.y
+                    }
+                    MotionEvent.ACTION_MOVE -> {
+                        val dx = ev.x - panLastX
+                        val dy = ev.y - panLastY
+                        panLastX = ev.x
+                        panLastY = ev.y
+                        applyContainerPanDelta(dx, dy)
+                    }
+                }
+                return true
+            }
+            if (!allowVerticalScrollFromTouch) return true
+            return super.onTouchEvent(ev)
         }
-    )
+    }
 
     // ── UI ───────────────────────────────────────────────────────────────────
-    val scrollView = ScrollView(context).apply {
+    private val scrollView = ZoomableScrollView(context).apply {
         layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
         isFillViewport = true
     }
@@ -169,6 +237,8 @@ class ExpoPdfReaderView(
             layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
             PagerSnapHelper().attachToRecyclerView(this)
             setBackgroundColor(Color.parseColor("#E8E8E8"))
+            overScrollMode = View.OVER_SCROLL_NEVER
+            isNestedScrollingEnabled = false
             visibility = View.GONE
             addOnScrollListener(object : RecyclerView.OnScrollListener() {
                 override fun onScrollStateChanged(rv: RecyclerView, newState: Int) {
@@ -209,11 +279,6 @@ class ExpoPdfReaderView(
         safeCloseRenderer()
     }
 
-    override fun onTouchEvent(event: MotionEvent): Boolean {
-        scaleDetector.onTouchEvent(event)
-        return super.onTouchEvent(event)
-    }
-
     // ─────────────────────────────────────────────────────────────────────────
     // Props
     // ─────────────────────────────────────────────────────────────────────────
@@ -472,20 +537,114 @@ class ExpoPdfReaderView(
     // ─────────────────────────────────────────────────────────────────────────
 
     private fun applyZoom(newZoom: Float) {
-        currentZoom = newZoom
+        currentZoom = newZoom.coerceIn(minZoom, maxZoom)
         container.pivotX = 0f
         container.pivotY = 0f
-        container.scaleX = newZoom
-        container.scaleY = newZoom
+        container.scaleX = currentZoom
+        container.scaleY = currentZoom
+        if (displayMode != "single") {
+            if (currentZoom <= 1.02f) {
+                scrollView.allowVerticalScrollFromTouch = true
+                container.translationX = 0f
+                container.translationY = 0f
+            } else {
+                scrollView.allowVerticalScrollFromTouch = false
+            }
+        }
+    }
+
+    /** Zoom > 1 үед container-ийг translation-оор pan (хуудас хоорондын scroll унтраасан) */
+    private fun applyContainerPanDelta(dx: Float, dy: Float) {
+        val ch = container.height.toFloat()
+        val cw = container.width.toFloat()
+        if (ch <= 0f || cw <= 0f) return
+        val scaledH = ch * currentZoom
+        val scaledW = cw * currentZoom
+        val vw = scrollView.width.toFloat()
+        val vh = scrollView.height.toFloat()
+        var tx = container.translationX + dx
+        var ty = container.translationY + dy
+        if (scaledW <= vw) tx = 0f else tx = tx.coerceIn(vw - scaledW, 0f)
+        if (scaledH <= vh) ty = 0f else ty = ty.coerceIn(vh - scaledH, 0f)
+        container.translationX = tx
+        container.translationY = ty
     }
 
     // ─────────────────────────────────────────────────────────────────────────
     // 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].bmpHeight.takeIf { it > 0 } ?: continue
@@ -510,12 +669,7 @@ class ExpoPdfReaderView(
             return
         }
         if (pageEntries.isEmpty()) return
-        // pageEntries[0] нь windowStart-р эхэлдэг тул relative index ашиглана
-        val relativeIndex = (pageIndex - windowStart).coerceIn(0, pageEntries.size - 1)
-        var y = 0
-        for (i in 0 until relativeIndex) {
-            y += (pageEntries[i].bmpHeight.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))
@@ -537,8 +691,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
@@ -583,6 +738,12 @@ class ExpoPdfReaderView(
         chunkLoading = false
 
         withContext(Dispatchers.Main) {
+            currentZoom = 1f
+            container.scaleX = 1f
+            container.scaleY = 1f
+            container.translationX = 0f
+            container.translationY = 0f
+            scrollView.allowVerticalScrollFromTouch = true
             container.removeAllViews()
             pageEntries.clear()
             loadingFooter = null
@@ -591,7 +752,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 дээр шууд дуудна
@@ -644,34 +810,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) }
             }
         }
     }
@@ -732,7 +917,7 @@ class ExpoPdfReaderView(
             }
         }
 
-        // Дээш scroll: өмнөх chunk ачаална
+        // Дээш scroll: өмнөх chunk (continuous = нэг багана; twoupcontinuous = хос мөр prepend).
         if (windowStart > 0 && scrollY <= scrollView.height * 2) {
             chunkLoading = true
             scope.launch {
@@ -805,6 +990,10 @@ class ExpoPdfReaderView(
      */
     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
@@ -840,6 +1029,105 @@ class ExpoPdfReaderView(
         }
     }
 
+    /** 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-г дуудагч тал шинэчилнэ.
      */
@@ -900,21 +1188,33 @@ class ExpoPdfReaderView(
                     chunkLoading = false
                 }
 
-                for (i in newStart until newEnd) {
-                    val bmp = renderPageBitmap(pdf, i, viewWidth)
-                    val idx = i
+                if (displayMode == "twoupcontinuous") {
+                    renderTwoUpRange(pdf, totalPages, viewWidth, newStart, newEnd)
                     withContext(Dispatchers.Main) {
-                        addPageRow(bmp, idx, pagePdfW.getOrElse(idx) { 1 }.toFloat(),
-                            pagePdfH.getOrElse(idx) { 1 }.toFloat())
+                        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) }
                     }
-                }
-
-                withContext(Dispatchers.Main) {
-                    renderedUpTo = newEnd - 1
-                    if (newEnd < totalPages) showLoadingFooter()
-                    forceLayoutScrollView()
-                    // Layout болсны дараа scroll хийнэ
-                    post { scrollToPage(targetPage, smooth = false) }
                 }
             } catch (e: CancellationException) { throw e }
             catch (e: Exception) { Log.e("ExpoPdfReader", "JumpToPage error", e) }
@@ -956,9 +1256,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 {
@@ -979,13 +1279,22 @@ class ExpoPdfReaderView(
         }
         frame.addView(iv)
         frame.addView(canvasView)
-        pageEntries.add(PageEntry(frame, canvasView, bmpH))
+        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)
@@ -1071,37 +1380,35 @@ class ExpoPdfReaderView(
                 singlePageCanvases.remove(it.pageIndex)
                 holder.frame.removeView(it)
             }
-            val pdfW = pagePdfW.getOrElse(position) { 1 }.toFloat()
-            val pdfH = pagePdfH.getOrElse(position) { 1 }.toFloat()
-            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
 
             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) {
-                        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)
-                        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)
                 }
             }
         }
@@ -1153,16 +1460,32 @@ class ExpoPdfReaderView(
             }
         )
 
+        override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool == null) {
+                zoomDetector.onTouchEvent(ev)
+                if (ev.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+                    stopScroll()
+                }
+                if (ev.pointerCount > 1 || zoomDetector.isInProgress) {
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+            }
+            return super.dispatchTouchEvent(ev)
+        }
+
         override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+            if (activeTool != null) return super.onInterceptTouchEvent(ev)
+            // Pinch үед RecyclerView хэвийн scroll intercept хийхгүй
+            if (ev.pointerCount > 1 || zoomDetector.isInProgress) return false
             // Zoom хийгдсэн + tool идэвхгүй → pan хийхийн тулд ACTION_DOWN-г intercept
-            if (currentScale > 1f && activeTool == null && ev.action == MotionEvent.ACTION_DOWN) {
+            if (currentScale > 1.02f && ev.action == MotionEvent.ACTION_DOWN) {
                 return true
             }
             return super.onInterceptTouchEvent(ev)
         }
 
         override fun onTouchEvent(ev: MotionEvent): Boolean {
-            zoomDetector.onTouchEvent(ev)
+            // zoomDetector-ийг dispatchTouchEvent-д аль хэдийн дамжуулсан
 
             // 2 хуруу байвал RecyclerView scroll хийхгүйгээр zoom-г л хийнэ
             if (ev.pointerCount >= 2 || zoomDetector.isInProgress) {
@@ -1170,9 +1493,12 @@ class ExpoPdfReaderView(
             }
 
             // Zoom хийгдсэн үед нэг хуруугаар pan (tool идэвхгүй)
-            if (currentScale > 1f && activeTool == null) {
+            if (currentScale > 1.02f && activeTool == null) {
                 when (ev.actionMasked) {
-                    MotionEvent.ACTION_DOWN -> { panX = ev.x; panY = ev.y }
+                    MotionEvent.ACTION_DOWN -> {
+                        stopScroll()
+                        panX = ev.x; panY = ev.y
+                    }
                     MotionEvent.ACTION_MOVE -> {
                         tx += ev.x - panX
                         ty += ev.y - panY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@june24/expo-pdf-reader",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "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",