@june24/expo-pdf-reader 0.1.20 → 0.1.22

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

@@ -89,6 +89,7 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     private val onTextPress = ViewEvent<Map<String, Any>>("onTextPress", this, null)
 
     private var pageHeights = mutableListOf<Int>()
+    private var rowHeights = mutableListOf<Int>()
     private var pageWidthsPdf = mutableListOf<Float>()
     private var pageHeightsPdf = mutableListOf<Float>()
     private var pageViews = mutableListOf<ImageView?>()
@@ -383,6 +384,7 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         addView(scrollView)
         scrollView.viewTreeObserver.addOnScrollChangedListener {
             notifyPageChange()
+            scrollView.post { updateVisiblePages() }
         }
         viewTreeObserver.addOnGlobalLayoutListener {
             if (width <= 0) {
@@ -552,13 +554,38 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         notifyAnnotationChange()
     }
 
+    private fun isTwoUpMode(): Boolean = displayMode == "twoUp" || displayMode == "twoUpContinuous"
+
     private fun marginBetweenPages(): Int = if (displayMode == "single") 0 else 16
 
+    private fun getFrameForPage(pageIndex: Int): FrameLayout? {
+        if (pageIndex !in pageHeights.indices) return null
+        return if (isTwoUpMode()) {
+            val row = pageIndex / 2
+            val col = pageIndex % 2
+            if (row >= container.childCount) null
+            else (container.getChildAt(row) as? LinearLayout)?.getChildAt(col) as? FrameLayout
+        } else {
+            container.getChildAt(pageIndex) as? FrameLayout
+        }
+    }
+
     private fun scrollToPage(pageIndex: Int) {
         if (pageHeights.isEmpty()) return
-        var offset = 0
-        for (i in 0 until pageIndex.coerceIn(0, pageHeights.size - 1)) {
-            offset += pageHeights[i] + marginBetweenPages()
+        val idx = pageIndex.coerceIn(0, pageHeights.size - 1)
+        val gap = marginBetweenPages()
+        val offset = if (isTwoUpMode() && rowHeights.isNotEmpty()) {
+            var sum = 0
+            for (r in 0 until idx / 2) {
+                sum += rowHeights[r] + gap
+            }
+            sum
+        } else {
+            var sum = 0
+            for (i in 0 until idx) {
+                sum += pageHeights[i] + gap
+            }
+            sum
         }
         scrollView.post { scrollView.smoothScrollTo(0, offset) }
     }
@@ -598,6 +625,7 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         fileDescriptor?.close()
         fileDescriptor = null
         pageHeights.clear()
+        rowHeights.clear()
         pageWidthsPdf.clear()
         pageHeightsPdf.clear()
         pageViews.clear()
@@ -632,33 +660,39 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
             updateVisiblePages()
             return
         }
-        val viewHeight = height.coerceAtLeast(1)
         val viewWidth = width.coerceAtLeast(1)
+        val viewHeight = height.coerceAtLeast(1)
+        val isTwoUp = displayMode == "twoUp" || displayMode == "twoUpContinuous"
         val isSingle = displayMode == "single"
+        val effectiveWidth = if (isTwoUp) viewWidth / 2 else viewWidth
         scope.launch {
-            val w = viewWidth
+            val w = effectiveWidth
+            val minSlotHeight = if (isSingle) viewHeight else 0
             val result = withContext(Dispatchers.Default) {
                 (0 until renderer.pageCount).map { i ->
                     val page = renderer.openPage(i)
                     try {
-                        val pageH = if (isSingle) {
-                            viewHeight
-                        } else {
-                            (w.toFloat() * page.height / page.width).toInt()
-                        }
+                        val naturalH = (w.toFloat() * page.height / page.width).toInt()
+                        val pageH = if (isSingle) maxOf(naturalH, minSlotHeight) else naturalH
                         Triple(
                             i,
                             pageH,
                             Pair(page.width.toFloat(), page.height.toFloat())
                         )
                     } finally {
-                        page.close()
+                        try {
+                            page.close()
+                        } catch (e: Exception) {
+                            // Renderer may have been closed on main thread (e.g. resetRenderer)
+                        }
                     }
                 }
             }
             if (!isActive) return@launch
             withContext(Dispatchers.Main) {
+                if (pdfRenderer == null) return@launch
                 pageHeights.clear()
+                rowHeights.clear()
                 pageWidthsPdf.clear()
                 pageHeightsPdf.clear()
                 for ((_, h, pdfSize) in result) {
@@ -666,6 +700,14 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
                     pageWidthsPdf.add(pdfSize.first)
                     pageHeightsPdf.add(pdfSize.second)
                 }
+                if (isTwoUp) {
+                    val rowCount = (renderer.pageCount + 1) / 2
+                    for (r in 0 until rowCount) {
+                        val h0 = pageHeights.getOrElse(2 * r) { 0 }
+                        val h1 = pageHeights.getOrElse(2 * r + 1) { 0 }
+                        rowHeights.add(maxOf(h0, h1))
+                    }
+                }
                 ensurePlaceholders(renderer)
                 scrollToPage(initialPage.coerceIn(0, (renderer.pageCount - 1).coerceAtLeast(0)))
                 updateVisiblePages()
@@ -682,34 +724,81 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
         while (pageAnnotations.size < pageCount) {
             pageAnnotations.add(mutableListOf())
         }
-        for (i in 0 until pageCount) {
-            val frame = FrameLayout(context).apply {
-                layoutParams = LinearLayout.LayoutParams(
-                    LinearLayout.LayoutParams.MATCH_PARENT,
-                    pageHeights[i]
-                ).apply { setMargins(0, 0, 0, marginBetween) }
-                setBackgroundColor(Color.LTGRAY)
+        if (isTwoUpMode() && rowHeights.isNotEmpty()) {
+            val rowCount = rowHeights.size
+            for (r in 0 until rowCount) {
+                val rowLayout = LinearLayout(context).apply {
+                    orientation = LinearLayout.HORIZONTAL
+                    layoutParams = LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        rowHeights[r]
+                    ).apply { setMargins(0, 0, 0, marginBetween) }
+                }
+                for (col in 0..1) {
+                    val i = 2 * r + col
+                    if (i >= pageCount) break
+                    val frame = FrameLayout(context).apply {
+                        layoutParams = LinearLayout.LayoutParams(
+                            0,
+                            LinearLayout.LayoutParams.MATCH_PARENT,
+                            1f
+                        ).apply { setMargins(0, 0, if (col == 0) 8 else 0, 0) }
+                        setBackgroundColor(Color.LTGRAY)
+                    }
+                    val overlay = AnnotationOverlayView(context, i).apply {
+                        layoutParams = FrameLayout.LayoutParams(
+                            FrameLayout.LayoutParams.MATCH_PARENT,
+                            FrameLayout.LayoutParams.MATCH_PARENT
+                        )
+                    }
+                    frame.addView(overlay)
+                    rowLayout.addView(frame)
+                    overlayViews[i] = overlay
+                }
+                container.addView(rowLayout)
             }
-            val overlay = AnnotationOverlayView(context, i).apply {
-                layoutParams = FrameLayout.LayoutParams(
-                    FrameLayout.LayoutParams.MATCH_PARENT,
-                    FrameLayout.LayoutParams.MATCH_PARENT
-                )
+        } else {
+            for (i in 0 until pageCount) {
+                val frame = FrameLayout(context).apply {
+                    layoutParams = LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        pageHeights[i]
+                    ).apply { setMargins(0, 0, 0, marginBetween) }
+                    setBackgroundColor(Color.LTGRAY)
+                }
+                val overlay = AnnotationOverlayView(context, i).apply {
+                    layoutParams = FrameLayout.LayoutParams(
+                        FrameLayout.LayoutParams.MATCH_PARENT,
+                        FrameLayout.LayoutParams.MATCH_PARENT
+                    )
+                }
+                frame.addView(overlay)
+                container.addView(frame)
+                overlayViews[i] = overlay
             }
-            frame.addView(overlay)
-            container.addView(frame)
-            overlayViews[i] = overlay
         }
     }
 
     private fun currentPageFromScroll(): Int {
         if (pageHeights.isEmpty()) return 0
         val scrollY = scrollView.scrollY
-        var offset = 0
         val gap = marginBetweenPages()
+        if (isTwoUpMode() && rowHeights.isNotEmpty()) {
+            var offset = 0
+            for (r in rowHeights.indices) {
+                val rowH = rowHeights[r]
+                if (scrollY < offset + rowH / 2) return (2 * r).coerceAtMost(pageHeights.size - 1)
+                if (scrollY < offset + rowH) return (2 * r + 1).coerceAtMost(pageHeights.size - 1)
+                offset += rowH + gap
+            }
+            return (pageHeights.size - 1).coerceAtLeast(0)
+        }
+        val viewportCenter = scrollY + scrollView.height / 2
+        var offset = 0
         for (i in pageHeights.indices) {
-            if (scrollY < offset + pageHeights[i] / 2) return i
-            offset += pageHeights[i] + gap
+            val pageEnd = offset + pageHeights[i]
+            if (viewportCenter < pageEnd) return i
+            offset = pageEnd + gap
         }
         return (pageHeights.size - 1).coerceAtLeast(0)
     }
@@ -717,13 +806,17 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
     private fun updateVisiblePages() {
         val renderer = pdfRenderer ?: return
         val currentPage = currentPageFromScroll()
-        val from = (currentPage - renderWindowBefore).coerceAtLeast(0)
-        val to = (currentPage + renderWindowAfter).coerceAtMost(renderer.pageCount - 1)
+        val (from, to) = if (displayMode == "single") {
+            currentPage to currentPage
+        } else {
+            (currentPage - renderWindowBefore).coerceAtLeast(0) 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 frame = getFrameForPage(i) ?: continue
             val bmp = (iv.drawable as? BitmapDrawable)?.bitmap
             iv.setImageBitmap(null)
             bmp?.recycle()
@@ -740,11 +833,10 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
 
     private fun renderPageToView(pageIndex: Int) {
         val renderer = pdfRenderer ?: return
-        val frame = container.getChildAt(pageIndex) as? FrameLayout ?: return
-        // Frame always has overlay; only skip if we already have an ImageView for this page
+        val frame = getFrameForPage(pageIndex) ?: return
         if (pageViews.getOrNull(pageIndex) != null) return
         val page = renderer.openPage(pageIndex)
-        val w = width.coerceAtLeast(1)
+        val w = if (isTwoUpMode()) (width / 2).coerceAtLeast(1) else width.coerceAtLeast(1)
         val h = pageHeights[pageIndex]
         val bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
         page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
@@ -766,18 +858,7 @@ class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(con
 
     private fun notifyPageChange() {
         if (pageHeights.isEmpty()) return
-        val scrollY = scrollView.scrollY
-        var offset = 0
-        var detectedPage = 0
-        val gap = marginBetweenPages()
-        for (i in pageHeights.indices) {
-            if (scrollY < offset + pageHeights[i] / 2) {
-                detectedPage = i
-                break
-            }
-            offset += pageHeights[i] + gap
-            detectedPage = i
-        }
+        val detectedPage = currentPageFromScroll()
         if (detectedPage != lastEmittedPageIndex) {
             lastEmittedPageIndex = detectedPage
             onPageChange(mapOf(

package/package.json

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