react-native-pdfrender 0.1.0

package/android/src/main/java/com/pdfrender/PdfIconComponents.kt

@@ -0,0 +1,275 @@
+package com.pdfrender
+
+import android.graphics.BitmapFactory
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.platform.LocalContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.URL
+
+/**
+ * PDF Icon Components
+ * 
+ * Handles loading and displaying icons from various sources:
+ * - URLs (http/https)
+ * - Local files
+ * - React Native resources
+ * - Android drawables
+ */
+
+/**
+ * Load and display an icon from URL, file, or drawable
+ * 
+ * @param imageUrl URL or path to the icon
+ * @param drawableName Fallback drawable name if URL fails
+ * @param modifier Modifier for the image
+ * @param tint Color tint to apply
+ * @param contentDescription Accessibility description
+ */
+@Composable
+fun LoadIconImage(
+    imageUrl: String?,
+    drawableName: String,
+    modifier: Modifier,
+    tint: Color,
+    contentDescription: String
+) {
+    val context = LocalContext.current
+    var bitmap by remember { mutableStateOf<android.graphics.Bitmap?>(null) }
+    
+    LaunchedEffect(imageUrl) {
+        if (!imageUrl.isNullOrEmpty()) {
+            // Load from URL or local file
+            bitmap = withContext(Dispatchers.IO) {
+                try {
+                    when {
+                        // Handle React Native resource URIs (res://drawable/... or res:/drawable/...)
+                        imageUrl.startsWith("res://") || imageUrl.startsWith("res:/") -> {
+                            val resourceName = imageUrl.substringAfterLast("/").substringBefore(".")
+                            val resourceId = context.resources.getIdentifier(resourceName, "drawable", context.packageName)
+                            if (resourceId != 0) {
+                                BitmapFactory.decodeResource(context.resources, resourceId)
+                            } else null
+                        }
+                        
+                        // Handle asset URIs (file:///android_asset/...)
+                        imageUrl.startsWith("file:///android_asset/") -> {
+                            val assetPath = imageUrl.removePrefix("file:///android_asset/")
+                            context.assets.open(assetPath).use { inputStream ->
+                                BitmapFactory.decodeStream(inputStream)
+                            }
+                        }
+                        
+                        // Handle local file URIs (file://...)
+                        imageUrl.startsWith("file://") -> {
+                            val filePath = imageUrl.removePrefix("file://")
+                            BitmapFactory.decodeFile(filePath)
+                        }
+                        
+                        // Handle content:// URIs
+                        imageUrl.startsWith("content://") -> {
+                            context.contentResolver.openInputStream(android.net.Uri.parse(imageUrl))?.use { inputStream ->
+                                BitmapFactory.decodeStream(inputStream)
+                            }
+                        }
+                        
+                        // Handle http/https URLs
+                        imageUrl.startsWith("http://") || imageUrl.startsWith("https://") -> {
+                            val url = URL(imageUrl)
+                            val connection = url.openConnection()
+                            connection.connectTimeout = 5000
+                            connection.readTimeout = 5000
+                            connection.connect()
+                            val inputStream = connection.getInputStream()
+                            BitmapFactory.decodeStream(inputStream)
+                        }
+                        
+                        // Try as numeric resource ID
+                        imageUrl.matches(Regex("^\\d+$")) -> {
+                            val resourceId = imageUrl.toInt()
+                            BitmapFactory.decodeResource(context.resources, resourceId)
+                        }
+                        
+                        // Try as drawable resource or asset
+                        else -> {
+                            val resourceId = context.resources.getIdentifier(imageUrl, "drawable", context.packageName)
+                            if (resourceId != 0) {
+                                BitmapFactory.decodeResource(context.resources, resourceId)
+                            } else {
+                                // Try as asset in various paths
+                                val assetPaths = listOf(
+                                    imageUrl,
+                                    "drawable-mdpi/$imageUrl",
+                                    "drawable-hdpi/$imageUrl",
+                                    "drawable-xhdpi/$imageUrl",
+                                    "drawable-xxhdpi/$imageUrl"
+                                )
+                                
+                                var loadedBitmap: android.graphics.Bitmap? = null
+                                for (path in assetPaths) {
+                                    try {
+                                        val inputStream = context.assets.open(path)
+                                        loadedBitmap = BitmapFactory.decodeStream(inputStream)
+                                        inputStream.close()
+                                        if (loadedBitmap != null) break
+                                    } catch (e: Exception) {
+                                        // Try next path
+                                    }
+                                }
+                                loadedBitmap ?: BitmapFactory.decodeFile(imageUrl)
+                            }
+                        }
+                    }
+                } catch (e: Exception) {
+                    null
+                }
+            }
+        } else {
+            // Fallback to drawable
+            val resourceId = context.resources.getIdentifier(drawableName, "drawable", context.packageName)
+            if (resourceId != 0) {
+                bitmap = BitmapFactory.decodeResource(context.resources, resourceId)
+            }
+        }
+    }
+    
+    bitmap?.let {
+        Image(
+            bitmap = it.asImageBitmap(),
+            contentDescription = contentDescription,
+            modifier = modifier,
+            colorFilter = ColorFilter.tint(tint)
+        )
+    }
+}
+
+/**
+ * Zoom In Icon Component
+ */
+@Composable
+fun ZoomInIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_zoom_in",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Zoom In"
+    )
+}
+
+/**
+ * Zoom Out Icon Component
+ */
+@Composable
+fun ZoomOutIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_zoom_out",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Zoom Out"
+    )
+}
+
+/**
+ * Fullscreen Icon Component
+ */
+@Composable
+fun FullscreenIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_fullscreen",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Fullscreen"
+    )
+}
+
+/**
+ * Minimize Icon Component
+ */
+@Composable
+fun MinimizeIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_minimize",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Minimize"
+    )
+}
+
+/**
+ * Left Layout Icon Component
+ */
+@Composable
+fun LeftLayoutSidebarIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_left_layout",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Left Layout"
+    )
+}
+
+/**
+ * Right Layout Icon Component
+ */
+@Composable
+fun RightLayoutSidebarIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_right_layout",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Right Layout"
+    )
+}
+
+/**
+ * Reset Icon Component
+ */
+@Composable
+fun ResetIcon(
+    tint: Color,
+    modifier: Modifier,
+    imageUrl: String? = null
+) {
+    LoadIconImage(
+        imageUrl = imageUrl,
+        drawableName = "ic_reset",
+        modifier = modifier,
+        tint = tint,
+        contentDescription = "Reset"
+    )
+}

package/android/src/main/java/com/pdfrender/PdfRenderingLogic.kt

@@ -0,0 +1,325 @@
+package com.pdfrender
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.pdf.PdfRenderer
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.system.measureTimeMillis
+
+/**
+ * PDF Page Rendering Logic
+ * 
+ * This file contains all functions related to rendering PDF pages to bitmaps.
+ * Handles thread safety, memory management, and error handling.
+ */
+
+/**
+ * Data class to hold rendering timing information
+ */
+data class RenderTimings(
+    val totalTime: Long,
+    val pageOpenTime: Long,
+    val bitmapCreateTime: Long,
+    val renderTime: Long
+)
+
+/**
+ * Renders a single PDF page to a Bitmap at the specified scale
+ * 
+ * This function is thread-safe and handles:
+ * - Page validation
+ * - Memory management
+ * - Error handling and cleanup
+ * - Bitmap creation with appropriate quality settings
+ * - Performance timing measurements
+ * 
+ * @param pageIndex The index of the page to render (0-based)
+ * @param targetScale The scale at which to render (0.3f to 0.6f)
+ * @param pageCount Total number of pages in the PDF
+ * @param pdfRenderer The PdfRenderer instance (can be null)
+ * @param renderMutex Mutex for thread-safe access to PdfRenderer
+ * @param density Screen density for proper scaling
+ * @param activeBitmaps Set to track active bitmaps (prevents premature recycling)
+ * @param logTimings Whether to log detailed timing information (default: true)
+ * 
+ * @return Pair of rendered Bitmap and RenderTimings, or null if rendering failed
+ */
+suspend fun renderPageToBitmap(
+    pageIndex: Int,
+    targetScale: Float,
+    pageCount: Int,
+    pdfRenderer: PdfRenderer?,
+    renderMutex: Mutex,
+    density: Float,
+    activeBitmaps: MutableSet<Bitmap>,
+    logTimings: Boolean = true
+): Pair<Bitmap, RenderTimings>? = withContext(Dispatchers.Default) {
+    
+    // Validate page index
+    if (pageIndex < 0 || pageIndex >= pageCount) {
+        Log.e("PdfRenderer", "Invalid page index: $pageIndex (pageCount: $pageCount)")
+        return@withContext null
+    }
+    
+    try {
+        val renderer = pdfRenderer
+        if (renderer == null) {
+            Log.e("PdfRenderer", "Renderer is null for page $pageIndex")
+            return@withContext null
+        }
+        
+        var page: PdfRenderer.Page? = null
+        var bitmap: Bitmap? = null
+        var pageOpenTime = 0L
+        var bitmapCreateTime = 0L
+        var renderTime = 0L
+        
+        try {
+            // Measure page opening time
+            pageOpenTime = measureTimeMillis {
+                // Use mutex to safely open page (PdfRenderer is not thread-safe)
+                page = renderMutex.withLock {
+                    try {
+                        // Double-check renderer is still valid
+                        val currentRenderer = pdfRenderer
+                        if (currentRenderer == null) {
+                            Log.e("PdfRenderer", "Renderer became null during lock")
+                            return@withLock null
+                        }
+                        
+                        // Validate page index again
+                        if (pageIndex < 0 || pageIndex >= pageCount) {
+                            Log.e("PdfRenderer", "Invalid page index in lock: $pageIndex")
+                            return@withLock null
+                        }
+                        
+                        currentRenderer.openPage(pageIndex)
+                    } catch (e: IllegalStateException) {
+                        Log.e("PdfRenderer", "IllegalState opening page $pageIndex: ${e.message}")
+                        null
+                    } catch (e: IllegalArgumentException) {
+                        Log.e("PdfRenderer", "IllegalArgument opening page $pageIndex: ${e.message}")
+                        null
+                    } catch (e: Exception) {
+                        Log.e("PdfRenderer", "Error opening page $pageIndex: ${e.message}")
+                        e.printStackTrace()
+                        null
+                    }
+                }
+            }
+            
+            val openedPage = page
+            if (openedPage == null) {
+                return@withContext null
+            }
+            
+            // Calculate bitmap dimensions based on scale (optimized calculation)
+            val scaleFactor = (targetScale * density * 4f).coerceIn(1.5f, 4f)
+            val width = (openedPage.width * scaleFactor).toInt()
+            val height = (openedPage.height * scaleFactor).toInt()
+            
+            // Check memory availability before creating bitmap
+            val runtime = Runtime.getRuntime()
+            val maxMemory = runtime.maxMemory()
+            val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+            val availableMemory = maxMemory - usedMemory
+            val bitmapSize = (width * height * 4).toLong()
+            
+            // Measure bitmap creation time
+            bitmapCreateTime = measureTimeMillis {
+                bitmap = try {
+                    // Optimize bitmap config based on memory pressure
+                    val config = when {
+                        bitmapSize > availableMemory * 0.8 -> {
+                            // Use lower quality if memory is very tight
+                            val reducedScale = scaleFactor * 0.7f
+                            val reducedWidth = (openedPage.width * reducedScale).toInt()
+                            val reducedHeight = (openedPage.height * reducedScale).toInt()
+                            Log.w("PdfRenderer", "Low memory: Using RGB_565 for page $pageIndex")
+                            Bitmap.createBitmap(reducedWidth, reducedHeight, Bitmap.Config.RGB_565)
+                        }
+                        bitmapSize > availableMemory * 0.6 -> {
+                            // Use RGB_565 for better memory efficiency
+                            Log.d("PdfRenderer", "Memory pressure: Using RGB_565 for page $pageIndex")
+                            Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565)
+                        }
+                        else -> {
+                            // Use high quality ARGB_8888 when memory is available
+                            Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+                        }
+                    }
+                    
+                    // Pre-fill with white background for better rendering performance
+                    config.apply {
+                        Canvas(this).drawColor(Color.WHITE)
+                    }
+                } catch (e: OutOfMemoryError) {
+                    Log.e("PdfRenderer", "OOM creating bitmap for page $pageIndex")
+                    System.gc()
+                    null
+                }
+            }
+            
+            val createdBitmap = bitmap
+            if (createdBitmap == null) {
+                return@withContext null
+            }
+            
+            // Track this bitmap as active (prevents premature recycling)
+            activeBitmaps.add(createdBitmap)
+            
+            // Measure actual PDF rendering time
+            renderTime = measureTimeMillis {
+                try {
+                    // Use RENDER_MODE_FOR_DISPLAY for optimized rendering
+                    openedPage.render(createdBitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+                } catch (e: IllegalStateException) {
+                    Log.e("PdfRenderer", "IllegalState rendering page $pageIndex: ${e.message}")
+                    throw e
+                } catch (e: Exception) {
+                    Log.e("PdfRenderer", "Error rendering page $pageIndex to bitmap: ${e.message}")
+                    e.printStackTrace()
+                    throw e
+                }
+            }
+            
+            val timings = RenderTimings(
+                totalTime = pageOpenTime + bitmapCreateTime + renderTime,
+                pageOpenTime = pageOpenTime,
+                bitmapCreateTime = bitmapCreateTime,
+                renderTime = renderTime
+            )
+            
+            if (logTimings) {
+                Log.i("PdfRenderer", """
+                    📊 Page $pageIndex Render Complete:
+                    ├─ Total: ${timings.totalTime}ms
+                    ├─ Page Open: ${pageOpenTime}ms
+                    ├─ Bitmap Create: ${bitmapCreateTime}ms
+                    ├─ PDF Render: ${renderTime}ms
+                    └─ Size: ${width}x${height} (${createdBitmap.config})
+                """.trimIndent())
+            }
+            
+            return@withContext Pair(createdBitmap, timings)
+        } catch (e: Exception) {
+            Log.e("PdfRenderer", "Error rendering page $pageIndex: ${e.message}")
+            e.printStackTrace()
+            
+            // Clean up bitmap if created
+            bitmap?.let {
+                cleanupBitmap(it, activeBitmaps)
+            }
+            return@withContext null
+        } finally {
+            // Always close the page
+            try {
+                page?.close()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+    } catch (e: Exception) {
+        Log.e("PdfRenderer", "Unexpected error in renderPageToBitmap: ${e.message}")
+        e.printStackTrace()
+        return@withContext null
+    }
+}
+
+/**
+ * Simplified version that returns only the Bitmap (for backward compatibility)
+ * 
+ * @return The rendered Bitmap, or null if rendering failed
+ */
+suspend fun renderPageToBitmapSimple(
+    pageIndex: Int,
+    targetScale: Float,
+    pageCount: Int,
+    pdfRenderer: PdfRenderer?,
+    renderMutex: Mutex,
+    density: Float,
+    activeBitmaps: MutableSet<Bitmap>
+): Bitmap? {
+    return renderPageToBitmap(
+        pageIndex = pageIndex,
+        targetScale = targetScale,
+        pageCount = pageCount,
+        pdfRenderer = pdfRenderer,
+        renderMutex = renderMutex,
+        density = density,
+        activeBitmaps = activeBitmaps,
+        logTimings = false
+    )?.first
+}
+
+/**
+ * Performance statistics tracker for bitmap rendering
+ */
+class RenderingStats {
+    private val timings = mutableListOf<RenderTimings>()
+    
+    fun addTiming(timing: RenderTimings) {
+        synchronized(timings) {
+            timings.add(timing)
+            // Keep only last 100 timings to prevent memory bloat
+            if (timings.size > 100) {
+                timings.removeAt(0)
+            }
+        }
+    }
+    
+    fun getStats(): String {
+        synchronized(timings) {
+            if (timings.isEmpty()) return "No render statistics available"
+            
+            val avgTotal = timings.map { it.totalTime }.average()
+            val avgPageOpen = timings.map { it.pageOpenTime }.average()
+            val avgBitmapCreate = timings.map { it.bitmapCreateTime }.average()
+            val avgRender = timings.map { it.renderTime }.average()
+            
+            val minTotal = timings.minOf { it.totalTime }
+            val maxTotal = timings.maxOf { it.totalTime }
+            
+            return """
+                📈 Rendering Statistics (last ${timings.size} pages):
+                ├─ Average Total: ${"%.2f".format(avgTotal)}ms
+                ├─ Average Page Open: ${"%.2f".format(avgPageOpen)}ms
+                ├─ Average Bitmap Create: ${"%.2f".format(avgBitmapCreate)}ms
+                ├─ Average PDF Render: ${"%.2f".format(avgRender)}ms
+                ├─ Fastest: ${minTotal}ms
+                └─ Slowest: ${maxTotal}ms
+            """.trimIndent()
+        }
+    }
+    
+    fun reset() {
+        synchronized(timings) {
+            timings.clear()
+        }
+    }
+}
+
+/**
+ * Safely cleans up a bitmap by removing it from active set and recycling it
+ * 
+ * @param bitmap The bitmap to clean up
+ * @param activeBitmaps The set of active bitmaps
+ */
+private fun cleanupBitmap(bitmap: Bitmap?, activeBitmaps: MutableSet<Bitmap>) {
+    if (bitmap == null) return
+    
+    try {
+        activeBitmaps.remove(bitmap)
+        if (!bitmap.isRecycled && bitmap.width > 0 && bitmap.height > 0) {
+            bitmap.recycle()
+        }
+    } catch (e: Exception) {
+        Log.e("PdfRenderer", "Error cleaning up bitmap: ${e.message}")
+    }
+}
+