react-native-optimized-pdf 1.0.1 → 1.2.0

package/android/src/main/kotlin/com/reactnativeoptimizedpdf/OptimizedPdfView.kt

@@ -5,7 +5,6 @@ import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
-import android.graphics.pdf.PdfRenderer
 import android.os.ParcelFileDescriptor
 import android.util.AttributeSet
 import android.view.GestureDetector
@@ -15,18 +14,24 @@ import android.widget.FrameLayout
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.events.RCTEventEmitter
-import com.tom_roush.pdfbox.android.PDFBoxResourceLoader
-import com.tom_roush.pdfbox.pdmodel.PDDocument
-import com.tom_roush.pdfbox.pdmodel.encryption.InvalidPasswordException
+import io.legere.pdfiumandroid.PdfDocument
+import io.legere.pdfiumandroid.PdfPage
+import io.legere.pdfiumandroid.PdfPasswordException
+import io.legere.pdfiumandroid.PdfiumCore
 import java.io.File
-import java.io.FileOutputStream
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+import android.graphics.Rect
 import kotlin.math.max
 import kotlin.math.min
+import kotlin.math.sqrt
 
 /**
  * View otimizada para renderização de PDF no Android
  * 
- * Usa PdfRenderer do Android para renderização eficiente em memória
+ * Usa PdfiumCore (pdfiumandroid) para renderização eficiente com suporte a Annots
  * com suporte a zoom via ScaleGestureDetector e pan via GestureDetector
  */
 class OptimizedPdfView @JvmOverloads constructor(
@@ -35,10 +40,22 @@ class OptimizedPdfView @JvmOverloads constructor(
     defStyleAttr: Int = 0
 ) : FrameLayout(context, attrs, defStyleAttr) {
 
-    private var pdfRenderer: PdfRenderer? = null
+    companion object {
+        private const val TILE_SIZE = 512
+    }
+
+    private class Tile(val x: Int, val y: Int, val size: Int, val scale: Float, val bitmap: Bitmap)
+
+    private val pdfiumCore: PdfiumCore = PdfiumCore()
+    private var pdfDocument: PdfDocument? = null
     private var fileDescriptor: ParcelFileDescriptor? = null
-    private var currentPage: PdfRenderer.Page? = null
-    private var currentBitmap: Bitmap? = null
+    private var currentPage: PdfPage? = null
+    private var baseBitmap: Bitmap? = null
+    
+    private val activeTiles = ConcurrentHashMap<String, Tile>()
+    private val tileFutures = ConcurrentHashMap<String, Future<*>>()
+    private var pendingBaseRenderFuture: Future<*>? = null
+    private val renderExecutor: ExecutorService = Executors.newFixedThreadPool(2)
     
     private var source: String = ""
     private var pageIndex: Int = 0
@@ -56,8 +73,6 @@ class OptimizedPdfView @JvmOverloads constructor(
     
     private var needsLoad: Boolean = false
     private var pendingPageIndex: Int? = null
-    private var decryptedFile: File? = null
-    private var pdfBoxInitialized: Boolean = false
     
     private val paint = Paint().apply {
         isAntiAlias = true
@@ -70,7 +85,7 @@ class OptimizedPdfView @JvmOverloads constructor(
     
     private var lastTouchX: Float = 0f
     private var lastTouchY: Float = 0f
-    private var isDragging: Boolean = false
+    private var activePointerId: Int = -1
 
     init {
         setBackgroundColor(Color.WHITE)
@@ -103,6 +118,7 @@ class OptimizedPdfView @JvmOverloads constructor(
                     translateY = focusY - newContentY - (pdfY * scaleFactor)
                     
                     constrainTranslation()
+                    updateTiles()
                     invalidate()
                 }
                 return true
@@ -118,21 +134,6 @@ class OptimizedPdfView @JvmOverloads constructor(
                 }
                 return true
             }
-            
-            override fun onScroll(
-                e1: MotionEvent?,
-                e2: MotionEvent,
-                distanceX: Float,
-                distanceY: Float
-            ): Boolean {
-                if (!scaleGestureDetector.isInProgress) {
-                    translateX -= distanceX
-                    translateY -= distanceY
-                    constrainTranslation()
-                    invalidate()
-                }
-                return true
-            }
         })
     }
 
@@ -168,7 +169,8 @@ class OptimizedPdfView @JvmOverloads constructor(
                     translateY = focusY - newContentY - (pdfY * currentScale)
                 }
                 constrainTranslation()
-                invalidate()
+                    updateTiles()
+                    invalidate()
             }
             start()
         }
@@ -195,17 +197,76 @@ class OptimizedPdfView @JvmOverloads constructor(
     }
 
     override fun onTouchEvent(event: MotionEvent): Boolean {
-        var handled = scaleGestureDetector.onTouchEvent(event)
-        handled = gestureDetector.onTouchEvent(event) || handled
-        return handled || super.onTouchEvent(event)
+        scaleGestureDetector.onTouchEvent(event)
+        gestureDetector.onTouchEvent(event)
+        
+        when (event.actionMasked) {
+            MotionEvent.ACTION_DOWN -> {
+                activePointerId = event.getPointerId(0)
+                lastTouchX = event.x
+                lastTouchY = event.y
+                if (scaleFactor > minScaleFactor + 0.01f) {
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+            }
+            MotionEvent.ACTION_MOVE -> {
+                if (!scaleGestureDetector.isInProgress) {
+                    val pointerIndex = event.findPointerIndex(activePointerId)
+                    if (pointerIndex >= 0) {
+                        val x = event.getX(pointerIndex)
+                        val y = event.getY(pointerIndex)
+                        
+                        translateX += (x - lastTouchX)
+                        translateY += (y - lastTouchY)
+                        constrainTranslation()
+                    updateTiles()
+                    invalidate()
+                        
+                        lastTouchX = x
+                        lastTouchY = y
+                    }
+                } else {
+                    val pointerIndex = event.findPointerIndex(activePointerId)
+                    if (pointerIndex >= 0) {
+                        lastTouchX = event.getX(pointerIndex)
+                        lastTouchY = event.getY(pointerIndex)
+                    }
+                }
+            }
+            MotionEvent.ACTION_POINTER_UP -> {
+                val pointerIndex = event.actionIndex
+                val pointerId = event.getPointerId(pointerIndex)
+                if (pointerId == activePointerId) {
+
+                    val newIndex = if (pointerIndex == 0) 1 else 0
+                    if (newIndex < event.pointerCount) {
+                        activePointerId = event.getPointerId(newIndex)
+                        lastTouchX = event.getX(newIndex)
+                        lastTouchY = event.getY(newIndex)
+                    }
+                }
+
+                if (event.pointerCount == 2) {
+                    val idx = event.findPointerIndex(activePointerId)
+                    if (idx >= 0) {
+                        lastTouchX = event.getX(idx)
+                        lastTouchY = event.getY(idx)
+                    }
+                }
+            }
+            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                activePointerId = -1
+                parent?.requestDisallowInterceptTouchEvent(false)
+            }
+        }
+        return true
     }
 
     fun setSource(source: String) {
         if (this.source != source) {
             this.source = source
             needsLoad = true
-            pdfRenderer?.close()
-            pdfRenderer = null
+            closePdfDocument()
             pendingPageIndex = pageIndex
             requestLayout()
             invalidate()
@@ -215,7 +276,7 @@ class OptimizedPdfView @JvmOverloads constructor(
     fun setPage(page: Int) {
         if (this.pageIndex != page) {
             this.pageIndex = page
-            if (pdfRenderer != null) {
+            if (pdfDocument != null) {
                 displayPage(page)
             } else {
                 pendingPageIndex = page
@@ -241,8 +302,7 @@ class OptimizedPdfView @JvmOverloads constructor(
     fun setPassword(pwd: String) {
         if (this.password != pwd) {
             this.password = pwd
-            // Se já temos source mas falhou por senha, tenta recarregar
-            if (source.isNotEmpty() && pdfRenderer == null) {
+            if (source.isNotEmpty() && pdfDocument == null) {
                 needsLoad = true
                 requestLayout()
             }
@@ -255,12 +315,28 @@ class OptimizedPdfView @JvmOverloads constructor(
         if (width > 0 && height > 0 && needsLoad) {
             needsLoad = false
             loadPdf()
-        } else if (changed && currentBitmap != null) {
+        } else if (changed && baseBitmap != null) {
             calculateFitScale()
             constrainTranslation()
         }
     }
 
+    private fun closePdfDocument() {
+        pendingBaseRenderFuture?.cancel(true)
+        pendingBaseRenderFuture = null
+        try { currentPage?.close() } catch (_: Exception) {}
+        currentPage = null
+        
+        if (pdfDocument != null) {
+            try { pdfDocument?.close() } catch (_: Exception) {}
+            pdfDocument = null
+            fileDescriptor = null
+        } else {
+            try { fileDescriptor?.close() } catch (_: Exception) {}
+            fileDescriptor = null
+        }
+    }
+
     private fun loadPdf() {
         if (source.isEmpty()) return
         
@@ -277,22 +353,29 @@ class OptimizedPdfView @JvmOverloads constructor(
                 return
             }
             
-            var pdfFile = file
+            fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
             
             try {
-                fileDescriptor = ParcelFileDescriptor.open(pdfFile, ParcelFileDescriptor.MODE_READ_ONLY)
-                pdfRenderer = PdfRenderer(fileDescriptor!!)
-            } catch (e: SecurityException) {
+                val pwd = if (password.isNotEmpty()) password else null
+                pdfDocument = pdfiumCore.newDocument(fileDescriptor!!, pwd)
+            } catch (e: PdfPasswordException) {
                 fileDescriptor?.close()
                 fileDescriptor = null
-                
-                pdfFile = decryptPdfWithPassword(file) ?: return
-                
-                fileDescriptor = ParcelFileDescriptor.open(pdfFile, ParcelFileDescriptor.MODE_READ_ONLY)
-                pdfRenderer = PdfRenderer(fileDescriptor!!)
+                if (password.isEmpty()) {
+                    sendPasswordRequired()
+                    sendError("PDF is password protected")
+                } else {
+                    sendError("Invalid password for PDF")
+                }
+                return
+            } catch (e: Exception) {
+                fileDescriptor?.close()
+                fileDescriptor = null
+                sendError("Failed to load PDF: ${e.message}")
+                return
             }
             
-            val pageCount = pdfRenderer!!.pageCount
+            val pageCount = pdfDocument!!.getPageCount()
             
             sendPageCount(pageCount)
             
@@ -304,81 +387,30 @@ class OptimizedPdfView @JvmOverloads constructor(
             sendError("Failed to load PDF: ${e.message}")
         }
     }
-    
-    private fun decryptPdfWithPassword(file: File): File? {
-        if (!pdfBoxInitialized) {
-            PDFBoxResourceLoader.init(context)
-            pdfBoxInitialized = true
-        }
-        
-        val document: PDDocument
-        try {
-            document = if (password.isNotEmpty()) {
-                PDDocument.load(file, password)
-            } else {
-                try {
-                    PDDocument.load(file, "")
-                } catch (e: InvalidPasswordException) {
-                    sendPasswordRequired()
-                    sendError("PDF is password protected")
-                    return null
-                }
-            }
-        } catch (e: InvalidPasswordException) {
-            sendError("Invalid password for PDF")
-            return null
-        } catch (e: Exception) {
-            sendError("Failed to decrypt PDF: ${e.message}")
-            return null
-        }
-        
-        try {
-            if (document.isEncrypted) {
-                document.setAllSecurityToBeRemoved(true)
-            }
-            
-            val tempFile = File(context.cacheDir, "decrypted_${System.currentTimeMillis()}.pdf")
-            document.save(FileOutputStream(tempFile))
-            document.close()
-            
-            decryptedFile?.delete()
-            decryptedFile = tempFile
-            
-            return tempFile
-        } catch (e: Exception) {
-            document.close()
-            sendError("Failed to save decrypted PDF: ${e.message}")
-            return null
-        }
-    }
 
     private fun displayPage(index: Int) {
-        val renderer = pdfRenderer ?: return
+        val doc = pdfDocument ?: return
         
-        if (index < 0 || index >= renderer.pageCount) {
+        val pageCount = doc.getPageCount()
+        if (index < 0 || index >= pageCount) {
             sendError("Invalid page index: $index")
             return
         }
         
-        currentPage?.close()
-        
-        currentPage = renderer.openPage(index)
-        val page = currentPage!!
+        pendingBaseRenderFuture?.cancel(true)
+        pendingBaseRenderFuture = null
         
-        pageWidth = page.width
-        pageHeight = page.height
+        baseBitmap?.recycle()
+        baseBitmap = null
         
-        val scale = calculateRenderScale()
-        val bitmapWidth = (pageWidth * scale).toInt()
-        val bitmapHeight = (pageHeight * scale).toInt()
+        currentPage?.close()
+        currentPage = null
         
-        currentBitmap?.recycle()
+        val page = doc.openPage(index)
+        currentPage = page
         
-        currentBitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888)
-        currentBitmap?.let { bitmap ->
-            bitmap.eraseColor(Color.WHITE)
-            page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
-        }
+        pageWidth = page.getPageWidthPoint()
+        pageHeight = page.getPageHeightPoint()
         
         pageIndex = index
         calculateFitScale()
@@ -387,23 +419,150 @@ class OptimizedPdfView @JvmOverloads constructor(
         translateX = 0f
         translateY = 0f
         
+        clearTiles()
+        updateTiles()
         invalidate()
         
+        val scale = calculateBaseScale()
+        val bmpWidth = max(1, (pageWidth * scale).toInt())
+        val bmpHeight = max(1, (pageHeight * scale).toInt())
+        
+        pendingBaseRenderFuture = renderExecutor.submit {
+            try {
+                val bitmap = Bitmap.createBitmap(bmpWidth, bmpHeight, Bitmap.Config.ARGB_8888)
+                bitmap.eraseColor(Color.WHITE)
+                
+                synchronized(page) {
+                    if (currentPage == page) {
+                        page.renderPageBitmap(
+                            bitmap, 0, 0, bmpWidth, bmpHeight,
+                            renderAnnot = true
+                        )
+                    }
+                }
+                
+                post {
+                    if (currentPage == page) {
+                        baseBitmap?.recycle()
+                        baseBitmap = bitmap
+                        invalidate()
+                    } else {
+                        bitmap.recycle()
+                    }
+                }
+            } catch (_: Exception) { }
+        }
+        
         sendLoadComplete(index, pageWidth, pageHeight)
     }
 
-    private fun calculateRenderScale(): Float {
-        val displayMetrics = resources.displayMetrics
-        val screenDensity = displayMetrics.density
-        
-        val baseScale = 2.0f * screenDensity
+    private fun clearTiles() {
+        tileFutures.values.forEach { it.cancel(true) }
+        tileFutures.clear()
+        activeTiles.values.forEach { it.bitmap.recycle() }
+        activeTiles.clear()
+    }
+
+    private fun updateTiles() {
+        if (width == 0 || height == 0 || pageWidth == 0 || pageHeight == 0) return
+        val page = currentPage ?: return
+
+        val scaledWidth = pageWidth * scaleFactor
+        val scaledHeight = pageHeight * scaleFactor
+
+        val contentX = (width - scaledWidth) / 2 + translateX
+        val contentY = (height - scaledHeight) / 2 + translateY
+
+        val visibleLeft = max(0f, -contentX)
+        val visibleTop = max(0f, -contentY)
+        val visibleRight = min(scaledWidth, width - contentX)
+        val visibleBottom = min(scaledHeight, height - contentY)
+
+        if (visibleRight <= visibleLeft || visibleBottom <= visibleTop) return
+
+        val cols = Math.ceil((scaledWidth / TILE_SIZE).toDouble()).toInt()
+        val rows = Math.ceil((scaledHeight / TILE_SIZE).toDouble()).toInt()
+
+        val startCol = Math.floor((visibleLeft / TILE_SIZE).toDouble()).toInt().coerceIn(0, cols - 1)
+        val endCol = Math.floor((visibleRight / TILE_SIZE).toDouble()).toInt().coerceIn(0, cols - 1)
+        val startRow = Math.floor((visibleTop / TILE_SIZE).toDouble()).toInt().coerceIn(0, rows - 1)
+        val endRow = Math.floor((visibleBottom / TILE_SIZE).toDouble()).toInt().coerceIn(0, rows - 1)
+
+        val neededKeys = mutableSetOf<String>()
+        val currentZoomFactor = scaleFactor
+
+        for (r in startRow..endRow) {
+            for (c in startCol..endCol) {
+                val key = "${currentZoomFactor}_${c}_${r}"
+                neededKeys.add(key)
+                
+                if (!activeTiles.containsKey(key) && !tileFutures.containsKey(key)) {
+                    val tileX = c * TILE_SIZE
+                    val tileY = r * TILE_SIZE
+                    
+                    val future = renderExecutor.submit {
+                        try {
+                            val bitmap = Bitmap.createBitmap(TILE_SIZE, TILE_SIZE, Bitmap.Config.ARGB_8888)
+                            bitmap.eraseColor(Color.WHITE)
+                            
+                            synchronized(page) {
+                                if (currentPage == page) {
+                                    page.renderPageBitmap(
+                                        bitmap,
+                                        -tileX, -tileY,
+                                        scaledWidth.toInt(), scaledHeight.toInt(),
+                                        renderAnnot = true
+                                    )
+                                }
+                            }
+                            
+                            val tile = Tile(tileX, tileY, TILE_SIZE, currentZoomFactor, bitmap)
+                            if (scaleFactor == currentZoomFactor) {
+                                activeTiles[key] = tile
+                                postInvalidate()
+                            } else {
+                                bitmap.recycle()
+                            }
+                        } catch (e: Exception) {
+                            e.printStackTrace()
+                        } finally {
+                            tileFutures.remove(key)
+                        }
+                    }
+                    tileFutures[key] = future
+                }
+            }
+        }
+
+        val keysToRemove = activeTiles.keys.filter { it !in neededKeys }
+        for (key in keysToRemove) {
+            activeTiles.remove(key)?.bitmap?.recycle()
+        }
+        val futuresToRemove = tileFutures.keys.filter { it !in neededKeys }
+        for (key in futuresToRemove) {
+            tileFutures.remove(key)?.cancel(true)
+        }
+    }
+
+    private fun calculateBaseScale(): Float {
+        if (pageWidth == 0 || pageHeight == 0) return 1.0f
         
-        val maxDimension = max(pageWidth, pageHeight) * baseScale
-        return if (maxDimension > 4096) {
-            4096f / max(pageWidth, pageHeight)
+        var scale = if (width > 0 && height > 0) {
+            val scaleX = width.toFloat() / pageWidth
+            val scaleY = height.toFloat() / pageHeight
+            min(scaleX, scaleY)
         } else {
-            baseScale
+            1.0f
         }
+        
+        // Base image limit: ~4M pixels (approx. 16MB) to avoid exceeding the Canvas size limit
+        val maxPixels = 4000000.0
+        val bitmapPixels = (pageWidth.toDouble() * scale) * (pageHeight.toDouble() * scale)
+        if (bitmapPixels > maxPixels) {
+            scale = Math.sqrt(maxPixels / (pageWidth.toDouble() * pageHeight.toDouble())).toFloat()
+        }
+        
+        return max(scale, 0.1f)
     }
 
     private fun calculateFitScale() {
@@ -421,28 +580,37 @@ class OptimizedPdfView @JvmOverloads constructor(
     override fun onDraw(canvas: Canvas) {
         super.onDraw(canvas)
         
-        val bitmap = currentBitmap ?: return
-        
-        canvas.save()
-        
         val scaledWidth = pageWidth * scaleFactor
         val scaledHeight = pageHeight * scaleFactor
         
         val centerX = (width - scaledWidth) / 2 + translateX
         val centerY = (height - scaledHeight) / 2 + translateY
         
-        canvas.translate(centerX, centerY)
-        canvas.scale(scaleFactor / calculateRenderScale(), scaleFactor / calculateRenderScale())
-        
-        canvas.drawBitmap(bitmap, 0f, 0f, paint)
+        baseBitmap?.let { base ->
+            canvas.save()
+            canvas.translate(centerX, centerY)
+            val baseScaleX = scaledWidth / base.width.toFloat()
+            val baseScaleY = scaledHeight / base.height.toFloat()
+            canvas.scale(baseScaleX, baseScaleY)
+            canvas.drawBitmap(base, 0f, 0f, paint)
+            canvas.restore()
+        }
         
-        canvas.restore()
+        for (tile in activeTiles.values) {
+            if (tile.scale != scaleFactor) continue
+            
+            canvas.save()
+            canvas.translate(centerX + tile.x, centerY + tile.y)
+            val drawRect = android.graphics.Rect(0, 0, tile.bitmap.width, tile.bitmap.height)
+            canvas.drawBitmap(tile.bitmap, drawRect, drawRect, paint)
+            canvas.restore()
+        }
     }
 
     private fun sendLoadComplete(page: Int, width: Int, height: Int) {
         val reactContext = context as? ReactContext ?: return
         val event = Arguments.createMap().apply {
-            putInt("currentPage", page + 1) // 1-indexed como no iOS
+            putInt("currentPage", page + 1)
             putInt("width", width)
             putInt("height", height)
         }
@@ -476,24 +644,18 @@ class OptimizedPdfView @JvmOverloads constructor(
     }
 
     fun cleanup() {
-        currentPage?.close()
-        currentPage = null
-        
-        pdfRenderer?.close()
-        pdfRenderer = null
-        
-        fileDescriptor?.close()
-        fileDescriptor = null
+        pendingBaseRenderFuture?.cancel(true)
+        clearTiles()
+        renderExecutor.shutdownNow()
         
-        currentBitmap?.recycle()
-        currentBitmap = null
+        baseBitmap?.recycle()
+        baseBitmap = null
         
-        decryptedFile?.delete()
-        decryptedFile = null
+        closePdfDocument()
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         cleanup()
     }
-}
+}

package/docs/android-setup.md

@@ -56,7 +56,7 @@ override fun getPackages(): List<ReactPackage> =
 
 ## Features
 
-- High-performance PDF rendering using Android's native PdfRenderer
+- High-performance PDF rendering using pdfium
 - Smooth zoom and pan with gesture support
 - Double-tap to zoom/reset
 - Memory-efficient rendering with proper bitmap recycling

package/ios/Core/PDFConfiguration.swift

@@ -0,0 +1,28 @@
+import UIKit
+
+/// Configuration options for PDF rendering.
+struct PDFConfiguration {
+    /// Maximum zoom scale allowed.
+    var maximumZoom: CGFloat = 5.0
+
+    /// Whether to enable antialiasing for smoother rendering.
+    var enableAntialiasing: Bool = true
+
+    /// Password for encrypted PDFs.
+    var password: String?
+
+    /// Size of each tile for CATiledLayer rendering.
+    var tileSize: CGSize = CGSize(width: 512, height: 512)
+
+    /// Number of detail levels for zoom.
+    var levelsOfDetail: Int = 2
+
+    /// Bias for levels of detail (allows zoom up to 2^bias resolution).
+    var levelsOfDetailBias: Int = 8
+
+    /// Animation duration for zoom reset.
+    var zoomResetAnimationDuration: TimeInterval = 0.25
+
+    /// Default configuration.
+    static let `default` = PDFConfiguration()
+}