@thatkid02/react-native-pdf-viewer 0.0.2 → 0.0.4

package/android/src/main/java/com/margelo/nitro/pdfviewer/PdfViewer.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.Rect
 import android.graphics.pdf.PdfRenderer
 import android.os.ParcelFileDescriptor
 import android.util.Log
@@ -13,11 +14,14 @@ import android.view.GestureDetector
 import android.view.MotionEvent
 import android.view.ScaleGestureDetector
 import android.view.View
-import android.graphics.Rect
+import android.view.View.MeasureSpec
 import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.ProgressBar
 import androidx.core.view.doOnLayout
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.facebook.proguard.annotations.DoNotStrip
@@ -26,6 +30,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -34,56 +39,120 @@ import java.io.File
 import java.io.FileOutputStream
 import java.net.URL
 import java.security.MessageDigest
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.math.roundToInt
 
+/**
+ * A high-performance PDF viewer component for React Native with Nitro integration.
+ * Supports zooming, thumbnails, page navigation, and efficient memory management.
+ */
 @DoNotStrip
 class PdfViewer(context: Context) : FrameLayout(context) {
+
     companion object {
         private const val TAG = "PdfViewer"
+        
+        // Memory management
         private const val CACHE_SIZE_PERCENTAGE = 0.25
-        private const val PRELOAD_RANGE = 1
-        // Dynamic quality scaling - prevents OOM at high zoom levels
-        private const val BASE_RENDER_QUALITY = 1.5f
-        // Maximum bitmap dimension to prevent GPU texture limits and OOM
         private const val MAX_BITMAP_DIMENSION = 4096
-        // Threshold for using reduced quality
-        private const val HIGH_ZOOM_THRESHOLD = 1.5f
+        private const val ESTIMATED_MEMORY_WARNING_MB = 50
+        
+        // Rendering quality (fixed - zoom uses view transformation)
+        private const val BASE_RENDER_QUALITY = 1.5f
+        
+        // Preloading
+        private const val PRELOAD_RANGE = 1
+        private const val INITIAL_PRELOAD_COUNT = 10
+        private const val INITIAL_PRELOAD_DELAY_MS = 50L
+        private const val LAZY_PRELOAD_DELAY_MS = 100L
+        
+        // UI
+        private const val LOADING_INDICATOR_SIZE_DP = 48
+        private const val THUMBNAIL_SIZE = 120
+        private const val THUMBNAIL_QUALITY = 85
+        private const val VIEW_CACHE_SIZE = 10
+        private const val RECYCLED_VIEW_POOL_SIZE = 20
+        
+        // Network
+        private const val CONNECT_TIMEOUT_MS = 30_000
+        private const val READ_TIMEOUT_MS = 60_000
+        private const val CACHE_VALIDITY_MS = 3600_000L
+        
+        // Default PDF page dimensions (US Letter)
+        private const val DEFAULT_PAGE_WIDTH = 612
+        private const val DEFAULT_PAGE_HEIGHT = 792
     }
 
-    // Core PDF components
+    // region Core PDF Components
+    
     private var pdfRenderer: PdfRenderer? = null
     private var parcelFileDescriptor: ParcelFileDescriptor? = null
     private val renderMutex = Mutex()
-    
-    // Coroutine scope with SupervisorJob for error isolation
     private val componentScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
     
-    // UI components
+    // endregion
+    
+    // region UI Components
+    
     private val recyclerView: RecyclerView
     private val loadingIndicator: ProgressBar
     private var adapter: PdfPageAdapter? = null
     
-    // Gesture handling
+    // endregion
+    
+    // region Gesture Handling
+    
     private val scaleGestureDetector: ScaleGestureDetector
     private val gestureDetector: GestureDetector
-    private var isScaling = false
+    @Volatile private var isScaling = false
+    
+    // endregion
+    
+    // region Rendering State
     
-    // Rendering state
     private val activeRenderJobs = mutableMapOf<Int, Job>()
     private val bitmapCache: LruCache<String, Bitmap>
-    private val pageDimensions = mutableMapOf<Int, Pair<Int, Int>>()
-    private val thumbnailCache = java.util.concurrent.ConcurrentHashMap<Int, String>()
-    private val pendingThumbnails = java.util.concurrent.ConcurrentHashMap.newKeySet<Int>()
-    private var currentLoadJob: Job? = null
+    private val pageDimensions = ConcurrentHashMap<Int, PageDimension>()
+    
+    // endregion
+    
+    // region Thumbnail Cache
+    
+    private val thumbnailCache = ConcurrentHashMap<String, ConcurrentHashMap<Int, String>>()
+    private val pendingThumbnails: MutableSet<Int> = ConcurrentHashMap.newKeySet()
+    
+    // endregion
+    
+    // region Document State
+    
+    @Volatile private var currentLoadJob: Job? = null
+    @Volatile private var documentHash: String? = null
+    
+    private val lifecycleObserver = LifecycleEventObserver { _, event ->
+        if (event == Lifecycle.Event.ON_STOP) {
+            cleanupAllThumbnails()
+        }
+    }
+    
+    private val prefs by lazy { 
+        context.getSharedPreferences("pdf_viewer_state", Context.MODE_PRIVATE) 
+    }
+    
+    // endregion
+    
+    // region Public Properties
     
-    // Props
     private var _sourceUri: String? = null
     var sourceUri: String?
         get() = _sourceUri
         set(value) {
             if (_sourceUri != value) {
                 _sourceUri = value
-                value?.let { loadDocument(it) }
+                value?.let(::loadDocument)
             }
         }
     
@@ -95,36 +164,24 @@ class PdfViewer(context: Context) : FrameLayout(context) {
             }
         }
     
-    // Note: horizontal and enablePaging are iOS-only features
-    // Android always uses vertical scroll
     var spacing: Float = 8f
     var enableZoom: Boolean = true
     var minScale: Float = 0.5f
     var maxScale: Float = 4.0f
     
-    // Content insets for glass UI / transparent bars
     var contentInsetTop: Float = 0f
-        set(value) {
-            field = value
-            updateContentInsets()
-        }
+        set(value) { field = value; updateContentInsets() }
     var contentInsetBottom: Float = 0f
-        set(value) {
-            field = value
-            updateContentInsets()
-        }
+        set(value) { field = value; updateContentInsets() }
     var contentInsetLeft: Float = 0f
-        set(value) {
-            field = value
-            updateContentInsets()
-        }
+        set(value) { field = value; updateContentInsets() }
     var contentInsetRight: Float = 0f
-        set(value) {
-            field = value
-            updateContentInsets()
-        }
+        set(value) { field = value; updateContentInsets() }
+    
+    // endregion
+    
+    // region Callbacks
     
-    // Callbacks for HybridPdfViewer integration
     var onLoadCompleteCallback: ((pageCount: Int, pageWidth: Int, pageHeight: Int) -> Unit)? = null
     var onPageChangeCallback: ((page: Int, pageCount: Int) -> Unit)? = null
     var onScaleChangeCallback: ((scale: Float) -> Unit)? = null
@@ -132,50 +189,37 @@ class PdfViewer(context: Context) : FrameLayout(context) {
     var onThumbnailGeneratedCallback: ((page: Int, uri: String) -> Unit)? = null
     var onLoadingChangeCallback: ((isLoading: Boolean) -> Unit)? = null
     
-    // Runtime state
-    private var currentScale = 1.0f
-    private var lastReportedPage = -1
-    private var isLoading = false
-    private var viewWidth = 0
+    // endregion
+    
+    // region Runtime State
+    
+    @Volatile private var currentScale = 1.0f
+    @Volatile private var lastReportedPage = -1
+    @Volatile private var isLoading = false
+    @Volatile private var viewWidth = 0
+    @Volatile private var needsInitialLayout = true
+    
+    // Zoom/Pan state
+    private var translateX = 0f
+    private var translateY = 0f
+    private var lastTouchX = 0f
+    private var lastTouchY = 0f
+    private var isPanning = false
+    private var activePointerId = MotionEvent.INVALID_POINTER_ID
+    
+    // endregion
+    
+    /** Simple data class for page dimensions */
+    private data class PageDimension(val width: Int, val height: Int)
     
     init {
-        recyclerView = RecyclerView(context).apply {
-            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-            setHasFixedSize(false)
-            setItemViewCacheSize(4)
-            recycledViewPool.setMaxRecycledViews(0, 12)
-            
-            // Allow parent to intercept touch events for pinch-to-zoom
-            requestDisallowInterceptTouchEvent(false)
-            
-            // Enable drawing content under padding (for glass UI effect)
-            clipToPadding = false
-        }
-        
-        loadingIndicator = ProgressBar(context).apply {
-            val size = (48 * context.resources.displayMetrics.density).toInt()
-            layoutParams = LayoutParams(size, size).apply {
-                gravity = android.view.Gravity.CENTER
-            }
-            isIndeterminate = true
-            visibility = View.GONE
-        }
+        ProcessLifecycleOwner.get().lifecycle.addObserver(lifecycleObserver)
         
+        recyclerView = createRecyclerView()
+        loadingIndicator = createLoadingIndicator()
         scaleGestureDetector = ScaleGestureDetector(context, ScaleListener())
         gestureDetector = GestureDetector(context, GestureListener())
-        
-        // Initialize bitmap cache (25% of available memory)
-        val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()
-        val cacheSize = (maxMemory * CACHE_SIZE_PERCENTAGE).toInt()
-        
-        bitmapCache = object : LruCache<String, Bitmap>(cacheSize) {
-            override fun sizeOf(key: String, bitmap: Bitmap): Int = bitmap.byteCount / 1024
-            
-            override fun entryRemoved(evicted: Boolean, key: String, oldValue: Bitmap?, newValue: Bitmap?) {
-                // CRITICAL: Don't recycle bitmaps - RecyclerView may still be using them
-                // Let GC handle cleanup. Only recycle on component unmount.
-            }
-        }
+        bitmapCache = createBitmapCache()
         
         setupRecyclerView()
         applySpacing()
@@ -183,7 +227,6 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         addView(recyclerView)
         addView(loadingIndicator)
         
-        // Measure view width for proper rendering
         doOnLayout {
             val newWidth = width
             if (newWidth > 0 && newWidth != viewWidth) {
@@ -193,32 +236,84 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
+    private fun createRecyclerView(): RecyclerView = RecyclerView(context).apply {
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        setHasFixedSize(false)
+        setItemViewCacheSize(VIEW_CACHE_SIZE)
+        recycledViewPool.setMaxRecycledViews(0, RECYCLED_VIEW_POOL_SIZE)
+        requestDisallowInterceptTouchEvent(false)
+        clipToPadding = false
+    }
+    
+    private fun createLoadingIndicator(): ProgressBar = ProgressBar(context).apply {
+        val size = (LOADING_INDICATOR_SIZE_DP * context.resources.displayMetrics.density).toInt()
+        layoutParams = LayoutParams(size, size).apply {
+            gravity = android.view.Gravity.CENTER
+        }
+        isIndeterminate = true
+        visibility = View.GONE
+    }
+    
+    private fun createBitmapCache(): LruCache<String, Bitmap> {
+        val maxMemoryKb = (Runtime.getRuntime().maxMemory() / 1024).toInt()
+        val cacheSize = (maxMemoryKb * CACHE_SIZE_PERCENTAGE).toInt()
+        
+        return object : LruCache<String, Bitmap>(cacheSize) {
+            override fun sizeOf(key: String, bitmap: Bitmap): Int = bitmap.byteCount / 1024
+        }
+    }
+    
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         super.onLayout(changed, left, top, right, bottom)
         
-        // Update viewWidth whenever layout changes
         val newWidth = right - left
         if (newWidth > 0 && newWidth != viewWidth) {
             viewWidth = newWidth
             post { adapter?.notifyDataSetChanged() }
         }
+        
+        if (needsInitialLayout && newWidth > 0 && bottom > 0 && pdfRenderer != null) {
+            needsInitialLayout = false
+            scheduleInitialLayout(newWidth, bottom - top)
+        }
     }
     
-    private fun applySpacing() {
-        // Add spacing between PDF pages
-        recyclerView.addItemDecoration(object : RecyclerView.ItemDecoration() {
-            override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView, state: RecyclerView.State) {
-                val position = parent.getChildAdapterPosition(view)
-                if (position != RecyclerView.NO_POSITION && position > 0) {
-                    outRect.top = spacing.toInt()
+    private fun scheduleInitialLayout(width: Int, height: Int) {
+        recyclerView.viewTreeObserver.addOnPreDrawListener(
+            object : android.view.ViewTreeObserver.OnPreDrawListener {
+                override fun onPreDraw(): Boolean {
+                    recyclerView.viewTreeObserver.removeOnPreDrawListener(this)
+                    recyclerView.measure(
+                        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+                        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+                    )
+                    recyclerView.layout(0, 0, width, height)
+                    preloadVisibleAndAdjacentPages()
+                    return true
                 }
             }
-        })
+        )
+    }
+    
+    private fun applySpacing() {
+        recyclerView.addItemDecoration(PageSpacingDecoration())
+    }
+    
+    private inner class PageSpacingDecoration : RecyclerView.ItemDecoration() {
+        override fun getItemOffsets(
+            outRect: Rect,
+            view: View,
+            parent: RecyclerView,
+            state: RecyclerView.State
+        ) {
+            val position = parent.getChildAdapterPosition(view)
+            if (position > 0) {
+                outRect.top = spacing.toInt()
+            }
+        }
     }
     
     private fun updateContentInsets() {
-        // Apply content insets as padding
-        // clipToPadding=false allows content to draw under padding (glass UI effect)
         recyclerView.setPadding(
             contentInsetLeft.toInt(),
             contentInsetTop.toInt(),
@@ -228,183 +323,204 @@ class PdfViewer(context: Context) : FrameLayout(context) {
     }
     
     private fun setupRecyclerView() {
-        // Android always uses vertical scroll (horizontal is iOS-only)
-        val layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
-        recyclerView.layoutManager = layoutManager
+        recyclerView.layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
+        recyclerView.addOnScrollListener(PageScrollListener())
+    }
+    
+    private inner class PageScrollListener : RecyclerView.OnScrollListener() {
+        private var scrollState = RecyclerView.SCROLL_STATE_IDLE
         
-        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
-            private var scrollState = RecyclerView.SCROLL_STATE_IDLE
+        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+            val layoutManager = recyclerView.layoutManager as? LinearLayoutManager ?: return
+            val firstVisible = layoutManager.findFirstVisibleItemPosition()
             
-            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
-                super.onScrolled(recyclerView, dx, dy)
-                
-                val layoutManager = recyclerView.layoutManager as? LinearLayoutManager ?: return
-                val firstVisible = layoutManager.findFirstVisibleItemPosition()
-                
-                if (firstVisible >= 0 && firstVisible != lastReportedPage) {
-                    lastReportedPage = firstVisible
-                    emitPageChange(firstVisible)
-                }
-                
-                if (scrollState == RecyclerView.SCROLL_STATE_IDLE) {
-                    schedulePreload()
-                }
+            if (firstVisible >= 0 && firstVisible != lastReportedPage) {
+                lastReportedPage = firstVisible
+                emitPageChange(firstVisible)
+                persistCurrentPage(firstVisible)
             }
             
-            override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
-                super.onScrollStateChanged(recyclerView, newState)
-                scrollState = newState
-                
-                if (newState == RecyclerView.SCROLL_STATE_IDLE) {
-                    schedulePreload()
-                }
+            if (scrollState == RecyclerView.SCROLL_STATE_IDLE) {
+                schedulePreload()
             }
-        })
+        }
+        
+        override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
+            scrollState = newState
+            if (newState == RecyclerView.SCROLL_STATE_IDLE) {
+                schedulePreload()
+            }
+        }
     }
     
+    private fun persistCurrentPage(page: Int) {
+        documentHash?.let { hash ->
+            prefs.edit().putInt("page_$hash", page).apply()
+        }
+    }
+    
+    // region Touch Handling
+    
     override fun onTouchEvent(event: MotionEvent): Boolean {
-        var handled = false
+        if (!enableZoom) {
+            return recyclerView.onTouchEvent(event)
+        }
         
-        if (enableZoom) {
-            // Try double-tap first (gestureDetector)
-            gestureDetector.onTouchEvent(event)
-            
-            // Then try scale gesture detector
-            scaleGestureDetector.onTouchEvent(event)
-            handled = scaleGestureDetector.isInProgress
-            isScaling = scaleGestureDetector.isInProgress
-            
-            if (isScaling) {
-                // During scaling, request not to be intercepted
-                parent?.requestDisallowInterceptTouchEvent(true)
-                recyclerView.requestDisallowInterceptTouchEvent(true)
+        // Always let scale detector examine events
+        scaleGestureDetector.onTouchEvent(event)
+        gestureDetector.onTouchEvent(event)
+        
+        if (scaleGestureDetector.isInProgress) {
+            isScaling = true
+            isPanning = false
+            return true
+        }
+        
+        // Handle panning when zoomed in
+        if (currentScale > 1.0f) {
+            when (event.actionMasked) {
+                MotionEvent.ACTION_DOWN -> {
+                    activePointerId = event.getPointerId(0)
+                    lastTouchX = event.x
+                    lastTouchY = event.y
+                    isPanning = true
+                    parent?.requestDisallowInterceptTouchEvent(true)
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    if (isPanning && !isScaling) {
+                        val pointerIndex = event.findPointerIndex(activePointerId)
+                        if (pointerIndex >= 0) {
+                            val x = event.getX(pointerIndex)
+                            val y = event.getY(pointerIndex)
+                            
+                            val dx = x - lastTouchX
+                            val dy = y - lastTouchY
+                            
+                            applyTranslation(dx, dy)
+                            
+                            lastTouchX = x
+                            lastTouchY = y
+                        }
+                    }
+                }
+                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                    isPanning = false
+                    isScaling = false
+                    activePointerId = MotionEvent.INVALID_POINTER_ID
+                    parent?.requestDisallowInterceptTouchEvent(false)
+                }
+                MotionEvent.ACTION_POINTER_UP -> {
+                    val pointerIndex = event.actionIndex
+                    val pointerId = event.getPointerId(pointerIndex)
+                    if (pointerId == activePointerId) {
+                        val newPointerIndex = if (pointerIndex == 0) 1 else 0
+                        if (newPointerIndex < event.pointerCount) {
+                            lastTouchX = event.getX(newPointerIndex)
+                            lastTouchY = event.getY(newPointerIndex)
+                            activePointerId = event.getPointerId(newPointerIndex)
+                        }
+                    }
+                }
             }
+            return true
         }
         
+        // At scale 1.0, let RecyclerView handle scrolling
         if (event.action == MotionEvent.ACTION_UP || event.action == MotionEvent.ACTION_CANCEL) {
             isScaling = false
-            parent?.requestDisallowInterceptTouchEvent(false)
-            recyclerView.requestDisallowInterceptTouchEvent(false)
-        }
-        
-        // Pass to children if not scaling
-        if (!handled) {
-            handled = recyclerView.onTouchEvent(event)
+            isPanning = false
         }
         
-        return handled || super.onTouchEvent(event)
+        return recyclerView.onTouchEvent(event)
     }
     
     override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
-        // Check for pinch gesture
-        if (enableZoom) {
-            scaleGestureDetector.onTouchEvent(event)
-            if (scaleGestureDetector.isInProgress) {
-                return true
-            }
+        if (!enableZoom) return false
+        
+        scaleGestureDetector.onTouchEvent(event)
+        
+        // Intercept if scaling or zoomed in (to handle panning)
+        if (scaleGestureDetector.isInProgress) return true
+        if (currentScale > 1.0f && event.pointerCount == 1) return true
+        
+        return false
+    }
+    
+    private fun applyTranslation(dx: Float, dy: Float) {
+        // Calculate bounds for panning
+        val scaledWidth = width * currentScale
+        val scaledHeight = recyclerView.computeVerticalScrollRange() * currentScale
+        
+        val maxTranslateX = (scaledWidth - width) / 2f
+        val maxTranslateY = (scaledHeight - height) / 2f
+        
+        translateX = (translateX + dx).coerceIn(-maxTranslateX, maxTranslateX)
+        translateY = (translateY + dy).coerceIn(-maxTranslateY, maxTranslateY)
+        
+        recyclerView.translationX = translateX
+        recyclerView.translationY = translateY
+    }
+    
+    private fun applyZoomTransform(focusX: Float, focusY: Float) {
+        recyclerView.pivotX = focusX
+        recyclerView.pivotY = focusY
+        recyclerView.scaleX = currentScale
+        recyclerView.scaleY = currentScale
+        
+        // Constrain translation after scale change
+        if (currentScale <= 1.0f) {
+            translateX = 0f
+            translateY = 0f
+            recyclerView.translationX = 0f
+            recyclerView.translationY = 0f
+        } else {
+            applyTranslation(0f, 0f)
         }
-        return super.onInterceptTouchEvent(event)
     }
     
+    private fun resetZoomTransform() {
+        currentScale = 1.0f
+        translateX = 0f
+        translateY = 0f
+        recyclerView.scaleX = 1.0f
+        recyclerView.scaleY = 1.0f
+        recyclerView.translationX = 0f
+        recyclerView.translationY = 0f
+        recyclerView.pivotX = width / 2f
+        recyclerView.pivotY = height / 2f
+    }
+    
+    // endregion
+    
+    // region Document Loading
+    
     fun loadDocument(uri: String?) {
-        if (BuildConfig.DEBUG) {
-            Log.d(TAG, "loadDocument called with uri: $uri")
-        }
+        if (BuildConfig.DEBUG) Log.d(TAG, "loadDocument: $uri")
+        
         if (uri.isNullOrBlank()) {
             Log.e(TAG, "URI is null or blank")
             emitError("URI cannot be empty", "INVALID_URI")
             return
         }
         
-        // Cancel previous load if in progress
-        if (isLoading) {
-            if (BuildConfig.DEBUG) {
-                Log.w(TAG, "Canceling previous document load")
-            }
-            currentLoadJob?.cancel()
-            currentLoadJob = null
-        }
-        
+        currentLoadJob?.cancel()
         isLoading = true
         setLoadingState(true)
         showLoading(true)
         cancelAllRenderJobs()
-        
-        // Clear cache without recycling (GC will handle it)
         bitmapCache.evictAll()
         
         currentLoadJob = componentScope.launch(Dispatchers.IO) {
             try {
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "Starting document download/load for uri: $uri")
-                }
                 val file = downloadOrGetFile(uri)
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "File obtained: ${file.absolutePath}, exists: ${file.exists()}, canRead: ${file.canRead()}")
-                }
-                
                 require(file.exists()) { "File does not exist: ${file.absolutePath}" }
                 require(file.canRead()) { "Cannot read file: ${file.absolutePath}" }
                 
                 val fd = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
                 val renderer = PdfRenderer(fd)
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "PdfRenderer created successfully, pageCount: ${renderer.pageCount}")
-                }
-                
                 require(renderer.pageCount > 0) { "PDF has no pages" }
                 
-                withContext(Dispatchers.Main) {
-                    closePdfRenderer()
-                    
-                    pdfRenderer = renderer
-                    parcelFileDescriptor = fd
-                    bitmapCache.evictAll()
-                    pageDimensions.clear()
-                    thumbnailCache.clear()
-                    pendingThumbnails.clear()
-                    lastReportedPage = -1
-                    
-                    // Get first page dimensions immediately for initial render
-                    val firstDim = try {
-                        renderMutex.withLock {
-                            renderer.openPage(0).use { page ->
-                                Pair(page.width, page.height).also {
-                                    pageDimensions[0] = it
-                                }
-                            }
-                        }
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error reading first page", e)
-                        Pair(612, 792)
-                    }
-                    
-                    // Preload a few more page dimensions in background (non-blocking)
-                    // This helps with initial scrolling but doesn't delay the initial render
-                    componentScope.launch(Dispatchers.IO) {
-                        preloadInitialPageDimensions(renderer)
-                    }
-                    
-                    adapter = PdfPageAdapter()
-                    recyclerView.adapter = adapter
-                    
-                    showLoading(false)
-                    setLoadingState(false)
-                    
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Emitting loadComplete: pageCount=${renderer.pageCount}, width=${firstDim.first}, height=${firstDim.second}")
-                    }
-                    emitLoadComplete(renderer.pageCount, firstDim.first, firstDim.second)
-                    
-                    // Force initial layout and render by scrolling slightly
-                    // This ensures content appears without requiring user interaction
-                    post {
-                        recyclerView.scrollBy(0, 2)
-                        recyclerView.scrollBy(0, -2)
-                    }
-                    
-                    schedulePreload()
-                }
+                initializeDocument(renderer, fd)
             } catch (e: SecurityException) {
                 handleLoadError("PDF is password protected or encrypted", "SECURITY_ERROR", e)
             } catch (e: java.io.FileNotFoundException) {
@@ -421,6 +537,80 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
+    private suspend fun initializeDocument(renderer: PdfRenderer, fd: ParcelFileDescriptor) {
+        val firstDim = loadFirstPageDimensions(renderer)
+        
+        componentScope.launch(Dispatchers.IO) {
+            preloadInitialPageDimensions(renderer)
+        }
+        
+        withContext(Dispatchers.Main) {
+            closePdfRenderer()
+            
+            pdfRenderer = renderer
+            parcelFileDescriptor = fd
+            documentHash = computeDocumentHash()
+            
+            resetDocumentState()
+            
+            adapter = PdfPageAdapter()
+            recyclerView.adapter = adapter
+            
+            showLoading(false)
+            setLoadingState(false)
+            
+            emitLoadComplete(renderer.pageCount, firstDim.width, firstDim.height)
+            restoreLastViewedPage(renderer)
+        }
+    }
+    
+    private suspend fun loadFirstPageDimensions(renderer: PdfRenderer): PageDimension {
+        return try {
+            renderMutex.withLock {
+                renderer.openPage(0).use { page ->
+                    PageDimension(page.width, page.height).also {
+                        pageDimensions[0] = it
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error reading first page", e)
+            PageDimension(DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT)
+        }
+    }
+    
+    private fun resetDocumentState() {
+        bitmapCache.evictAll()
+        pageDimensions.clear()
+        pendingThumbnails.clear()
+        lastReportedPage = -1
+    }
+    
+    private fun restoreLastViewedPage(renderer: PdfRenderer) {
+        post {
+            val lastPage = documentHash?.let { prefs.getInt("page_$it", 0) } ?: 0
+            
+            Choreographer.getInstance().postFrameCallback {
+                if (lastPage > 0 && lastPage < renderer.pageCount) {
+                    recyclerView.scrollToPosition(lastPage)
+                    lastReportedPage = lastPage
+                    emitPageChange(lastPage)
+                } else {
+                    lastReportedPage = 0
+                    emitPageChange(0)
+                    preloadInitialPages()
+                }
+            }
+        }
+    }
+    
+    private fun preloadInitialPages() {
+        val pageCount = pdfRenderer?.pageCount ?: return
+        repeat(minOf(PRELOAD_RANGE + 1, pageCount)) { i ->
+            startPageRender(i)
+        }
+    }
+    
     private suspend fun handleLoadError(message: String, code: String, error: Exception) {
         Log.e(TAG, message, error)
         withContext(Dispatchers.Main) {
@@ -430,58 +620,45 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
-    // Preload only first few pages (non-blocking) for better initial experience
     private suspend fun preloadInitialPageDimensions(renderer: PdfRenderer) {
-        // Preload first 5-10 pages to improve initial scrolling
-        val pagesToPreload = minOf(10, renderer.pageCount)
-        for (i in 1 until pagesToPreload) { // Start from 1 since 0 is already loaded
-            try {
-                kotlinx.coroutines.delay(50) // Small delay to not block other operations
-                renderMutex.withLock {
-                    if (pageDimensions[i] == null) { // Only if not already loaded
-                        renderer.openPage(i).use { page ->
-                            pageDimensions[i] = Pair(page.width, page.height)
-                        }
-                    }
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Error preloading page $i dimensions", e)
-            }
+        val pagesToPreload = minOf(INITIAL_PRELOAD_COUNT, renderer.pageCount)
+        
+        // Preload first batch with short delay
+        for (i in 1 until pagesToPreload) {
+            loadPageDimensionIfMissing(renderer, i, INITIAL_PRELOAD_DELAY_MS)
         }
         
-        // Lazily load remaining pages with lower priority
-        if (renderer.pageCount > pagesToPreload) {
-            for (i in pagesToPreload until renderer.pageCount) {
-                try {
-                    kotlinx.coroutines.delay(100) // Longer delay for non-critical pages
-                    renderMutex.withLock {
-                        if (pageDimensions[i] == null) {
-                            renderer.openPage(i).use { page ->
-                                pageDimensions[i] = Pair(page.width, page.height)
-                            }
-                        }
+        // Lazily load remaining pages with longer delay
+        for (i in pagesToPreload until renderer.pageCount) {
+            loadPageDimensionIfMissing(renderer, i, LAZY_PRELOAD_DELAY_MS)
+        }
+    }
+    
+    private suspend fun loadPageDimensionIfMissing(renderer: PdfRenderer, index: Int, delayMs: Long) {
+        try {
+            delay(delayMs)
+            renderMutex.withLock {
+                if (pageDimensions[index] == null) {
+                    renderer.openPage(index).use { page ->
+                        pageDimensions[index] = PageDimension(page.width, page.height)
                     }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error preloading page $i dimensions", e)
                 }
             }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error preloading page $index dimensions", e)
         }
     }
     
-    // Get page dimensions on-demand if not already cached
-    private suspend fun getPageDimensions(pageIndex: Int): Pair<Int, Int> {
-        // Return cached if available
+    private suspend fun getPageDimensions(pageIndex: Int): PageDimension {
         pageDimensions[pageIndex]?.let { return it }
         
-        // Load on-demand
-        val renderer = pdfRenderer ?: return Pair(612, 792) // Standard page size fallback
+        val renderer = pdfRenderer ?: return PageDimension(DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT)
         
         return try {
             renderMutex.withLock {
-                // Check again inside lock in case another thread loaded it
                 pageDimensions[pageIndex] ?: run {
                     renderer.openPage(pageIndex).use { page ->
-                        Pair(page.width, page.height).also {
+                        PageDimension(page.width, page.height).also {
                             pageDimensions[pageIndex] = it
                         }
                     }
@@ -489,26 +666,88 @@ class PdfViewer(context: Context) : FrameLayout(context) {
             }
         } catch (e: Exception) {
             Log.e(TAG, "Error loading page $pageIndex dimensions", e)
-            Pair(612, 792) // Fallback
+            PageDimension(DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT)
         }
     }
     
+    // endregion
+    
+    // region File Handling
+    
     private fun closePdfRenderer() {
-        try {
-            pdfRenderer?.close()
-        } catch (e: Exception) {
-            Log.e(TAG, "Error closing renderer", e)
-        }
+        runCatching { pdfRenderer?.close() }
+            .onFailure { Log.e(TAG, "Error closing renderer", it) }
         pdfRenderer = null
         
+        runCatching { parcelFileDescriptor?.close() }
+            .onFailure { Log.e(TAG, "Error closing file descriptor", it) }
+        parcelFileDescriptor = null
+    }
+    
+    private suspend fun downloadOrGetFile(uri: String): File = withContext(Dispatchers.IO) {
+        when {
+            uri.startsWith("file://") -> File(uri.removePrefix("file://"))
+            uri.startsWith("http://") || uri.startsWith("https://") -> downloadPdf(uri)
+            else -> File(uri)
+        }
+    }
+    
+    private fun downloadPdf(uri: String): File {
+        val hash = uri.hashCode().toString()
+        val file = File(context.cacheDir, "pdf_$hash.pdf")
+        val tempFile = File(context.cacheDir, "pdf_${hash}_temp.pdf")
+        
+        if (file.exists() && isCacheValid(file)) {
+            if (BuildConfig.DEBUG) Log.d(TAG, "Using cached PDF: ${file.absolutePath}")
+            return file
+        }
+        
         try {
-            parcelFileDescriptor?.close()
+            val connection = URL(uri).openConnection().apply {
+                connectTimeout = CONNECT_TIMEOUT_MS
+                readTimeout = READ_TIMEOUT_MS
+                setRequestProperty("Accept", "application/pdf")
+                addConditionalHeaders(file)
+            }
+            
+            connection.getInputStream().use { input ->
+                FileOutputStream(tempFile).use { output ->
+                    input.copyTo(output, bufferSize = 8192)
+                }
+            }
+            
+            file.delete()
+            tempFile.renameTo(file)
+            
+            if (BuildConfig.DEBUG) Log.d(TAG, "Download completed: ${file.absolutePath}")
         } catch (e: Exception) {
-            Log.e(TAG, "Error closing file descriptor", e)
+            tempFile.delete()
+            if (file.exists()) {
+                Log.w(TAG, "Download failed, using cached version: ${e.message}")
+                return file
+            }
+            throw e
+        }
+        
+        return file
+    }
+    
+    private fun isCacheValid(file: File): Boolean =
+        System.currentTimeMillis() - file.lastModified() < CACHE_VALIDITY_MS
+    
+    private fun java.net.URLConnection.addConditionalHeaders(cachedFile: File) {
+        if (cachedFile.exists()) {
+            val dateFormat = SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US).apply {
+                timeZone = TimeZone.getTimeZone("GMT")
+            }
+            setRequestProperty("If-Modified-Since", dateFormat.format(Date(cachedFile.lastModified())))
         }
-        parcelFileDescriptor = null
     }
     
+    // endregion
+    
+    // region Loading State
+    
     private fun showLoading(show: Boolean) {
         loadingIndicator.visibility = if (show && showsActivityIndicator) View.VISIBLE else View.GONE
         recyclerView.visibility = if (show) View.INVISIBLE else View.VISIBLE
@@ -532,204 +771,109 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
-    private suspend fun downloadOrGetFile(uri: String): File = withContext(Dispatchers.IO) {
-        when {
-            uri.startsWith("file://") -> File(uri.substring(7))
-            uri.startsWith("http://") || uri.startsWith("https://") -> {
-                val hash = uri.hashCode().toString()
-                val file = File(context.cacheDir, "pdf_$hash.pdf")
-                val tempFile = File(context.cacheDir, "pdf_${hash}_temp.pdf")
-                
-                // Check if cached file exists and is reasonably fresh (< 1 hour)
-                if (file.exists() && (System.currentTimeMillis() - file.lastModified() < 3600_000)) {
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Using cached PDF file: ${file.absolutePath}")
-                    }
-                    return@withContext file
-                }
-                
-                // Download with better error handling and progress
-                try {
-                    val url = URL(uri)
-                    val connection = url.openConnection().apply {
-                        connectTimeout = 30_000 // 30 seconds
-                        readTimeout = 60_000   // 60 seconds
-                        setRequestProperty("Accept", "application/pdf")
-                        
-                        // Add cache headers for better HTTP caching
-                        if (file.exists()) {
-                            setRequestProperty("If-Modified-Since", 
-                                java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", java.util.Locale.US)
-                                    .apply { timeZone = java.util.TimeZone.getTimeZone("GMT") }
-                                    .format(java.util.Date(file.lastModified())))
-                        }
-                    }
-                    
-                    val contentLength = connection.contentLength
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Downloading PDF: $uri, size: $contentLength bytes")
-                    }
-                    
-                    connection.getInputStream().use { input ->
-                        FileOutputStream(tempFile).use { output ->
-                            val buffer = ByteArray(8192)
-                            var bytesRead: Int
-                            var totalRead = 0
-                            
-                            while (input.read(buffer).also { bytesRead = it } != -1) {
-                                output.write(buffer, 0, bytesRead)
-                                totalRead += bytesRead
-                                
-                                // Log progress for large files
-                                if (BuildConfig.DEBUG && contentLength > 0 && totalRead % (contentLength / 10 + 1) == 0) {
-                                    val progress = (totalRead * 100) / contentLength
-                                    Log.d(TAG, "Download progress: $progress%")
-                                }
-                            }
-                            
-                            output.flush()
-                        }
-                    }
-                    
-                    // Move temp file to final location
-                    if (tempFile.exists()) {
-                        file.delete() // Remove old cached file
-                        tempFile.renameTo(file)
-                    }
-                    
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Download completed: ${file.absolutePath}")
-                    }
-                } catch (e: Exception) {
-                    // Clean up temp file on error
-                    tempFile.delete()
-                    
-                    // If download failed but we have an old cached version, use it
-                    if (file.exists()) {
-                        Log.w(TAG, "Download failed, using cached version: ${e.message}")
-                        return@withContext file
-                    }
-                    
-                    throw e
-                }
-                
-                file
-            }
-            else -> File(uri)
-        }
-    }
+    // endregion
+    
+    // region Public API
     
     fun goToPage(page: Int) {
-        val renderer = pdfRenderer ?: run {
-            emitError("PDF not loaded", "NOT_LOADED")
-            return
-        }
+        val renderer = pdfRenderer ?: return emitError("PDF not loaded", "NOT_LOADED")
+        
         if (page !in 0 until renderer.pageCount) {
             emitError("Invalid page: $page. Valid range: 0-${renderer.pageCount - 1}", "INVALID_PAGE")
             return
         }
         
-        if (BuildConfig.DEBUG) {
-            Log.d(TAG, "goToPage called: $page")
+        if (BuildConfig.DEBUG) Log.d(TAG, "goToPage: $page")
+        
+        // Reset zoom when navigating to a page
+        if (currentScale != 1.0f) {
+            resetZoomTransform()
+            emitScaleChange(1.0f)
         }
         
         post {
-            // Use smoothScrollToPosition for animated scroll
             recyclerView.smoothScrollToPosition(page)
-            
-            // Emit page change event for UI sync
             emitPageChange(page)
-            
             postDelayed({ schedulePreload() }, 100)
         }
     }
     
     fun setScale(scale: Float) {
-        if (!enableZoom) {
-            emitError("Zoom is disabled", "ZOOM_DISABLED")
-            return
-        }
+        setScale(scale, width / 2f, height / 2f)
+    }
+    
+    private fun setScale(scale: Float, focusX: Float, focusY: Float) {
+        if (!enableZoom) return emitError("Zoom is disabled", "ZOOM_DISABLED")
         
         val clampedScale = scale.coerceIn(minScale, maxScale)
-        if ((clampedScale - currentScale).let { it < 0.01f && it > -0.01f }) return
+        if (kotlin.math.abs(clampedScale - currentScale) < 0.01f) return
         
-        if (BuildConfig.DEBUG) {
-            Log.d(TAG, "setScale: $clampedScale (was $currentScale)")
-        }
-        currentScale = clampedScale
-        
-        // Clear cache but DON'T recycle bitmaps (RecyclerView may still be drawing them)
-        bitmapCache.evictAll()
+        if (BuildConfig.DEBUG) Log.d(TAG, "setScale: $clampedScale (was $currentScale)")
         
-        // Update adapter to refresh all views
-        adapter?.notifyDataSetChanged()
+        currentScale = clampedScale
+        applyZoomTransform(focusX, focusY)
         emitScaleChange(currentScale)
+    }
+    
+    fun getDocumentInfo(): Map<String, Any>? {
+        val renderer = pdfRenderer ?: return null
+        if (renderer.pageCount == 0) return null
         
-        // Force immediate render of visible pages
-        post {
-            val layoutManager = recyclerView.layoutManager as? LinearLayoutManager
-            val firstVisible = layoutManager?.findFirstVisibleItemPosition() ?: 0
-            val lastVisible = layoutManager?.findLastVisibleItemPosition() ?: 0
-            
-            for (i in firstVisible..lastVisible) {
-                startPageRender(i)
-            }
-            
-            // Preload adjacent pages after a delay
-            postDelayed({ schedulePreload() }, 150)
-        }
+        val page = renderer.openPage(0)
+        val info: Map<String, Any> = mapOf(
+            "pageCount" to renderer.pageCount,
+            "pageWidth" to page.width,
+            "pageHeight" to page.height,
+            "currentPage" to ((recyclerView.layoutManager as? LinearLayoutManager)
+                ?.findFirstVisibleItemPosition() ?: 0)
+        )
+        page.close()
+        
+        return info
     }
     
+    // endregion
+    
+    // region Thumbnail Generation
+    
     fun generateThumbnail(page: Int) {
-        if (BuildConfig.DEBUG) {
-            Log.d(TAG, "generateThumbnail called for page: $page")
-        }
-        val renderer = pdfRenderer ?: run {
-            emitError("PDF not loaded", "NOT_LOADED")
-            return
-        }
+        if (BuildConfig.DEBUG) Log.d(TAG, "generateThumbnail: $page")
+        
+        val renderer = pdfRenderer ?: return emitError("PDF not loaded", "NOT_LOADED")
+        
         if (page !in 0 until renderer.pageCount) {
             emitError("Invalid page: $page. Valid range: 0-${renderer.pageCount - 1}", "INVALID_PAGE")
             return
         }
         
-        // Check cache first
-        thumbnailCache[page]?.let { cachedUri ->
-            if (BuildConfig.DEBUG) {
-                Log.d(TAG, "Thumbnail for page $page found in cache: $cachedUri")
-            }
+        val hash = documentHash ?: return emitError("Document hash not available", "HASH_ERROR")
+        
+        // Check memory cache
+        thumbnailCache[hash]?.get(page)?.let { cachedUri ->
             emitThumbnailGenerated(page, cachedUri)
             return
         }
         
-        // Check if already being generated (thread-safe)
-        if (!pendingThumbnails.add(page)) {
-            if (BuildConfig.DEBUG) {
-                Log.d(TAG, "Thumbnail for page $page already being generated")
-            }
+        // Check disk cache
+        val diskPath = getThumbnailPath(hash, page)
+        if (File(diskPath).exists()) {
+            val uri = "file://$diskPath"
+            thumbnailCache.getOrPut(hash) { ConcurrentHashMap() }[page] = uri
+            emitThumbnailGenerated(page, uri)
             return
         }
         
+        // Skip if already being generated
+        if (!pendingThumbnails.add(page)) return
+        
         componentScope.launch(Dispatchers.IO) {
             try {
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "Starting thumbnail generation for page $page")
-                }
                 val thumbnail = renderThumbnail(page)
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "Thumbnail bitmap created: ${thumbnail.width}x${thumbnail.height}")
-                }
-                val uri = saveThumbnailToCache(thumbnail, page)
-                if (BuildConfig.DEBUG) {
-                    Log.d(TAG, "Thumbnail saved to: $uri")
-                }
+                val uri = saveThumbnailToCache(thumbnail, page, hash)
                 
-                thumbnailCache[page] = uri
+                thumbnailCache.getOrPut(hash) { ConcurrentHashMap() }[page] = uri
                 
                 withContext(Dispatchers.Main) {
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Emitting thumbnail generated event for page $page")
-                    }
                     emitThumbnailGenerated(page, uri)
                 }
             } catch (e: Exception) {
@@ -745,49 +889,109 @@ class PdfViewer(context: Context) : FrameLayout(context) {
     
     fun generateAllThumbnails() {
         val renderer = pdfRenderer ?: return
+        val hash = documentHash ?: return
         
         componentScope.launch(Dispatchers.IO) {
             for (i in 0 until renderer.pageCount) {
-                // Check cache first
-                val cachedUri = thumbnailCache[i]
-                if (cachedUri != null) {
-                    withContext(Dispatchers.Main) {
-                        emitThumbnailGenerated(i, cachedUri)
-                    }
-                    continue
-                }
-                
-                // Skip if already being generated
-                if (!pendingThumbnails.add(i)) {
-                    continue
-                }
+                generateThumbnailForPage(i, hash)
+                delay(50)
+            }
+        }
+    }
+    
+    private suspend fun generateThumbnailForPage(page: Int, hash: String) {
+        // Check memory cache
+        thumbnailCache[hash]?.get(page)?.let { cachedUri ->
+            withContext(Dispatchers.Main) { emitThumbnailGenerated(page, cachedUri) }
+            return
+        }
+        
+        // Check disk cache
+        val diskPath = getThumbnailPath(hash, page)
+        if (File(diskPath).exists()) {
+            val uri = "file://$diskPath"
+            thumbnailCache.getOrPut(hash) { ConcurrentHashMap() }[page] = uri
+            withContext(Dispatchers.Main) { emitThumbnailGenerated(page, uri) }
+            return
+        }
+        
+        if (!pendingThumbnails.add(page)) return
+        
+        try {
+            val thumbnail = renderThumbnail(page)
+            val uri = saveThumbnailToCache(thumbnail, page, hash)
+            
+            thumbnailCache.getOrPut(hash) { ConcurrentHashMap() }[page] = uri
+            withContext(Dispatchers.Main) { emitThumbnailGenerated(page, uri) }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error generating thumbnail for page $page", e)
+            withContext(Dispatchers.Main) {
+                emitError("Thumbnail $page failed: ${e.message}", "THUMBNAIL_ERROR")
+            }
+        } finally {
+            pendingThumbnails.remove(page)
+        }
+    }
+    
+    private suspend fun renderThumbnail(pageIndex: Int): Bitmap = withContext(Dispatchers.IO) {
+        val renderer = pdfRenderer ?: throw IllegalStateException("No renderer")
+        
+        renderMutex.withLock {
+            renderer.openPage(pageIndex).use { page ->
+                val aspectRatio = page.height.toFloat() / page.width.toFloat()
+                val thumbWidth = THUMBNAIL_SIZE
+                val thumbHeight = (THUMBNAIL_SIZE * aspectRatio).roundToInt()
                 
-                try {
-                    val thumbnail = renderThumbnail(i)
-                    val uri = saveThumbnailToCache(thumbnail, i)
-                    
-                    thumbnailCache[i] = uri
-                    
-                    withContext(Dispatchers.Main) {
-                        emitThumbnailGenerated(i, uri)
-                    }
-                    
-                    // Small delay to avoid overwhelming the system
-                    kotlinx.coroutines.delay(50)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error generating thumbnail for page $i", e)
-                    withContext(Dispatchers.Main) {
-                        emitError("Thumbnail $i failed: ${e.message}", "THUMBNAIL_ERROR")
-                    }
-                } finally {
-                    pendingThumbnails.remove(i)
+                Bitmap.createBitmap(thumbWidth, thumbHeight, Bitmap.Config.ARGB_8888).apply {
+                    Canvas(this).drawColor(Color.WHITE)
+                    page.render(this, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
                 }
             }
         }
     }
     
+    private fun saveThumbnailToCache(bitmap: Bitmap, page: Int, hash: String): String {
+        val hashDir = File(context.cacheDir, "PDFThumbnails/$hash").apply { mkdirs() }
+        val file = File(hashDir, "thumb_$page.jpg")
+        
+        FileOutputStream(file).use { out ->
+            bitmap.compress(Bitmap.CompressFormat.JPEG, THUMBNAIL_QUALITY, out)
+        }
+        
+        if (!bitmap.isRecycled) bitmap.recycle()
+        
+        return "file://${file.absolutePath}"
+    }
+    
+    private fun getThumbnailPath(hash: String, page: Int): String =
+        "${context.cacheDir}/PDFThumbnails/$hash/thumb_$page.jpg"
+    
+    private fun computeDocumentHash(): String {
+        val uri = sourceUri ?: return "unknown"
+        return try {
+            MessageDigest.getInstance("MD5")
+                .digest(uri.toByteArray())
+                .joinToString("") { "%02x".format(it) }
+                .take(8)
+        } catch (e: Exception) {
+            "unknown"
+        }
+    }
+    
+    private fun cleanupAllThumbnails() {
+        runCatching {
+            File(context.cacheDir, "PDFThumbnails").deleteRecursively()
+            Log.d(TAG, "Cleaned up all thumbnail cache directories")
+        }.onFailure {
+            Log.e(TAG, "Error cleaning up thumbnail directories", it)
+        }
+    }
+    
+    // endregion
+    
+    // region Page Rendering
+    
     private fun schedulePreload() {
-        // Use Choreographer to schedule on next frame
         Choreographer.getInstance().postFrameCallback {
             preloadVisibleAndAdjacentPages()
         }
@@ -805,8 +1009,7 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         val endPage = (lastVisible + PRELOAD_RANGE).coerceAtMost(pageCount - 1)
         
         for (i in startPage..endPage) {
-            val cacheKey = "$i-${currentScale.toString().take(4)}"
-            if (bitmapCache.get(cacheKey) == null) {
+            if (bitmapCache.get("$i") == null) {
                 startPageRender(i)
             }
         }
@@ -818,9 +1021,8 @@ class PdfViewer(context: Context) : FrameLayout(context) {
             
             val job = componentScope.launch(Dispatchers.IO) {
                 try {
-                    val bitmap = renderPage(pageIndex)
-                    if (bitmap != null) {
-                        val cacheKey = "$pageIndex-${currentScale.toString().take(4)}"
+                    renderPage(pageIndex)?.let { bitmap ->
+                        val cacheKey = "$pageIndex"
                         bitmapCache.put(cacheKey, bitmap)
                         
                         withContext(Dispatchers.Main) {
@@ -847,71 +1049,18 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         try {
             renderMutex.withLock {
                 renderer.openPage(pageIndex).use { page ->
-                    // Calculate base scale to fit page to view width
-                    val baseScale = viewWidth.toFloat() / page.width
-                    
-                    // Dynamic quality scaling: reduce quality at higher zoom levels
-                    // This prevents exponential bitmap growth and OOM errors
-                    val renderQuality = when {
-                        currentScale <= 1.0f -> BASE_RENDER_QUALITY // Normal zoom: 1.5x quality
-                        currentScale <= HIGH_ZOOM_THRESHOLD -> 1.2f  // Slight zoom: 1.2x quality
-                        currentScale <= 2.0f -> 1.0f                 // Medium zoom: 1.0x quality
-                        currentScale <= 3.0f -> 0.85f                // High zoom: 0.85x quality
-                        else -> kotlin.math.max(0.7f, 2.5f / currentScale) // Very high zoom: inverse scaling
-                    }
+                    val (bitmapWidth, bitmapHeight) = calculateBitmapDimensions(page)
                     
-                    // Calculate final scale with dynamic quality
-                    val totalScale = baseScale * currentScale * renderQuality
-                    var bitmapWidth = (page.width * totalScale).toInt().coerceAtLeast(1)
-                    var bitmapHeight = (page.height * totalScale).toInt().coerceAtLeast(1)
+                    logBitmapStats(pageIndex, bitmapWidth, bitmapHeight)
                     
-                    // Enforce maximum bitmap dimensions to prevent GPU texture limits
-                    // Most Android devices support 4096x4096, some up to 8192x8192
-                    if (bitmapWidth > MAX_BITMAP_DIMENSION || bitmapHeight > MAX_BITMAP_DIMENSION) {
-                        val aspectRatio = page.width.toFloat() / page.height.toFloat()
-                        if (bitmapWidth > bitmapHeight) {
-                            bitmapWidth = MAX_BITMAP_DIMENSION
-                            bitmapHeight = (MAX_BITMAP_DIMENSION / aspectRatio).toInt()
-                        } else {
-                            bitmapHeight = MAX_BITMAP_DIMENSION
-                            bitmapWidth = (MAX_BITMAP_DIMENSION * aspectRatio).toInt()
-                        }
-                        if (BuildConfig.DEBUG) {
-                            Log.w(TAG, "Page $pageIndex bitmap capped to ${bitmapWidth}x${bitmapHeight} (scale: $currentScale, quality: $renderQuality)")
-                        }
+                    Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888).apply {
+                        Canvas(this).drawColor(Color.WHITE)
+                        page.render(this, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
                     }
-                    
-                    // Calculate approximate memory usage
-                    val estimatedMemoryMB = (bitmapWidth * bitmapHeight * 4) / (1024 * 1024)
-                    if (estimatedMemoryMB > 50) {
-                        if (BuildConfig.DEBUG) {
-                            Log.w(TAG, "Page $pageIndex: Large bitmap ${bitmapWidth}x${bitmapHeight} (~${estimatedMemoryMB}MB)")
-                        }
-                    }
-                    
-                    if (BuildConfig.DEBUG) {
-                        Log.d(TAG, "Rendering page $pageIndex: ${bitmapWidth}x${bitmapHeight} (scale: $currentScale, quality: $renderQuality, totalScale: $totalScale)")
-                    }
-                    
-                    // ARGB_8888 is required for PdfRenderer
-                    val bitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888)
-                    
-                    Canvas(bitmap).drawColor(Color.WHITE)
-                    page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
-                    
-                    bitmap
                 }
             }
         } catch (e: OutOfMemoryError) {
-            Log.e(TAG, "OOM rendering page $pageIndex at scale $currentScale", e)
-            // Clear cache and try to recover memory
-            bitmapCache.evictAll()
-            System.gc()
-            
-            // Emit error to inform user
-            withContext(Dispatchers.Main) {
-                emitError("Out of memory at zoom level ${currentScale}x. Try reducing zoom.", "OOM_ERROR")
-            }
+            handleOutOfMemoryError(pageIndex, e)
             null
         } catch (e: IllegalArgumentException) {
             Log.e(TAG, "Invalid bitmap dimensions for page $pageIndex", e)
@@ -922,72 +1071,54 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
-    private suspend fun renderThumbnail(pageIndex: Int): Bitmap = withContext(Dispatchers.IO) {
-        val renderer = pdfRenderer ?: throw IllegalStateException("No renderer")
+    private fun calculateBitmapDimensions(page: PdfRenderer.Page): Pair<Int, Int> {
+        // Render at view width with quality multiplier (zoom is handled by view transform)
+        val baseScale = viewWidth.toFloat() / page.width
+        val totalScale = baseScale * BASE_RENDER_QUALITY
         
-        renderMutex.withLock {
-            renderer.openPage(pageIndex).use { page ->
-                val thumbSize = 120
-                val aspectRatio = page.height.toFloat() / page.width.toFloat()
-                val thumbWidth = thumbSize
-                val thumbHeight = (thumbSize * aspectRatio).roundToInt()
-                
-                val bitmap = Bitmap.createBitmap(thumbWidth, thumbHeight, Bitmap.Config.ARGB_8888)
-                Canvas(bitmap).drawColor(Color.WHITE)
-                page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
-                
-                bitmap
+        var bitmapWidth = (page.width * totalScale).toInt().coerceAtLeast(1)
+        var bitmapHeight = (page.height * totalScale).toInt().coerceAtLeast(1)
+        
+        // Enforce maximum bitmap dimensions
+        if (bitmapWidth > MAX_BITMAP_DIMENSION || bitmapHeight > MAX_BITMAP_DIMENSION) {
+            val aspectRatio = page.width.toFloat() / page.height.toFloat()
+            if (bitmapWidth > bitmapHeight) {
+                bitmapWidth = MAX_BITMAP_DIMENSION
+                bitmapHeight = (MAX_BITMAP_DIMENSION / aspectRatio).toInt()
+            } else {
+                bitmapHeight = MAX_BITMAP_DIMENSION
+                bitmapWidth = (MAX_BITMAP_DIMENSION * aspectRatio).toInt()
             }
         }
+        
+        return Pair(bitmapWidth, bitmapHeight)
     }
     
-    private fun saveThumbnailToCache(bitmap: Bitmap, page: Int): String {
-        val cacheDir = File(context.cacheDir, "PDFThumbnails").apply { 
-            if (!exists()) mkdirs() 
-        }
+    private fun logBitmapStats(pageIndex: Int, width: Int, height: Int) {
+        if (!BuildConfig.DEBUG) return
         
-        val hash = getDocumentHash()
-        val file = File(cacheDir, "thumb_${page}_$hash.jpg")
-        
-        FileOutputStream(file).use { out ->
-            bitmap.compress(Bitmap.CompressFormat.JPEG, 85, out)
+        val estimatedMemoryMB = (width * height * 4) / (1024 * 1024)
+        if (estimatedMemoryMB > ESTIMATED_MEMORY_WARNING_MB) {
+            Log.w(TAG, "Page $pageIndex: Large bitmap ${width}x${height} (~${estimatedMemoryMB}MB)")
         }
-        
-        if (!bitmap.isRecycled) bitmap.recycle()
-        
-        return "file://${file.absolutePath}"
     }
     
-    private fun getDocumentHash(): String {
-        val uri = sourceUri ?: return "unknown"
-        return try {
-            MessageDigest.getInstance("MD5")
-                .digest(uri.toByteArray())
-                .joinToString("") { "%02x".format(it) }
-                .substring(0, 8)
-        } catch (e: Exception) {
-            "unknown"
+    private suspend fun handleOutOfMemoryError(pageIndex: Int, error: OutOfMemoryError) {
+        Log.e(TAG, "OOM rendering page $pageIndex at scale $currentScale", error)
+        bitmapCache.evictAll()
+        System.gc()
+        
+        withContext(Dispatchers.Main) {
+            emitError("Out of memory at zoom level ${currentScale}x. Try reducing zoom.", "OOM_ERROR")
         }
     }
     
-    private fun cleanupThumbnailDirectory() {
-        try {
-            val cacheDir = File(context.cacheDir, "PDFThumbnails")
-            if (cacheDir.exists() && cacheDir.isDirectory) {
-                cacheDir.listFiles()?.forEach { file ->
-                    try {
-                        file.delete()
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error deleting thumbnail file: ${file.name}", e)
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error cleaning up thumbnail directory", e)
-        }
-    }
+    // endregion
+    
+    // region RecyclerView Adapter
     
-    inner class PdfPageAdapter : RecyclerView.Adapter<PdfPageViewHolder>() {
+    private inner class PdfPageAdapter : RecyclerView.Adapter<PdfPageViewHolder>() {
+        
         override fun getItemCount(): Int = pdfRenderer?.pageCount ?: 0
         
         override fun onCreateViewHolder(parent: android.view.ViewGroup, viewType: Int): PdfPageViewHolder {
@@ -1000,38 +1131,46 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
         
         override fun onBindViewHolder(holder: PdfPageViewHolder, position: Int) {
-            // Set height first
+            bindPageDimensions(holder, position)
+            bindPageBitmap(holder, position)
+        }
+        
+        private fun bindPageDimensions(holder: PdfPageViewHolder, position: Int) {
             val dimensions = pageDimensions[position]
+            
             if (dimensions != null && viewWidth > 0) {
-                val scale = (viewWidth.toFloat() / dimensions.first) * currentScale
-                val targetHeight = (dimensions.second * scale).toInt().coerceAtLeast(100)
+                // Scale to fit width (no zoom factor - zoom is handled by view transformation)
+                val scale = viewWidth.toFloat() / dimensions.width
+                val targetHeight = (dimensions.height * scale).toInt().coerceAtLeast(100)
                 holder.imageView.layoutParams.height = targetHeight
             } else {
-                // Dimensions not loaded yet, use default height and trigger lazy load
                 holder.imageView.layoutParams.height = (viewWidth * 1.414f).toInt().coerceAtLeast(100)
-                
-                // Trigger lazy loading of dimensions in background
-                componentScope.launch(Dispatchers.IO) {
-                    val dims = getPageDimensions(position)
-                    withContext(Dispatchers.Main) {
-                        // Update the view if it's still showing this position
-                        if (holder.bindingAdapterPosition == position) {
-                            val scale = (viewWidth.toFloat() / dims.first) * currentScale
-                            val targetHeight = (dims.second * scale).toInt().coerceAtLeast(100)
-                            holder.imageView.layoutParams.height = targetHeight
-                            holder.imageView.requestLayout()
-                        }
+                loadDimensionsAsync(holder, position)
+            }
+        }
+        
+        private fun loadDimensionsAsync(holder: PdfPageViewHolder, position: Int) {
+            componentScope.launch(Dispatchers.IO) {
+                val dims = getPageDimensions(position)
+                withContext(Dispatchers.Main) {
+                    if (holder.bindingAdapterPosition == position) {
+                        val scale = viewWidth.toFloat() / dims.width
+                        val targetHeight = (dims.height * scale).toInt().coerceAtLeast(100)
+                        holder.imageView.layoutParams.height = targetHeight
+                        holder.imageView.requestLayout()
                     }
                 }
             }
-            
-            // Check cache for valid bitmap at current scale
-            val cacheKey = "$position-${currentScale.toString().take(4)}"
+        }
+        
+        private fun bindPageBitmap(holder: PdfPageViewHolder, position: Int) {
+            // Cache key no longer includes scale since bitmap is rendered at fixed quality
+            val cacheKey = "$position"
             val cached = bitmapCache.get(cacheKey)
+            
             if (cached != null && !cached.isRecycled) {
                 holder.imageView.setImageBitmap(cached)
             } else {
-                // Show placeholder and trigger render
                 holder.imageView.setImageBitmap(createPlaceholderBitmap(position))
                 startPageRender(position)
             }
@@ -1039,131 +1178,133 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         
         override fun onViewRecycled(holder: PdfPageViewHolder) {
             super.onViewRecycled(holder)
-            // Clear reference but don't recycle the bitmap (cache may still have it)
             holder.imageView.setImageBitmap(null)
         }
         
         private fun createPlaceholderBitmap(pageIndex: Int): Bitmap {
             val dimensions = pageDimensions[pageIndex]
-            val w = dimensions?.let { (it.first * 0.1f).toInt() } ?: 100
-            val h = dimensions?.let { (it.second * 0.1f).toInt() } ?: 100
+            val w = dimensions?.let { (it.width * 0.1f).toInt() } ?: 100
+            val h = dimensions?.let { (it.height * 0.1f).toInt() } ?: 100
             
-            return Bitmap.createBitmap(w.coerceAtLeast(10), h.coerceAtLeast(10), Bitmap.Config.ARGB_8888).apply {
+            return Bitmap.createBitmap(
+                w.coerceAtLeast(10),
+                h.coerceAtLeast(10),
+                Bitmap.Config.ARGB_8888
+            ).apply {
                 Canvas(this).drawColor(Color.WHITE)
             }
         }
     }
     
-    inner class PdfPageViewHolder(val imageView: ImageView) : RecyclerView.ViewHolder(imageView)
+    private inner class PdfPageViewHolder(val imageView: ImageView) : RecyclerView.ViewHolder(imageView)
+    
+    // endregion
     
-    inner class ScaleListener : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+    // region Gesture Listeners
+    
+    private inner class ScaleListener : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+        private var lastFocusX = 0f
+        private var lastFocusY = 0f
+        
+        override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+            if (!enableZoom) return false
+            lastFocusX = detector.focusX
+            lastFocusY = detector.focusY
+            return true
+        }
+        
         override fun onScale(detector: ScaleGestureDetector): Boolean {
             if (!enableZoom) return false
             
             val newScale = (currentScale * detector.scaleFactor).coerceIn(minScale, maxScale)
-            if (newScale != currentScale) {
-                setScale(newScale)
+            if (kotlin.math.abs(newScale - currentScale) > 0.01f) {
+                setScale(newScale, detector.focusX, detector.focusY)
             }
             return true
         }
         
-        override fun onScaleBegin(detector: ScaleGestureDetector): Boolean = enableZoom
+        override fun onScaleEnd(detector: ScaleGestureDetector) {
+            // Snap to 1.0 if very close
+            if (currentScale < 1.05f && currentScale > 0.95f) {
+                resetZoomTransform()
+                emitScaleChange(1.0f)
+            }
+        }
     }
     
-    inner class GestureListener : GestureDetector.SimpleOnGestureListener() {
+    private inner class GestureListener : GestureDetector.SimpleOnGestureListener() {
         override fun onDoubleTap(e: MotionEvent): Boolean {
             if (!enableZoom) return false
             
-            // Toggle between current scale and 2x zoom (or reset to 1.0 if already zoomed)
-            val targetScale = if (currentScale > 1.5f) 1.0f else 2.0f
-            setScale(targetScale)
+            if (currentScale > 1.1f) {
+                // Zoom out to 1.0
+                resetZoomTransform()
+                emitScaleChange(1.0f)
+            } else {
+                // Zoom in to 2.0 centered on tap point
+                setScale(2.0f, e.x, e.y)
+            }
             return true
         }
     }
     
-    // Event emitters
+    // endregion
+    
+    // region Event Emitters
+    
     private fun emitLoadComplete(pageCount: Int, pageWidth: Int, pageHeight: Int) {
-        // Call Nitro callback
         onLoadCompleteCallback?.invoke(pageCount, pageWidth, pageHeight)
     }
     
     private fun emitPageChange(page: Int) {
         val pageCount = pdfRenderer?.pageCount ?: return
-        
-        // Call Nitro callback
-        onPageChangeCallback?.invoke(page, pageCount)
+        onPageChangeCallback?.invoke(page + 1, pageCount)
     }
     
     private fun emitScaleChange(scale: Float) {
-        // Call Nitro callback
         onScaleChangeCallback?.invoke(scale)
     }
     
     private fun emitError(message: String, code: String) {
-        // Call Nitro callback
         onErrorCallback?.invoke(message, code)
     }
     
     private fun emitThumbnailGenerated(page: Int, uri: String) {
-        // Call Nitro callback
         onThumbnailGeneratedCallback?.invoke(page, uri)
     }
     
     private fun emitLoadingChange(loading: Boolean) {
-        // Call Nitro callback
         onLoadingChangeCallback?.invoke(loading)
     }
     
+    // endregion
+    
+    // region Lifecycle
+    
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         
-        // Cancel all coroutines
+        ProcessLifecycleOwner.get().lifecycle.removeObserver(lifecycleObserver)
         componentScope.cancel()
         cancelAllRenderJobs()
         
-        // Wait for RecyclerView to finish drawing before recycling bitmaps
-        post {
-            val snapshot = bitmapCache.snapshot()
-            bitmapCache.evictAll()
-            
-            // Now safe to recycle - views are detached
-            snapshot.values.forEach { bitmap ->
-                if (!bitmap.isRecycled) {
-                    try {
-                        bitmap.recycle()
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error recycling bitmap", e)
-                    }
-                }
-            }
-        }
+        post { recycleCachedBitmaps() }
         
         closePdfRenderer()
         pageDimensions.clear()
         thumbnailCache.clear()
         pendingThumbnails.clear()
-        
-        // Clean up thumbnail directory
-        cleanupThumbnailDirectory()
     }
     
-    // Extension function for try-with-resources pattern
-    private inline fun <T : AutoCloseable, R> T.use(block: (T) -> R): R {
-        var exception: Throwable? = null
-        try {
-            return block(this)
-        } catch (e: Throwable) {
-            exception = e
-            throw e
-        } finally {
-            when {
-                exception == null -> close()
-                else -> try {
-                    close()
-                } catch (closeException: Throwable) {
-                    exception.addSuppressed(closeException)
-                }
-            }
+    private fun recycleCachedBitmaps() {
+        val snapshot = bitmapCache.snapshot()
+        bitmapCache.evictAll()
+        
+        snapshot.values.forEach { bitmap ->
+            runCatching { if (!bitmap.isRecycled) bitmap.recycle() }
+                .onFailure { Log.e(TAG, "Error recycling bitmap", it) }
         }
     }
+    
+    // endregion
 }