react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/DocumentPreviewView.kt

@@ -0,0 +1,846 @@
+package com.customcamera
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.pdf.PdfRenderer
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelFileDescriptor
+import android.util.LruCache
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.ViewGroup
+import android.webkit.WebResourceRequest
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.ProgressBar
+import android.widget.ScrollView
+import android.widget.TextView
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.Event
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.RejectedExecutionException
+
+/**
+ * ViewManager for a native, dependency-free IN-APP document preview used by the full-screen
+ * media viewer. Replaces the old "Open" → external ACTION_VIEW hand-off for the formats Android
+ * can render itself — the document is shown directly inside the existing preview screen, keeping
+ * the viewer's paging, counter and close chrome intact.
+ *
+ * Renderers (all standard Android framework — no third-party preview library):
+ *  - `pdf`   → [PdfRenderer] pages in a vertically scrolling [RecyclerView]. Pages are rasterized
+ *              lazily on a single background thread at (capped) view width and held in a
+ *              heap-bounded [LruCache], so a 200-page PDF costs only the on-screen pages.
+ *  - `text`  → plain text (TXT/LOG/…) in a scrollable [TextView]; `code` is the same renderer
+ *              with a monospace face for structured text (JSON/XML/CSV). Reads are size-capped
+ *              and binary content is rejected instead of rendered as garbage.
+ *  - `html`  → a locked-down [WebView] (JavaScript, file/content access and network loads all
+ *              disabled; navigation blocked) fed the file's bytes directly, so it behaves as a
+ *              static document renderer rather than a browser.
+ *  - `image` → image-based documents decoded with inSampleSize down-sampling into an ImageView.
+ *
+ * The React side chooses the renderer via the `kind` prop (it owns the extension/MIME mapping and
+ * the unsupported-format info card) and listens for `onPreviewLoad` (`{pageCount}`) /
+ * `onPreviewError` (`{message}`) to fall back to the card when a file can't actually be rendered.
+ * `active` mirrors the viewer's visible-page gate (like the audio/video cells): PDF page bitmaps
+ * are only rasterized while the slide is the active page, so the pager's mounted-but-off-screen
+ * neighbours never stack up full-width page bitmaps on low-RAM devices.
+ */
+class DocumentPreviewViewManager : SimpleViewManager<DocumentPreviewView>() {
+  override fun getName() = "CustomDocumentPreview"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): DocumentPreviewView =
+    DocumentPreviewView(reactContext)
+
+  override fun onDropViewInstance(view: DocumentPreviewView) {
+    view.release()
+    super.onDropViewInstance(view)
+  }
+
+  @ReactProp(name = "src")
+  fun setSrc(view: DocumentPreviewView, src: String?) {
+    view.setSource(src)
+  }
+
+  @ReactProp(name = "kind")
+  fun setKind(view: DocumentPreviewView, kind: String?) {
+    view.setKind(kind)
+  }
+
+  @ReactProp(name = "active", defaultBoolean = true)
+  fun setActive(view: DocumentPreviewView, active: Boolean) {
+    view.setActive(active)
+  }
+
+  // Merge with the base constants (à la BaseViewManager) instead of replacing them, so
+  // framework events like topAccessibilityAction keep working on this view type.
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val constants: MutableMap<String, Any> =
+      super.getExportedCustomDirectEventTypeConstants() ?: mutableMapOf()
+    constants["topPreviewLoad"] = mutableMapOf("registrationName" to "onPreviewLoad")
+    constants["topPreviewError"] = mutableMapOf("registrationName" to "onPreviewError")
+    return constants
+  }
+}
+
+/** Direct event carrying either the load result or a render failure to the React side. */
+private class DocumentPreviewEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val name: String,
+  private val payload: WritableMap
+) : Event<DocumentPreviewEvent>(surfaceId, viewId) {
+  override fun getEventName() = name
+  override fun getEventData(): WritableMap = payload
+  // Load/error are one-shot state transitions — never merge two into one delivery.
+  override fun canCoalesce(): Boolean = false
+}
+
+class DocumentPreviewView(context: Context) : FrameLayout(context) {
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  private val theme = CameraTheme.get(context)
+  private val accentColor =
+    theme.componentColor("documentPreview", "accent", Color.parseColor("#4A56FF"))
+  private val textColor =
+    theme.componentColor("documentPreview", "text", Color.parseColor("#E2E8F0"))
+  private val textBackground =
+    theme.componentColor("documentPreview", "textBackground", Color.parseColor("#0B0D1F"))
+  /** Unrendered-page / web-view backing; stock white so pages read as paper. */
+  private val pageBackground =
+    theme.componentColor("documentPreview", "pageBackground", Color.WHITE)
+
+  /**
+   * Single worker thread owning ALL file/PdfRenderer access. PdfRenderer is not thread-safe, so
+   * serializing every open/render/close on one executor removes the need for locks entirely —
+   * a close posted after a render can never interleave with it.
+   */
+  private var executor: ExecutorService? = null
+
+  /**
+   * Monotonic load generation. Every async hop (worker job, main-thread post) captures the
+   * generation it was started under and bails if a newer load/reset has since superseded it,
+   * so a recycled or re-sourced view can never apply a stale document's content.
+   */
+  @Volatile private var generation = 0
+
+  private var currentSrc: String? = null
+  private var currentKind: String? = null
+  private var isActive = true
+  /** Set by [release]; no reload or worker may start afterwards (a posted reload could
+   *  otherwise recreate the executor thread on a dropped view and leak it). */
+  private var released = false
+
+  // ── PDF state ──
+  private var pdfRenderer: PdfRenderer? = null
+  private var pdfFd: ParcelFileDescriptor? = null
+  private var tempPdfFile: File? = null
+  private var pageCache: LruCache<Int, Bitmap>? = null
+  private val pageAspects = HashMap<Int, Float>()
+  private val pendingPages = HashSet<Int>()
+  private var pdfAdapter: PageAdapter? = null
+  private var recycler: RecyclerView? = null
+
+  // ── HTML state ──
+  private var webView: WebView? = null
+
+  init {
+    setBackgroundColor(Color.TRANSPARENT)
+  }
+
+  private val measureAndLayout = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+    )
+    layout(left, top, right, bottom)
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    post(measureAndLayout)
+  }
+
+  fun setSource(src: String?) {
+    if (src == currentSrc) return
+    currentSrc = src
+    scheduleReload()
+  }
+
+  fun setKind(kind: String?) {
+    if (kind == currentKind) return
+    currentKind = kind
+    scheduleReload()
+  }
+
+  fun setActive(active: Boolean) {
+    if (active == isActive) return
+    isActive = active
+    if (active) pdfAdapter?.notifyDataSetChanged()
+  }
+
+  fun release() {
+    released = true
+    resetContent()
+    executor?.shutdown()
+    executor = null
+  }
+
+  // ── Loading pipeline ─────────────────────────────────────────────
+
+  private var reloadScheduled = false
+
+  private fun scheduleReload() {
+    if (reloadScheduled) return
+    reloadScheduled = true
+    mainHandler.post {
+      reloadScheduled = false
+      reload()
+    }
+  }
+
+  private fun reload() {
+    if (released) return
+    resetContent()
+    val src = currentSrc ?: return
+    val kind = currentKind ?: return
+    val gen = generation
+    val uri = Uri.parse(src)
+    showLoading()
+    when (kind) {
+      "pdf" -> loadPdf(uri, gen)
+      "text" -> loadText(uri, monospace = false, gen = gen)
+      "code" -> loadText(uri, monospace = true, gen = gen)
+      "html" -> loadHtml(uri, gen)
+      "image" -> loadImage(uri, gen)
+      "ppt", "pptx" -> loadPowerPoint(uri, kind, gen)
+      "docx", "xlsx", "odt", "ods", "rtf", "csv", "epub" -> loadOffice(uri, kind, gen)
+      else -> postError(gen, Localization.getString("unsupportedPreviewKind", "Unsupported preview kind: {0}", kind))
+    }
+  }
+
+  private fun resetContent() {
+    generation++
+    removeAllViews()
+    recycler = null
+    pdfAdapter = null
+    pendingPages.clear()
+    pageAspects.clear()
+    pageCache?.evictAll()
+    pageCache = null
+    webView?.let { web ->
+      try { web.stopLoading(); web.destroy() } catch (_: Exception) {}
+    }
+    webView = null
+    powerPointPresentation?.release()
+    powerPointPresentation = null
+    powerPointAdapter = null
+    if (executor != null) {
+      runOnWorker {
+        try { pdfRenderer?.close() } catch (_: Exception) {}
+        try { pdfFd?.close() } catch (_: Exception) {}
+        pdfRenderer = null
+        pdfFd = null
+        tempPdfFile?.delete(); tempPdfFile = null
+        tempOfficeFile?.delete(); tempOfficeFile = null
+      }
+    }
+  }
+
+  private fun runOnWorker(block: () -> Unit) {
+    val exec = executor
+      ?: Executors.newSingleThreadExecutor { r ->
+        Thread(r, "DocumentPreview").apply { priority = Thread.NORM_PRIORITY - 1 }
+      }.also { executor = it }
+    try { exec.execute(block) } catch (_: RejectedExecutionException) {}
+  }
+
+  private fun showLoading() {
+    val spinner = ProgressBar(context).apply {
+      isIndeterminate = true
+      indeterminateTintList = ColorStateList.valueOf(accentColor)
+    }
+    removeAllViews()
+    addView(spinner, LayoutParams(dp(40), dp(40), Gravity.CENTER))
+  }
+
+  private fun attachContent(
+    view: android.view.View,
+    params: LayoutParams = LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+  ) {
+    removeAllViews()
+    addView(view, params)
+  }
+
+  private fun postError(gen: Int, message: String) {
+    mainHandler.post {
+      if (gen != generation) return@post
+      removeAllViews()
+      emitEvent("topPreviewError", Arguments.createMap().apply { putString("message", message) })
+    }
+  }
+
+  private fun emitLoaded(pageCount: Int) {
+    emitEvent("topPreviewLoad", Arguments.createMap().apply { putInt("pageCount", pageCount) })
+  }
+
+  private fun emitEvent(name: String, payload: WritableMap) {
+    val reactContext = context as? ReactContext ?: return
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id) ?: return
+    dispatcher.dispatchEvent(
+      DocumentPreviewEvent(UIManagerHelper.getSurfaceId(reactContext), id, name, payload)
+    )
+  }
+
+  // ── PDF ──────────────────────────────────────────────────────────
+
+  private fun loadPdf(uri: Uri, gen: Int) {
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val fd: ParcelFileDescriptor
+      val renderer: PdfRenderer
+      try {
+        fd = openSeekableFd(uri)
+        renderer = PdfRenderer(fd)
+      } catch (e: Exception) {
+        postError(gen, Localization.getString("couldNotOpenPdf", "Could not open PDF: {0}", e.message ?: ""))
+        return@runOnWorker
+      }
+      if (gen != generation) {
+        try { renderer.close() } catch (_: Exception) {}
+        try { fd.close() } catch (_: Exception) {}
+        return@runOnWorker
+      }
+      pdfRenderer = renderer
+      pdfFd = fd
+      val pageCount = renderer.pageCount
+      mainHandler.post {
+        if (gen != generation) return@post
+        showPdfUi(pageCount)
+      }
+    }
+  }
+
+  private fun openSeekableFd(uri: Uri): ParcelFileDescriptor {
+    val resolver = context.contentResolver
+    try {
+      val direct = resolver.openFileDescriptor(uri, "r")
+      if (direct != null) {
+        if (direct.statSize >= 0) return direct
+        try { direct.close() } catch (_: Exception) {}
+      }
+    } catch (_: Exception) {}
+    val input = resolver.openInputStream(uri)
+      ?: throw IOException("Cannot open document stream")
+    val temp = File.createTempFile("doc_preview_", ".pdf", context.cacheDir)
+    input.use { stream -> FileOutputStream(temp).use { out -> stream.copyTo(out) } }
+    tempPdfFile = temp
+    return ParcelFileDescriptor.open(temp, ParcelFileDescriptor.MODE_READ_ONLY)
+  }
+
+  private fun showPdfUi(pageCount: Int) {
+    val cacheKb = (Runtime.getRuntime().maxMemory() / 1024L / 16L).toInt().coerceAtLeast(4096)
+    pageCache = object : LruCache<Int, Bitmap>(cacheKb) {
+      override fun sizeOf(key: Int, value: Bitmap): Int = value.byteCount / 1024
+    }
+    val rv = RecyclerView(context).apply {
+      layoutManager = LinearLayoutManager(context)
+      itemAnimator = null
+    }
+    val adapter = PageAdapter(pageCount)
+    rv.adapter = adapter
+    pdfAdapter = adapter
+    recycler = rv
+    attachContent(rv, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER))
+    emitLoaded(pageCount)
+  }
+
+  private fun pageRenderWidth(): Int {
+    val base = recycler?.let { it.width - it.paddingLeft - it.paddingRight }?.takeIf { it > 0 }
+      ?: width.takeIf { it > 0 }
+      ?: resources.displayMetrics.widthPixels
+    return base.coerceIn(240, maxRenderDimension())
+  }
+
+  private fun maxRenderDimension(): Int {
+    val am = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+    return if (am?.isLowRamDevice == true) 1080 else 1600
+  }
+
+  private fun requestPageRender(index: Int) {
+    if (!isActive) return
+    if (!pendingPages.add(index)) return
+    val gen = generation
+    val targetWidth = pageRenderWidth()
+    runOnWorker {
+      if (gen != generation) { mainHandler.post { pendingPages.remove(index) }; return@runOnWorker }
+      val renderer = pdfRenderer
+      if (renderer == null) { mainHandler.post { pendingPages.remove(index) }; return@runOnWorker }
+      var bitmap: Bitmap? = null
+      var aspect = DEFAULT_PAGE_ASPECT
+      try {
+        val page = renderer.openPage(index)
+        try {
+          var scale = targetWidth.toFloat() / page.width
+          if (page.height * scale > MAX_PAGE_BITMAP_HEIGHT) scale = MAX_PAGE_BITMAP_HEIGHT.toFloat() / page.height
+          val w = (page.width * scale).toInt().coerceAtLeast(1)
+          val h = (page.height * scale).toInt().coerceAtLeast(1)
+          val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+          bmp.eraseColor(pageBackground)
+          page.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+          aspect = page.height.toFloat() / page.width.toFloat()
+          bitmap = bmp
+        } finally { page.close() }
+      } catch (_: Throwable) { bitmap?.recycle(); bitmap = null }
+      val rendered = bitmap
+      mainHandler.post {
+        pendingPages.remove(index)
+        if (gen != generation) { rendered?.recycle(); return@post }
+        if (rendered != null) { pageAspects[index] = aspect; pageCache?.put(index, rendered); pdfAdapter?.notifyItemChanged(index) }
+      }
+    }
+  }
+
+  private inner class PageAdapter(private val pages: Int) : RecyclerView.Adapter<PageAdapter.PageHolder>() {
+    inner class PageHolder(val image: ImageView) : RecyclerView.ViewHolder(image)
+    override fun getItemCount(): Int = pages
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PageHolder {
+      val image = ImageView(parent.context).apply {
+        setBackgroundColor(pageBackground); scaleType = ImageView.ScaleType.FIT_XY
+        layoutParams = RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+      }
+      return PageHolder(image)
+    }
+    override fun onBindViewHolder(holder: PageHolder, position: Int) {
+      val listWidth = pageRenderWidth()
+      val aspect = pageAspects[position] ?: DEFAULT_PAGE_ASPECT
+      val lp = holder.image.layoutParams as RecyclerView.LayoutParams
+      lp.height = (listWidth * aspect).toInt().coerceAtLeast(1)
+      lp.bottomMargin = if (position == pages - 1) 0 else dp(6)
+      holder.image.layoutParams = lp
+      val cached = pageCache?.get(position)
+      if (cached != null) holder.image.setImageBitmap(cached) else { holder.image.setImageBitmap(null); requestPageRender(position) }
+    }
+    override fun onViewRecycled(holder: PageHolder) { holder.image.setImageBitmap(null); super.onViewRecycled(holder) }
+  }
+
+  // ── Plain / structured text ──────────────────────────────────────
+
+  private fun loadText(uri: Uri, monospace: Boolean, gen: Int) {
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val text: String; val truncated: Boolean
+      try {
+        val (bytes, wasTruncated) = readCapped(uri, MAX_TEXT_BYTES)
+        if (looksBinary(bytes)) { postError(gen, Localization.getString("fileNotPreviewableText", "File is not previewable text")); return@runOnWorker }
+        text = String(bytes, Charsets.UTF_8).removePrefix("\uFEFF"); truncated = wasTruncated
+      } catch (e: Exception) { postError(gen, Localization.getString("couldNotReadFile", "Could not read file: {0}", e.message ?: "")); return@runOnWorker }
+      mainHandler.post { if (gen != generation) return@post; showTextUi(text, monospace, truncated) }
+    }
+  }
+
+  private fun showTextUi(text: String, monospace: Boolean, truncated: Boolean) {
+    val body = buildString { append(text.ifBlank { Localization.getString("emptyFile", "(empty file)") }); if (truncated) append("\n\n… " + Localization.getString("previewTruncated", "preview truncated")) }
+    val textView = TextView(context).apply {
+      setTextColor(textColor); setTextSize(TypedValue.COMPLEX_UNIT_SP, if (monospace) 12.5f else 14f)
+      typeface = if (monospace) Typeface.MONOSPACE else Typeface.DEFAULT
+      setLineSpacing(0f, 1.35f); setPadding(dp(16), dp(14), dp(16), dp(24)); this.text = body
+    }
+    val scroll = ScrollView(context).apply {
+      isFillViewport = true; setBackgroundColor(textBackground); isVerticalScrollBarEnabled = true
+      addView(textView, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT))
+    }
+    attachContent(scroll); emitLoaded(0)
+  }
+
+  // ── HTML ─────────────────────────────────────────────────────────
+
+  private fun loadHtml(uri: Uri, gen: Int) {
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val html: String
+      try { val (bytes, _) = readCapped(uri, MAX_HTML_BYTES); html = String(bytes, Charsets.UTF_8).removePrefix("\uFEFF") }
+      catch (e: Exception) { postError(gen, Localization.getString("couldNotReadFile", "Could not read file: {0}", e.message ?: "")); return@runOnWorker }
+      mainHandler.post { if (gen != generation) return@post; showHtmlUi(html, gen) }
+    }
+  }
+
+  private fun showHtmlUi(html: String, gen: Int, wideViewport: Boolean = false, pageCount: Int = 0) {
+    val web = try { WebView(context) } catch (e: Exception) { postError(gen, Localization.getString("webViewUnavailable", "WebView unavailable: {0}", e.message ?: "")); return }
+    web.settings.apply {
+      javaScriptEnabled = false; allowFileAccess = false; allowContentAccess = false
+      blockNetworkLoads = true; loadWithOverviewMode = true; useWideViewPort = wideViewport
+      builtInZoomControls = true; displayZoomControls = false
+    }
+    web.webViewClient = object : WebViewClient() { override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest) = true }
+    web.setBackgroundColor(pageBackground)
+    // Overscroll glow is pure overdraw on a static document; dropping it removes work per frame.
+    web.overScrollMode = android.view.View.OVER_SCROLL_NEVER
+    web.loadDataWithBaseURL(null, html, "text/html", "utf-8", null)
+    webView = web
+    // MATCH_PARENT (an EXACTLY height), NOT wrap_content. A WebView measured with wrap_content
+    // (an AT_MOST spec) drops out of Chromium's GPU-composited *tiled* scrolling and re-rasterizes
+    // its whole content on every scroll frame — that was the "laggy, not smooth" scroll on every
+    // non-PDF (Office) document. A bounded height puts it back on the fast composited path and lets
+    // the WebView scroll its own overflow internally. (Short documents now top-align instead of
+    // centring, which reads correctly for a document; do NOT restore wrap_content to re-centre.)
+    attachContent(web)
+    emitLoaded(pageCount)
+  }
+
+  private fun buildPowerPointSlideHtml(file: File, extractedText: String): String {
+    val segments = extractedText.split(Regex("\n\\s*\n+")).map { it.trim() }.filter { it.isNotBlank() }
+    val slideCss = ".pptx-slide{font-family:Calibri,\"Segoe UI\",sans-serif;color:#0F172A;background:#FFFFFF;border-radius:6pt;padding:20pt 24pt;line-height:1.6;box-shadow:0 4px 12px rgba(0,0,0,0.15);margin:12pt auto;box-sizing:border-box;}" +
+      ".pptx-slide h1{font-size:20pt;font-weight:700;color:#0F172A;margin:0 0 10pt 0;border-bottom:2pt solid #E2E8F0;padding-bottom:8pt;}" +
+      ".pptx-slide .slide-num{display:inline-block;background:#4A56FF;color:#FFF;font-size:9pt;font-weight:700;padding:2pt 8pt;border-radius:4pt;margin-bottom:10pt;letter-spacing:0.5pt;}" +
+      ".pptx-slide .slide-text{font-size:12pt;color:#1E293B;white-space:pre-wrap;word-wrap:break-word;line-height:1.6;}"
+    val sb = StringBuilder()
+    if (segments.size <= 1) {
+      sb.append("<div class=\"sheet pptx-slide\"><div class=\"slide-num\">${Localization.getString("slideNumberLabel", "SLIDE {0}", 1)}</div><div class=\"slide-text\">${Ox.esc(extractedText)}</div></div>")
+    } else {
+      for ((idx, segment) in segments.take(50).withIndex()) {
+        sb.append("<div class=\"sheet pptx-slide\"><div class=\"slide-num\">${Localization.getString("slideNumberLabel", "SLIDE {0}", idx + 1)}</div><div class=\"slide-text\">${Ox.esc(segment)}</div></div>")
+      }
+    }
+    return Ox.shell(612f, slideCss, sb.toString())
+  }
+
+  // ── PowerPoint presentations (PPT/PPTX) ──────────────────────────
+
+  private var powerPointPresentation: PowerPointPresentation? = null
+  private var powerPointAdapter: PowerPointPreviewAdapter? = null
+
+  private fun loadPowerPoint(uri: Uri, kind: String, gen: Int) {
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val src: File
+      try {
+        src = materializeFile(uri, kind)
+      } catch (e: Throwable) {
+        val name = uri.lastPathSegment ?: Localization.getString("powerPointPresentationTitle", "PowerPoint presentation")
+        val errorPresentation = PowerPointDocumentProcessor.errorPresentation(
+          name,
+          Localization.getString("couldNotOpenPresentation", "Could not open presentation: {0}", e.message ?: "")
+        )
+        mainHandler.post {
+          if (gen != generation) return@post
+          showPowerPointUi(errorPresentation)
+        }
+        return@runOnWorker
+      }
+
+      val presentation: PowerPointPresentation
+      try {
+        presentation = PowerPointDocumentProcessor.process(src, kind)
+      } catch (e: Throwable) {
+        val errorPresentation = PowerPointDocumentProcessor.errorPresentation(
+          src.name,
+          Localization.getString("couldNotReadPowerPoint", "Could not read PowerPoint presentation: {0}", e.message ?: "")
+        )
+        mainHandler.post {
+          if (gen != generation) return@post
+          showPowerPointUi(errorPresentation)
+        }
+        return@runOnWorker
+      }
+
+      if (gen != generation) {
+        presentation.release()
+        return@runOnWorker
+      }
+      mainHandler.post {
+        if (gen != generation) {
+          presentation.release()
+          return@post
+        }
+        showPowerPointUi(presentation)
+      }
+    }
+  }
+
+  private fun showPowerPointUi(presentation: PowerPointPresentation) {
+    powerPointPresentation?.release()
+    powerPointPresentation = presentation
+    val rv = RecyclerView(context).apply {
+      layoutManager = LinearLayoutManager(context)
+      itemAnimator = null
+      setBackgroundColor(Color.TRANSPARENT)
+    }
+    val adapter = PowerPointPreviewAdapter(context, presentation) { pageRenderWidth() }
+    rv.adapter = adapter
+    recycler = rv
+    powerPointAdapter = adapter
+    attachContent(rv, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER))
+    emitLoaded(presentation.slides.size)
+  }
+
+  // ── Office documents (DOCX/XLSX/ODT/ODS/RTF/CSV/EPUB) ──────
+
+  private var tempOfficeFile: File? = null
+
+  private fun loadOffice(uri: Uri, kind: String, gen: Int) {
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val src: File
+      try { src = materializeFile(uri, kind) } catch (e: Throwable) { postError(gen, Localization.getString("couldNotOpenDocument", "Could not open document: {0}", e.message ?: "")); return@runOnWorker }
+      val conversion: OfficeDocumentConverter.Conversion
+      try { conversion = OfficeDocumentConverter.convert(src, kind) }
+      catch (e: Throwable) {
+        val fallback = extractOfficeTextFallback(src)
+        if (fallback != null) { mainHandler.post { if (gen != generation) return@post; showHtmlUi(fallback, gen) }; return@runOnWorker }
+        postError(gen, Localization.getString("couldNotConvertDocument", "Could not convert document: {0}", e.message ?: "")); return@runOnWorker
+      }
+      if (gen != generation) return@runOnWorker
+      mainHandler.post { if (gen != generation) return@post; showHtmlUi(conversion.html, gen, wideViewport = true, pageCount = conversion.pageCount) }
+    }
+  }
+
+  /**
+   * Best-effort fallback for office documents. Three strategies in order:
+   *
+   * 1. ZIP XML text extraction — works for OOXML/ODF containers (.docx, .xlsx, .odt, etc.)
+   *    when the primary converter failed. Extracts slide/document text and renders as HTML.
+   *
+   * 2. Binary-era text extraction + info card — for .doc / .xls (proprietary binary OLE
+   *    formats). Extracts readable text runs from the binary and renders them as slide-like HTML,
+   *    topped with a neutral info note suggesting the external app for full fidelity. This gives
+   *    users *something* to look at rather than a bare "unsupported" message.
+   *
+   * 3. Generic informational card — catch-all for any other unextractable format.
+   */
+  private fun extractOfficeTextFallback(file: File): String? {
+    // ── Strategy 1: ZIP XML text extraction ──
+    try {
+      java.util.zip.ZipFile(file).use { zip ->
+        val sb = StringBuilder()
+        val entries = zip.entries()
+        while (entries.hasMoreElements()) {
+          val entry = entries.nextElement()
+          val name = entry.name
+          if (!name.endsWith(".xml") && !name.endsWith(".txt")) continue
+          val isContent = name.matches(Regex("ppt/slides/slide\\d+\\.xml")) ||
+            name == "word/document.xml" || name == "xl/sharedStrings.xml" ||
+            name == "content.xml" || name.endsWith("/document.xml")
+          if (!isContent) continue
+          zip.getInputStream(entry).use { stream ->
+            val xml = String(stream.readBytes(), Charsets.UTF_8)
+            val text = xml.replace(Regex("<[^>]+>"), " ").replace(Regex("\\s+"), " ").trim()
+            if (text.isNotBlank()) sb.appendLine(text).appendLine()
+          }
+        }
+        val extracted = sb.toString().trim()
+        if (extracted.length > 20) return buildPowerPointSlideHtml(file, extracted)
+      }
+    } catch (_: Throwable) { /* Not a valid ZIP — fall through. */ }
+
+    // ── Strategy 2: Binary text extraction + info card ──
+    val ext = file.name.substringAfterLast('.', "").lowercase()
+    if (ext in setOf("doc", "xls")) {
+      val extractedText = extractBinaryText(file)
+      val formatLabel = when (ext) { "ppt" -> "PowerPoint"; "doc" -> "Word"; "xls" -> "Excel"; else -> "Office" }
+      val sizeKb = (file.length() / 1024)
+      val sizeLabel = if (sizeKb > 1024) "${sizeKb / 1024} MB" else "$sizeKb KB"
+
+      val infoCss = ".legacy-info{font-family:-apple-system,sans-serif;color:#0F172A;}" +
+        ".legacy-info .info-card{background:#FFFFFF;border-radius:6pt;padding:16pt 20pt;margin:12pt auto;box-shadow:0 2px 8px rgba(0,0,0,0.1);text-align:center;max-width:520pt;}" +
+        ".legacy-info .info-card h2{font-size:14pt;margin:0 0 4pt 0;color:#0F172A;}" +
+        ".legacy-info .info-card .meta{color:#64748B;font-size:10pt;margin-bottom:8pt;}" +
+        ".legacy-info .info-card .msg{color:#334155;font-size:11pt;line-height:1.5;}" +
+        ".pptx-slide{font-family:Calibri,\"Segoe UI\",sans-serif;color:#0F172A;background:#FFFFFF;border-radius:6pt;padding:16pt 20pt;line-height:1.5;box-shadow:0 2px 8px rgba(0,0,0,0.1);margin:10pt auto;box-sizing:border-box;}" +
+        ".pptx-slide .slide-num{display:inline-block;background:#4A56FF;color:#FFF;font-size:8pt;font-weight:700;padding:2pt 6pt;border-radius:3pt;margin-bottom:6pt;}" +
+        ".pptx-slide .slide-text{font-size:11pt;color:#1E293B;white-space:pre-wrap;word-wrap:break-word;}"
+
+      val body = StringBuilder()
+      // Info card at the top
+      body.append("<div class=\"info-card\">")
+      body.append("<h2>${Ox.esc(file.name)}</h2>")
+      body.append("<div class=\"meta\">$formatLabel · $sizeLabel</div>")
+      body.append("<div class=\"msg\">" + Localization.getString("officeBinaryPreviewNote", "Text preview shown below — open in PowerPoint, Google Slides, or WPS Office for full formatting and images.") + "</div>")
+      body.append("</div>")
+
+      if (extractedText.length > 20) {
+        // Render extracted text as slides
+        val segments = extractedText.split(Regex("\n\\s*\n+")).map { it.trim() }.filter { it.isNotBlank() }
+        if (segments.size <= 1) {
+          body.append("<div class=\"pptx-slide\"><div class=\"slide-num\">${Localization.getString("slideNumberLabel", "SLIDE {0}", 1)}</div><div class=\"slide-text\">${Ox.esc(extractedText)}</div></div>")
+        } else {
+          for ((idx, segment) in segments.take(50).withIndex()) {
+            body.append("<div class=\"pptx-slide\"><div class=\"slide-num\">${Localization.getString("slideNumberLabel", "SLIDE {0}", idx + 1)}</div><div class=\"slide-text\">${Ox.esc(segment)}</div></div>")
+          }
+        }
+      } else {
+        // No extractable text — show the info card alone
+        body.append("<div class=\"info-card\" style=\"margin-top:0;\"><div class=\"msg\">" + Localization.getString("unableToExtractBinaryText", "Unable to extract text from this binary file. Open in PowerPoint for the best experience.") + "</div></div>")
+      }
+
+      return Ox.shell(612f, infoCss, body.toString())
+    }
+
+    // ── Strategy 3: Generic card ──
+    val formatLabel = when (ext.uppercase()) {
+      "PPT", "PPTX" -> Localization.getString("docTypePowerpoint", "PowerPoint Presentation")
+      "DOC", "DOCX" -> Localization.getString("docTypeWord", "Word Document")
+      "XLS", "XLSX" -> Localization.getString("docTypeExcel", "Excel Spreadsheet")
+      else -> Localization.getString("docTypeOffice", "Office Document")
+    }
+    val sizeKb = (file.length() / 1024)
+    val sizeLabel = if (sizeKb > 1024) "${sizeKb / 1024} MB" else "$sizeKb KB"
+    return Ox.shell(612f,
+      ".fallback{font-family:-apple-system,sans-serif;padding:24pt;background:#FFFFFF;color:#0F172A;text-align:center;border-radius:6pt;margin:16pt auto;box-shadow:0 4px 12px rgba(0,0,0,0.15);}" +
+        ".fallback .icon{font-size:48pt;margin-bottom:12pt;}.fallback h2{font-size:16pt;margin:0 0 6pt 0;}" +
+        ".fallback .format{display:inline-block;background:#E2E8F0;color:#334155;font-size:10pt;font-weight:600;padding:3pt 8pt;border-radius:4pt;margin-bottom:10pt;}" +
+        ".fallback .size{color:#64748B;font-size:10pt;margin-bottom:16pt;}" +
+        ".fallback .msg{color:#334155;font-size:12pt;line-height:1.6;max-width:400pt;margin:0 auto;}",
+      "<div class=\"sheet fallback\"><div class=\"icon\">📊</div><h2>${Ox.esc(file.name)}</h2>" +
+        "<div class=\"format\">$formatLabel</div><div class=\"size\">$sizeLabel</div>" +
+        "<p class=\"msg\">" + Localization.getString("openInOfficeAppNote", "Open this file in PowerPoint, Google Slides, or WPS Office for the best viewing experience.") + "</p></div>")
+  }
+
+  /** Scan a binary-era Office file for readable UTF-16LE and ASCII text runs. */
+  private fun extractBinaryText(file: File): String {
+    // Skip files that are too large to scan safely in memory.
+    if (file.length() > MAX_BINARY_SCAN_BYTES) return ""
+    val sb = StringBuilder()
+    try {
+      val bytes = file.inputStream().use { it.readBytes() }
+      var i = 0
+      while (i < bytes.size - 3) {
+        if (isUtf16LeRun(bytes, i)) {
+          val run = extractUtf16LeRun(bytes, i)
+          if (run.length >= 2) sb.appendLine(run)
+          i += run.length * 2
+        } else if (isAsciiRun(bytes, i)) {
+          val run = extractAsciiRun(bytes, i)
+          if (run.length >= 4) sb.appendLine(run)
+          i += run.length
+        } else { i++ }
+      }
+      return sb.toString()
+        .replace(Regex("\u0000"), "")
+        .replace(Regex("[\\x00-\\x08\\x0E-\\x1F]"), " ")
+        .replace(Regex(" {3,}"), "  ")
+        .trim()
+        .lines().filter { it.isNotBlank() }.joinToString("\n\n")
+    } catch (_: Throwable) { return "" }
+  }
+
+  private fun isUtf16LeRun(bytes: ByteArray, pos: Int): Boolean {
+    if (pos + 3 >= bytes.size) return false
+    val hi1 = bytes[pos + 1].toInt() and 0xFF; val hi2 = bytes[pos + 3].toInt() and 0xFF
+    return hi1 == 0 && hi2 == 0 && isPrintableChar(bytes[pos].toInt() and 0xFF) && isPrintableChar(bytes[pos + 2].toInt() and 0xFF)
+  }
+
+  private fun extractUtf16LeRun(bytes: ByteArray, start: Int): String {
+    val sb = StringBuilder(); var i = start
+    while (i + 1 < bytes.size) {
+      val lo = bytes[i].toInt() and 0xFF; val hi = bytes[i + 1].toInt() and 0xFF
+      if (hi != 0 || !isPrintableChar(lo)) break
+      sb.append(lo.toChar()); i += 2
+    }
+    return sb.toString()
+  }
+
+  private fun isAsciiRun(bytes: ByteArray, pos: Int): Boolean = pos < bytes.size && (bytes[pos].toInt() and 0xFF) in 0x20..0x7E
+
+  private fun extractAsciiRun(bytes: ByteArray, start: Int): String {
+    val sb = StringBuilder(); var i = start
+    while (i < bytes.size && (bytes[i].toInt() and 0xFF) in 0x20..0x7E) { sb.append((bytes[i].toInt() and 0xFF).toChar()); i++ }
+    return sb.toString()
+  }
+
+  private fun isPrintableChar(b: Int): Boolean = b in 0x20..0x7E || b == 0x0A || b == 0x0D || (b in 0x80..0xFF)
+
+  private fun materializeFile(uri: Uri, kind: String): File {
+    if (uri.scheme == "file") { uri.path?.let { path -> val f = File(path); if (f.canRead()) return f } }
+    val input = context.contentResolver.openInputStream(uri) ?: throw IOException("Cannot open document stream")
+    val temp = File.createTempFile("doc_preview_", ".$kind", context.cacheDir)
+    input.use { stream -> FileOutputStream(temp).use { out -> stream.copyTo(out) } }
+    tempOfficeFile = temp
+    return temp
+  }
+
+  // ── Image-based documents ────────────────────────────────────────
+
+  private fun loadImage(uri: Uri, gen: Int) {
+    if (width > 0) { decodeImage(uri, gen, width, height); return }
+    addOnLayoutChangeListener(object : OnLayoutChangeListener {
+      override fun onLayoutChange(v: android.view.View, l: Int, t: Int, r: Int, b: Int, ol: Int, ot: Int, or2: Int, ob: Int) {
+        if (r - l <= 0) return; v.removeOnLayoutChangeListener(this)
+        if (gen != generation) return; decodeImage(uri, gen, r - l, b - t)
+      }
+    })
+  }
+
+  private fun decodeImage(uri: Uri, gen: Int, viewW: Int, viewH: Int) {
+    val maxDim = maxRenderDimension(); val targetW = viewW.coerceIn(1, maxDim); val targetH = (if (viewH > 0) viewH else viewW).coerceIn(1, maxDim)
+    runOnWorker {
+      if (gen != generation) return@runOnWorker
+      val bitmap: Bitmap?
+      try {
+        val resolver = context.contentResolver
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        resolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, bounds) }
+        if (bounds.outWidth <= 0 || bounds.outHeight <= 0) { postError(gen, Localization.getString("notDecodableImage", "Not a decodable image")); return@runOnWorker }
+        var sample = 1
+        while (bounds.outWidth / (sample * 2) >= targetW && bounds.outHeight / (sample * 2) >= targetH) sample *= 2
+        val opts = BitmapFactory.Options().apply { inSampleSize = sample }
+        bitmap = resolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, opts) }
+      } catch (e: Throwable) { postError(gen, Localization.getString("couldNotDecodeImage", "Could not decode image: {0}", e.message ?: "")); return@runOnWorker }
+      if (bitmap == null) { postError(gen, Localization.getString("couldNotDecodeImageGeneric", "Could not decode image")); return@runOnWorker }
+      mainHandler.post {
+        if (gen != generation) { bitmap.recycle(); return@post }
+        val imageView = ImageView(context).apply { scaleType = ImageView.ScaleType.FIT_CENTER; setImageBitmap(bitmap) }
+        attachContent(imageView); emitLoaded(0)
+      }
+    }
+  }
+
+  // ── Shared IO helpers ────────────────────────────────────────────
+
+  private fun readCapped(uri: Uri, cap: Int): Pair<ByteArray, Boolean> {
+    val input = context.contentResolver.openInputStream(uri) ?: throw IOException("Cannot open document stream")
+    input.use { stream ->
+      val buffer = ByteArrayOutputStream(minOf(cap, 256 * 1024)); val chunk = ByteArray(64 * 1024); var total = 0; var truncated = false
+      while (true) {
+        val read = stream.read(chunk); if (read == -1) break
+        val remaining = cap - total
+        if (read >= remaining) { buffer.write(chunk, 0, remaining); total += remaining; truncated = read > remaining || stream.read() != -1; break }
+        buffer.write(chunk, 0, read); total += read
+      }
+      return buffer.toByteArray() to truncated
+    }
+  }
+
+  private fun looksBinary(bytes: ByteArray): Boolean { val checkLen = minOf(bytes.size, 8192); for (i in 0 until checkLen) { if (bytes[i] == 0.toByte()) return true }; return false }
+
+  private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt()
+
+  companion object {
+    private const val DEFAULT_PAGE_ASPECT = 1.4142f
+    private const val MAX_PAGE_BITMAP_HEIGHT = 4096
+    private const val MAX_TEXT_BYTES = 256 * 1024
+    private const val MAX_HTML_BYTES = 2 * 1024 * 1024
+    private const val MAX_BINARY_SCAN_BYTES = 2 * 1024 * 1024
+  }
+}