@june24/expo-pdf-reader 0.1.0

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

@@ -0,0 +1,934 @@
+package expo.modules.pdfreader
+
+import android.content.Context
+import android.graphics.*
+import android.graphics.pdf.PdfDocument
+import android.graphics.pdf.PdfRenderer
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.ScrollView
+import android.widget.LinearLayout
+import android.view.ViewTreeObserver
+import android.view.ViewGroup
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+import expo.modules.kotlin.viewevent.EventDispatcher
+import java.io.File
+import java.io.FileOutputStream
+import java.net.URL
+import kotlinx.coroutines.*
+
+class ExpoPdfReaderView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+  private val scrollView = ScrollView(context)
+  private val container = FrameLayout(context)
+  private val imageView = ImageView(context)
+  private val drawingView = DrawingView(context)
+  
+  private var pdfRenderer: PdfRenderer? = null
+  private var currentPage: PdfRenderer.Page? = null
+  private var fileDescriptor: ParcelFileDescriptor? = null
+  private val scope = CoroutineScope(Dispatchers.Main)
+  
+  private var currentTool = "none"
+  private var currentColor = Color.BLACK
+  private var currentFontSize = 16.0
+  private var currentText = "Text"
+  private var currentPdfFile: File? = null
+  private var currentStrokeWidth: Double = 10.0
+  private var displayMode = "continuous" // 'single' | 'continuous' | 'twoUp' | 'twoUpContinuous'
+  private var initialPage: Int = 0
+  private var minZoom: Float = 1.0f
+  private var maxZoom: Float = 4.0f
+  private var currentZoom: Float = 1.0f
+  
+  private val onAnnotationChange by EventDispatcher()
+  private val onPageChange by EventDispatcher()
+  private val onScroll by EventDispatcher()
+
+  init {
+    // Setup ScrollView
+    scrollView.layoutParams = FrameLayout.LayoutParams(
+      FrameLayout.LayoutParams.MATCH_PARENT,
+      FrameLayout.LayoutParams.MATCH_PARENT
+    )
+    scrollView.isFillViewport = true
+    
+    // Setup container
+    container.layoutParams = FrameLayout.LayoutParams(
+      FrameLayout.LayoutParams.MATCH_PARENT,
+      FrameLayout.LayoutParams.WRAP_CONTENT
+    )
+    
+    // Setup Image View
+    imageView.layoutParams = FrameLayout.LayoutParams(
+      FrameLayout.LayoutParams.MATCH_PARENT,
+      FrameLayout.LayoutParams.WRAP_CONTENT
+    )
+    imageView.adjustViewBounds = true
+    imageView.scaleType = ImageView.ScaleType.FIT_START
+    
+    // Setup Drawing View (Overlay)
+    drawingView.layoutParams = FrameLayout.LayoutParams(
+      FrameLayout.LayoutParams.MATCH_PARENT,
+      FrameLayout.LayoutParams.MATCH_PARENT
+    )
+    drawingView.setBackgroundColor(Color.TRANSPARENT)
+    drawingView.visibility = View.GONE // Hidden by default
+    
+    // Set callback
+    drawingView.onDrawingChanged = {
+        onAnnotationChange(mapOf("annotations" to getAnnotations()))
+    }
+    
+    // Setup scroll listener
+    scrollView.viewTreeObserver.addOnScrollChangedListener {
+        val scrollX = scrollView.scrollX
+        val scrollY = scrollView.scrollY
+        val contentWidth = scrollView.getChildAt(0)?.width ?: 0
+        val contentHeight = scrollView.getChildAt(0)?.height ?: 0
+        val layoutWidth = scrollView.width
+        val layoutHeight = scrollView.height
+        
+        onScroll(mapOf(
+            "x" to scrollX.toDouble(),
+            "y" to scrollY.toDouble(),
+            "contentWidth" to contentWidth.toDouble(),
+            "contentHeight" to contentHeight.toDouble(),
+            "layoutWidth" to layoutWidth.toDouble(),
+            "layoutHeight" to layoutHeight.toDouble()
+        ))
+    }
+    
+    container.addView(imageView)
+    container.addView(drawingView)
+    container.scaleX = currentZoom
+    container.scaleY = currentZoom
+    scrollView.addView(container)
+    addView(scrollView)
+  }
+
+  fun setDisplayMode(mode: String) {
+    displayMode = mode
+    // Re-render PDF with new display mode
+    currentPdfFile?.let { file ->
+      renderPdf(file)
+    }
+  }
+  
+  fun setInitialPage(page: Int) {
+    initialPage = if (page >= 0) page else 0
+    // If PDF already loaded, jump immediately
+    if (pdfRenderer != null) {
+      goToPage(initialPage)
+    }
+  }
+  
+  fun setMinZoom(value: Double) {
+    val v = value.toFloat()
+    minZoom = if (v > 0f) v else 0.5f
+    if (currentZoom < minZoom) {
+      applyZoom(minZoom)
+    }
+  }
+  
+  fun setMaxZoom(value: Double) {
+    val v = value.toFloat()
+    maxZoom = if (v > minZoom) v else minZoom
+    if (currentZoom > maxZoom) {
+      applyZoom(maxZoom)
+    }
+  }
+  
+  private fun applyZoom(factor: Float) {
+    currentZoom = factor
+    container.scaleX = factor
+    container.scaleY = factor
+  }
+  
+  fun zoomIn(): Boolean {
+    val newZoom = (currentZoom * 1.25f).coerceAtMost(maxZoom)
+    if (newZoom == currentZoom) return false
+    applyZoom(newZoom)
+    return true
+  }
+  
+  fun zoomOut(): Boolean {
+    val newZoom = (currentZoom / 1.25f).coerceAtLeast(minZoom)
+    if (newZoom == currentZoom) return false
+    applyZoom(newZoom)
+    return true
+  }
+  
+  fun setUrl(url: String) {
+    scope.launch(Dispatchers.IO) {
+      try {
+        val file = if (url.startsWith("http")) {
+          downloadFile(url)
+        } else {
+          val uri = Uri.parse(url)
+          File(uri.path ?: url)
+        }
+
+        if (file.exists()) {
+          currentPdfFile = file
+          withContext(Dispatchers.Main) {
+            renderPdf(file)
+            // After render, go to initialPage (or 0)
+            if (pdfRenderer != null) {
+              val target = if (initialPage >= 0 && initialPage < pdfRenderer!!.pageCount) {
+                initialPage
+              } else {
+                0
+              }
+              goToPage(target)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        e.printStackTrace()
+      }
+    }
+  }
+  
+  fun setAnnotationTool(tool: String) {
+    currentTool = tool
+    drawingView.setTool(tool)
+    
+    if (tool == "none") {
+        if (drawingView.hasAnnotations()) {
+            drawingView.visibility = View.VISIBLE
+        } else {
+            drawingView.visibility = View.GONE
+        }
+    } else {
+        drawingView.visibility = View.VISIBLE
+        drawingView.bringToFront()
+    }
+  }
+  
+  fun setAnnotationColor(colorHex: String?) {
+      if (colorHex != null) {
+          try {
+              currentColor = Color.parseColor(colorHex)
+              drawingView.setColor(currentColor)
+          } catch (e: Exception) {
+              // Invalid color
+          }
+      }
+  }
+  
+  fun setAnnotationFontSize(size: Double) {
+      currentFontSize = size
+      drawingView.setFontSize(size.toFloat())
+  }
+  
+  fun setAnnotationText(text: String) {
+      currentText = text
+      drawingView.setTextToDraw(text)
+  }
+  
+  fun setAnnotationStrokeWidth(width: Double) {
+      currentStrokeWidth = width
+      drawingView.setBaseStrokeWidth(width.toFloat())
+  }
+  
+  fun getAnnotations(): List<AnnotationData> {
+      return drawingView.getAnnotations()
+  }
+  
+  fun setAnnotations(annotations: List<AnnotationData>) {
+      drawingView.setAnnotations(annotations)
+      if (annotations.isNotEmpty()) {
+          drawingView.visibility = View.VISIBLE
+      }
+  }
+  
+  fun undo(): Boolean {
+      return drawingView.undo()
+  }
+  
+  fun redo(): Boolean {
+      return drawingView.redo()
+  }
+  
+  fun renderThumbnail(pageIndex: Int, targetWidth: Int): String {
+      if (targetWidth <= 0) {
+          throw IllegalArgumentException("targetWidth must be > 0")
+      }
+      
+      if (pdfRenderer == null) {
+          if (currentPdfFile == null || !currentPdfFile!!.exists()) {
+              throw IllegalStateException("PDF not loaded")
+          }
+          fileDescriptor = ParcelFileDescriptor.open(currentPdfFile, ParcelFileDescriptor.MODE_READ_ONLY)
+          pdfRenderer = PdfRenderer(fileDescriptor!!)
+      }
+      
+      if (pageIndex < 0 || pageIndex >= pdfRenderer!!.pageCount) {
+          throw IllegalArgumentException("Invalid page index")
+      }
+      
+      val page = pdfRenderer!!.openPage(pageIndex)
+      try {
+          val scale = targetWidth.toFloat() / page.width.toFloat()
+          val targetHeight = (page.height * scale).toInt().coerceAtLeast(1)
+          
+          val bitmap = Bitmap.createBitmap(
+              targetWidth,
+              targetHeight,
+              Bitmap.Config.ARGB_8888
+          )
+          
+          page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+          
+          val fileName = "thumb_${pageIndex}_${System.currentTimeMillis()}.png"
+          val file = File(context.cacheDir, fileName)
+          val output = FileOutputStream(file)
+          try {
+              bitmap.compress(Bitmap.CompressFormat.PNG, 90, output)
+          } finally {
+              output.close()
+          }
+          
+          return Uri.fromFile(file).toString()
+      } finally {
+          page.close()
+      }
+  }
+  
+  fun searchText(text: String): List<SearchResultData> {
+      android.util.Log.w("ExpoPdfReader", "Search is not supported on Android with native PdfRenderer.")
+      return emptyList()
+  }
+  
+  fun goToPage(pageIndex: Int) {
+      if (pdfRenderer != null && pageIndex >= 0 && pageIndex < pdfRenderer!!.pageCount) {
+          try {
+              currentPage?.close()
+              currentPage = pdfRenderer!!.openPage(pageIndex)
+              
+              val bitmap = Bitmap.createBitmap(
+                currentPage!!.width,
+                currentPage!!.height,
+                Bitmap.Config.ARGB_8888
+              )
+              
+              currentPage!!.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+              imageView.setImageBitmap(bitmap)
+              
+              // Notify page change
+              onPageChange(mapOf(
+                  "page" to pageIndex,
+                  "total" to pdfRenderer!!.pageCount
+              ))
+              
+          } catch (e: Exception) {
+              e.printStackTrace()
+          }
+      }
+  }
+  
+  fun savePdf(): String {
+      if (currentPdfFile == null || !currentPdfFile!!.exists()) {
+          throw Exception("No PDF loaded")
+      }
+      
+      val document = PdfDocument()
+      val descriptor = ParcelFileDescriptor.open(currentPdfFile, ParcelFileDescriptor.MODE_READ_ONLY)
+      val renderer = PdfRenderer(descriptor)
+      
+      if (renderer.pageCount > 0) {
+          val page = renderer.openPage(0)
+          val pageInfo = PdfDocument.PageInfo.Builder(page.width, page.height, 1).create()
+          val newPage = document.startPage(pageInfo)
+          val canvas = newPage.canvas
+          
+          val bitmap = Bitmap.createBitmap(page.width, page.height, Bitmap.Config.ARGB_8888)
+          page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+          canvas.drawBitmap(bitmap, 0f, 0f, null)
+          
+          val viewWidth = imageView.width.toFloat()
+          val viewHeight = imageView.height.toFloat()
+          val pdfWidth = page.width.toFloat()
+          val pdfHeight = page.height.toFloat()
+          
+          val scale: Float
+          val dx: Float
+          val dy: Float
+          
+          if (pdfWidth / pdfHeight > viewWidth / viewHeight) {
+              scale = viewWidth / pdfWidth
+              dx = 0f
+              dy = (viewHeight - pdfHeight * scale) * 0.5f
+          } else {
+              scale = viewHeight / pdfHeight
+              dx = (viewWidth - pdfWidth * scale) * 0.5f
+              dy = 0f
+          }
+          
+          canvas.save()
+          canvas.scale(1/scale, 1/scale)
+          canvas.translate(-dx, -dy)
+          drawingView.drawPaths(canvas)
+          canvas.restore()
+          
+          document.finishPage(newPage)
+          page.close()
+      }
+      
+      renderer.close()
+      descriptor.close()
+      
+      val fileName = "saved_pdf_${System.currentTimeMillis()}.pdf"
+      val file = File(context.cacheDir, fileName)
+      val outputStream = FileOutputStream(file)
+      document.writeTo(outputStream)
+      document.close()
+      outputStream.close()
+      
+      return Uri.fromFile(file).toString()
+  }
+
+  private fun downloadFile(urlStr: String): File {
+    val url = URL(urlStr)
+    val connection = url.openConnection()
+    connection.connect()
+    val input = connection.getInputStream()
+    val file = File(context.cacheDir, "temp_${System.currentTimeMillis()}.pdf")
+    val output = FileOutputStream(file)
+    input.copyTo(output)
+    output.close()
+    input.close()
+    return file
+  }
+
+  private fun renderPdf(file: File) {
+    try {
+      fileDescriptor?.close()
+      fileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+      pdfRenderer?.close()
+      pdfRenderer = PdfRenderer(fileDescriptor!!)
+      
+      // Clear existing views
+      container.removeAllViews()
+      
+      when (displayMode) {
+        "single" -> {
+          // Single page mode - show only current page
+          if (pdfRenderer!!.pageCount > 0) {
+            currentPage?.close()
+            currentPage = pdfRenderer!!.openPage(0)
+            
+            val bitmap = Bitmap.createBitmap(
+              currentPage!!.width,
+              currentPage!!.height,
+              Bitmap.Config.ARGB_8888
+            )
+            
+            currentPage!!.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+            
+            val singleImageView = ImageView(context)
+            singleImageView.layoutParams = FrameLayout.LayoutParams(
+              FrameLayout.LayoutParams.MATCH_PARENT,
+              FrameLayout.LayoutParams.WRAP_CONTENT
+            )
+            singleImageView.adjustViewBounds = true
+            singleImageView.scaleType = ImageView.ScaleType.FIT_START
+            singleImageView.setImageBitmap(bitmap)
+            
+            container.addView(singleImageView)
+            container.addView(drawingView)
+          }
+        }
+        "continuous" -> {
+          // Continuous mode - show all pages vertically
+          val verticalContainer = LinearLayout(context)
+          verticalContainer.orientation = LinearLayout.VERTICAL
+          verticalContainer.layoutParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+          )
+          
+          for (i in 0 until pdfRenderer!!.pageCount) {
+            val page = pdfRenderer!!.openPage(i)
+            val bitmap = Bitmap.createBitmap(
+              page.width,
+              page.height,
+              Bitmap.Config.ARGB_8888
+            )
+            page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+            
+            val pageImageView = ImageView(context)
+            pageImageView.layoutParams = LinearLayout.LayoutParams(
+              LinearLayout.LayoutParams.MATCH_PARENT,
+              LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            pageImageView.adjustViewBounds = true
+            pageImageView.scaleType = ImageView.ScaleType.FIT_START
+            pageImageView.setImageBitmap(bitmap)
+            
+            verticalContainer.addView(pageImageView)
+            page.close()
+          }
+          
+          container.addView(verticalContainer)
+          container.addView(drawingView)
+        }
+        "twoUp", "twoUpContinuous" -> {
+          // Two-up mode - show two pages side by side
+          val verticalContainer = LinearLayout(context)
+          verticalContainer.orientation = LinearLayout.VERTICAL
+          verticalContainer.layoutParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+          )
+          
+          var i = 0
+          while (i < pdfRenderer!!.pageCount) {
+            val rowContainer = LinearLayout(context)
+            rowContainer.orientation = LinearLayout.HORIZONTAL
+            rowContainer.layoutParams = LinearLayout.LayoutParams(
+              LinearLayout.LayoutParams.MATCH_PARENT,
+              LinearLayout.LayoutParams.WRAP_CONTENT
+            )
+            
+            // First page
+            val page1 = pdfRenderer!!.openPage(i)
+            val bitmap1 = Bitmap.createBitmap(
+              page1.width,
+              page1.height,
+              Bitmap.Config.ARGB_8888
+            )
+            page1.render(bitmap1, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+            
+            val pageImageView1 = ImageView(context)
+            pageImageView1.layoutParams = LinearLayout.LayoutParams(
+              0,
+              LinearLayout.LayoutParams.WRAP_CONTENT,
+              1.0f
+            )
+            pageImageView1.adjustViewBounds = true
+            pageImageView1.scaleType = ImageView.ScaleType.FIT_START
+            pageImageView1.setImageBitmap(bitmap1)
+            rowContainer.addView(pageImageView1)
+            page1.close()
+            
+            // Second page (if exists)
+            if (i + 1 < pdfRenderer!!.pageCount) {
+              val page2 = pdfRenderer!!.openPage(i + 1)
+              val bitmap2 = Bitmap.createBitmap(
+                page2.width,
+                page2.height,
+                Bitmap.Config.ARGB_8888
+              )
+              page2.render(bitmap2, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+              
+              val pageImageView2 = ImageView(context)
+              pageImageView2.layoutParams = LinearLayout.LayoutParams(
+                0,
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+                1.0f
+              )
+              pageImageView2.adjustViewBounds = true
+              pageImageView2.scaleType = ImageView.ScaleType.FIT_START
+              pageImageView2.setImageBitmap(bitmap2)
+              rowContainer.addView(pageImageView2)
+              page2.close()
+            }
+            
+            verticalContainer.addView(rowContainer)
+            i += 2
+          }
+          
+          container.addView(verticalContainer)
+          container.addView(drawingView)
+        }
+        else -> {
+          // Default to continuous
+          displayMode = "continuous"
+          renderPdf(file)
+          return
+        }
+      }
+      
+      // Re-apply zoom after layout rebuild
+      applyZoom(currentZoom)
+      
+      // Set current page for single mode
+      if (displayMode == "single" && pdfRenderer!!.pageCount > 0) {
+        currentPage?.close()
+        currentPage = pdfRenderer!!.openPage(0)
+      }
+      
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    currentPage?.close()
+    pdfRenderer?.close()
+    fileDescriptor?.close()
+    scope.cancel()
+  }
+  
+  // Inner class for handling drawing
+  inner class DrawingView(context: Context) : View(context) {
+      private var drawPath = Path()
+      private var drawPaint = Paint()
+      private var textPaint = Paint()
+      
+      // Callback
+      var onDrawingChanged: (() -> Unit)? = null
+      
+      // Store raw data for serialization
+      data class AnnotationItem(
+          val path: Path?, 
+          val paint: Paint,
+          val type: String,
+          val color: Int,
+          val points: MutableList<PointF>,
+          val text: String = "",
+          val fontSize: Float = 16f,
+          val x: Float = 0f,
+          val y: Float = 0f
+      )
+      
+      private val items = ArrayList<AnnotationItem>()
+      private val undoStack = ArrayList<AnnotationItem>() // History for undo
+      private val redoStack = ArrayList<AnnotationItem>() // History for redo
+      private var currentPoints = ArrayList<PointF>()
+      private var currentTool = "none"
+      private var currentTextToDraw = "Text"
+      private var currentFontSize = 16f
+      private var baseStrokeWidth = 10f
+      
+      init {
+          setupPaint()
+      }
+      
+      fun hasAnnotations(): Boolean {
+          return items.isNotEmpty()
+      }
+      
+      private fun setupPaint() {
+          drawPaint.color = currentColor
+          drawPaint.isAntiAlias = true
+          drawPaint.strokeWidth = baseStrokeWidth
+          drawPaint.style = Paint.Style.STROKE
+          drawPaint.strokeJoin = Paint.Join.ROUND
+          drawPaint.strokeCap = Paint.Cap.ROUND
+          
+          textPaint.color = currentColor
+          textPaint.isAntiAlias = true
+          textPaint.textSize = currentFontSize
+          textPaint.style = Paint.Style.FILL
+      }
+      
+      fun setTool(tool: String) {
+          currentTool = tool
+          if (tool == "highlighter") {
+              drawPaint.alpha = 80
+              drawPaint.strokeWidth = baseStrokeWidth * 3f
+          } else if (tool == "eraser") {
+              // Eraser doesn't draw, it erases
+          } else {
+              drawPaint.alpha = 255
+              drawPaint.strokeWidth = baseStrokeWidth
+          }
+      }
+      
+      fun setColor(color: Int) {
+          drawPaint.color = color
+          textPaint.color = color
+          if (currentTool == "highlighter") {
+              drawPaint.alpha = 80
+          }
+      }
+      
+      fun setFontSize(size: Float) {
+          currentFontSize = size
+          textPaint.textSize = size
+      }
+      
+      fun setBaseStrokeWidth(width: Float) {
+          baseStrokeWidth = if (width > 0f) width else 1f
+          // Apply to current tool
+          if (currentTool == "highlighter") {
+              drawPaint.strokeWidth = baseStrokeWidth * 3f
+          } else {
+              drawPaint.strokeWidth = baseStrokeWidth
+          }
+      }
+      
+      fun setTextToDraw(text: String) {
+          currentTextToDraw = text
+      }
+      
+      fun drawPaths(canvas: Canvas) {
+          for (item in items) {
+              if (item.type == "text") {
+                  canvas.drawText(item.text, item.x, item.y, item.paint)
+              } else if (item.path != null) {
+                  canvas.drawPath(item.path, item.paint)
+              }
+          }
+      }
+      
+      fun getAnnotations(): List<AnnotationData> {
+          return items.map { item ->
+              val annotation = AnnotationData()
+              annotation.type = item.type
+              annotation.color = String.format("#%06X", (0xFFFFFF and item.color))
+              
+              if (item.type == "text") {
+                  annotation.text = item.text
+                  annotation.fontSize = item.fontSize.toDouble()
+                  annotation.x = item.x.toDouble()
+                  annotation.y = item.y.toDouble()
+              } else {
+                  annotation.width = if (item.type == "highlighter") (baseStrokeWidth * 3f).toDouble() else baseStrokeWidth.toDouble()
+                  val pointsList = ArrayList<Map<String, Double>>()
+                  for (pt in item.points) {
+                      pointsList.add(mapOf("x" to pt.x.toDouble(), "y" to pt.y.toDouble()))
+                  }
+                  annotation.points = listOf(pointsList)
+              }
+              annotation
+          }
+      }
+      
+      fun undo(): Boolean {
+          if (items.isEmpty()) return false
+          
+          val lastItem = items.removeAt(items.size - 1)
+          undoStack.add(lastItem)
+          invalidate()
+          onDrawingChanged?.invoke()
+          return true
+      }
+      
+      fun redo(): Boolean {
+          if (undoStack.isEmpty()) return false
+          
+          val item = undoStack.removeAt(undoStack.size - 1)
+          items.add(item)
+          invalidate()
+          onDrawingChanged?.invoke()
+          return true
+      }
+      
+      fun setAnnotations(annotations: List<AnnotationData>) {
+          items.clear()
+          undoStack.clear()
+          redoStack.clear()
+          for (ann in annotations) {
+              if (ann.type == "text") {
+                  val paint = Paint(textPaint)
+                  try {
+                      paint.color = Color.parseColor(ann.color)
+                  } catch (e: Exception) {
+                      paint.color = Color.BLACK
+                  }
+                  paint.textSize = ann.fontSize.toFloat()
+                  
+                  items.add(AnnotationItem(
+                      null, 
+                      paint, 
+                      "text", 
+                      paint.color, 
+                      ArrayList(), 
+                      ann.text, 
+                      ann.fontSize.toFloat(), 
+                      ann.x.toFloat(), 
+                      ann.y.toFloat()
+                  ))
+              } else {
+                  val path = Path()
+                  val points = ArrayList<PointF>()
+                  
+                  if (ann.points.isNotEmpty()) {
+                      val stroke = ann.points[0]
+                      if (stroke.isNotEmpty()) {
+                          val start = stroke[0]
+                          path.moveTo(start["x"]!!.toFloat(), start["y"]!!.toFloat())
+                          points.add(PointF(start["x"]!!.toFloat(), start["y"]!!.toFloat()))
+                          
+                          for (i in 1 until stroke.size) {
+                              val pt = stroke[i]
+                              path.lineTo(pt["x"]!!.toFloat(), pt["y"]!!.toFloat())
+                              points.add(PointF(pt["x"]!!.toFloat(), pt["y"]!!.toFloat()))
+                          }
+                      }
+                  }
+                  
+                  val paint = Paint()
+                  paint.isAntiAlias = true
+                  paint.style = Paint.Style.STROKE
+                  paint.strokeJoin = Paint.Join.ROUND
+                  paint.strokeCap = Paint.Cap.ROUND
+                  
+                  try {
+                      paint.color = Color.parseColor(ann.color)
+                  } catch (e: Exception) {
+                      paint.color = Color.BLACK
+                  }
+                  
+                  if (ann.type == "highlighter") {
+                      paint.alpha = 80
+                      paint.strokeWidth = 30f
+                  } else {
+                      paint.alpha = 255
+                      paint.strokeWidth = 10f
+                  }
+                  
+                  val colorInt = paint.color
+                  items.add(AnnotationItem(path, paint, ann.type, colorInt, points))
+              }
+          }
+          invalidate()
+      }
+      
+      override fun onDraw(canvas: Canvas) {
+          super.onDraw(canvas)
+          for (item in items) {
+              if (item.type == "text") {
+                  canvas.drawText(item.text, item.x, item.y, item.paint)
+              } else if (item.path != null) {
+                  canvas.drawPath(item.path, item.paint)
+              }
+          }
+          if (currentTool != "none" && currentTool != "text") {
+              canvas.drawPath(drawPath, drawPaint)
+          }
+      }
+      
+      private fun findAnnotationAt(x: Float, y: Float, tolerance: Float = 20f): AnnotationItem? {
+          // Check items in reverse order (most recent first)
+          for (i in items.size - 1 downTo 0) {
+              val item = items[i]
+              
+              if (item.type == "text") {
+                  // Check if point is near text
+                  val textBounds = Rect()
+                  item.paint.getTextBounds(item.text, 0, item.text.length, textBounds)
+                  val textWidth = item.paint.measureText(item.text)
+                  val textHeight = textBounds.height().toFloat()
+                  
+                  if (x >= item.x - tolerance && x <= item.x + textWidth + tolerance &&
+                      y >= item.y - textHeight - tolerance && y <= item.y + tolerance) {
+                      return item
+                  }
+              } else if (item.path != null) {
+                  // Check if point is on or near the path
+                  val region = Region()
+                  val rect = RectF()
+                  item.path.computeBounds(rect, true)
+                  rect.inset(-tolerance, -tolerance)
+                  
+                  region.setPath(item.path, Region(rect.left.toInt(), rect.top.toInt(), rect.right.toInt(), rect.bottom.toInt()))
+                  if (region.contains(x.toInt(), y.toInt())) {
+                      return item
+                  }
+                  
+                  // Also check if point is near any point in the path
+                  for (pt in item.points) {
+                      val dx = pt.x - x
+                      val dy = pt.y - y
+                      if (dx * dx + dy * dy <= tolerance * tolerance) {
+                          return item
+                      }
+                  }
+              }
+          }
+          return null
+      }
+      
+      override fun onTouchEvent(event: MotionEvent): Boolean {
+          if (currentTool == "none") return false
+          
+          val touchX = event.x
+          val touchY = event.y
+          
+          if (currentTool == "eraser") {
+              when (event.action) {
+                  MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE -> {
+                      val item = findAnnotationAt(touchX, touchY)
+                      if (item != null) {
+                          items.remove(item)
+                          undoStack.add(item)
+                          redoStack.clear()
+                          invalidate()
+                          onDrawingChanged?.invoke()
+                      }
+                  }
+              }
+              return true
+          }
+          
+          if (currentTool == "text") {
+              if (event.action == MotionEvent.ACTION_UP) {
+                  val paint = Paint(textPaint)
+                  val newItem = AnnotationItem(
+                      null, 
+                      paint, 
+                      "text", 
+                      paint.color, 
+                      ArrayList(), 
+                      currentTextToDraw, 
+                      currentFontSize, 
+                      touchX, 
+                      touchY
+                  )
+                  items.add(newItem)
+                  
+                  // Clear redo stack when new action is performed
+                  redoStack.clear()
+                  
+                  invalidate()
+                  onDrawingChanged?.invoke()
+              }
+              return true
+          }
+          
+          when (event.action) {
+              MotionEvent.ACTION_DOWN -> {
+                  drawPath.moveTo(touchX, touchY)
+                  currentPoints.clear()
+                  currentPoints.add(PointF(touchX, touchY))
+              }
+              MotionEvent.ACTION_MOVE -> {
+                  drawPath.lineTo(touchX, touchY)
+                  currentPoints.add(PointF(touchX, touchY))
+              }
+              MotionEvent.ACTION_UP -> {
+                  drawPath.lineTo(touchX, touchY)
+                  currentPoints.add(PointF(touchX, touchY))
+                  
+                  val newPaint = Paint(drawPaint)
+                  val newPath = Path(drawPath)
+                  val newPoints = ArrayList(currentPoints)
+                  
+                  val newItem = AnnotationItem(newPath, newPaint, currentTool, drawPaint.color, newPoints)
+                  items.add(newItem)
+                  
+                  // Clear redo stack when new action is performed
+                  redoStack.clear()
+                  
+                  drawPath.reset()
+                  
+                  // Trigger callback
+                  onDrawingChanged?.invoke()
+              }
+              else -> return false
+          }
+          invalidate()
+          return true
+      }
+  }
+}