Added some new features.

Author: Rae-ARK

.github/workflows/build-apk.yml

@@ -0,0 +1,46 @@
+name: Build APK
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+  workflow_dispatch:
+  release:
+    types: [ published ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Set up Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          gradle-version: '8.7'
+
+      - name: Build APK
+        run: gradle assembleDebug --no-daemon --stacktrace
+
+      - name: Upload APK
+        uses: actions/upload-artifact@v4
+        with:
+          name: arklight-viewer-apk
+          path: app/build/outputs/apk/debug/*.apk
+
+      - name: Attach APK to GitHub Release
+        if: github.event_name == 'release'
+        uses: softprops/action-gh-release@v2
+        with:
+          files: app/build/outputs/apk/debug/*.apk

app/src/main/java/com/arklight/viewer/ArkBundle.kt

@@ -1,5 +1,6 @@
 package com.arklight.viewer
 
+import android.content.Context
 import java.io.File
 import java.io.FileOutputStream
 import java.util.zip.ZipEntry
@@ -48,27 +49,40 @@ object ArkBundle {
         File(entryDir, "index.html").writeText(entryHtml, Charsets.UTF_8)
     }
 
+    /**
+     * Where an extracted site's files currently live. [Ram] is the
+     * preferred backing — nothing touches disk, and [flush] just drops
+     * the reference for GC. [Disk] is the fallback used when
+     * [MemoryGuard] says RAM is too tight, backed by a fixed directory
+     * under the app's own data folder (`cacheDir/ark_current/site` —
+     * see [MainActivity]) so `WebViewAssetLoader`'s origin stays
+     * constant across bundles.
+     */
+    sealed class SiteBacking {
+        data class Ram(val files: Map<String, ByteArray>) : SiteBacking()
+        data class Disk(val dir: File) : SiteBacking()
+    }
+
     sealed class ExtractResult {
-        data class Success(val dir: File) : ExtractResult()
+        data class Success(val backing: SiteBacking) : ExtractResult()
         object NeedsPassphrase : ExtractResult()
         data class Failed(val reason: String) : ExtractResult()
     }
 
     /**
-     * Unseals (if needed) and unzips the archive half into [outDir],
-     * which the caller points at a **fixed path** (e.g.
-     * `cacheDir/ark_current/site`) rather than a per-bundle hash
-     * directory. That's deliberate: `WebViewAssetLoader` binds a path
-     * handler to a directory *path* once, at `Builder` time — keeping
-     * that path constant across every opened bundle means the loader
-     * (and therefore the served origin, `https://appassets.
-     * androidplatform.net/site/`) never changes, which is what makes
-     * origin-scoped storage (`localStorage`, IndexedDB, cookies) behave
-     * consistently across different bundles instead of being silently
-     * partitioned per bundle. See ARCHITECTURE.md, "Origin stability."
-     * [outDir] is cleared before each extraction.
+     * Unseals (if needed) and unzips the archive half, preferring to
+     * hold the result entirely in RAM ([SiteBacking.Ram]) and only
+     * falling back to writing it under [outDir] ([SiteBacking.Disk])
+     * when [MemoryGuard] reports the device doesn't have comfortable
+     * headroom for that. [outDir] is only touched in the fallback
+     * case, and is cleared before each extraction into it.
      */
-    fun unsealAndExtract(archiveBytes: ByteArray, outDir: File, passphrase: String?): ExtractResult {
+    fun unsealAndExtract(
+        archiveBytes: ByteArray,
+        outDir: File,
+        passphrase: String?,
+        context: Context
+    ): ExtractResult {
         if (archiveBytes.isEmpty()) {
             return ExtractResult.Failed("no archive half present (entry-page-only bundle)")
         }
@@ -85,6 +99,60 @@ object ArkBundle {
             archiveBytes
         }
 
+        // Uncompressed HTML/CSS/JS/JSON typically runs 3-5x the
+        // compressed size; budget 6x so a bad guess only ever costs an
+        // unnecessary disk write, never a memory squeeze -- the actual
+        // safety margin is enforced inside MemoryGuard itself.
+        val estimatedUncompressed = zipBytes.size.toLong() * 6
+
+        return if (MemoryGuard.hasRamHeadroom(context, estimatedUncompressed)) {
+            extractToMemory(zipBytes)
+        } else {
+            extractToDisk(zipBytes, outDir)
+        }
+    }
+
+    /**
+     * Releases whichever backing a site is currently using. RAM just
+     * drops the reference for GC; disk is deleted outright.
+     */
+    fun flush(backing: SiteBacking?) {
+        if (backing is SiteBacking.Disk) {
+            backing.dir.deleteRecursively()
+        }
+        // Ram case: caller drops its reference to `backing`; there's
+        // nothing else holding the byte arrays, so they're GC-eligible
+        // immediately.
+    }
+
+    private fun extractToMemory(zipBytes: ByteArray): ExtractResult {
+        val files = mutableMapOf<String, ByteArray>()
+        return try {
+            ZipInputStream(zipBytes.inputStream()).use { zis ->
+                var entry: ZipEntry? = zis.nextEntry
+                while (entry != null) {
+                    if (!entry.isDirectory) {
+                        val name = entry.name
+                        // Same zip-slip concern as the disk path: a
+                        // "../" entry isn't a legitimate site-relative
+                        // path even though it can't escape a directory
+                        // when there's no directory to escape.
+                        if (name.contains("..")) {
+                            throw SecurityException("Unsafe zip entry path: $name")
+                        }
+                        files[name] = zis.readBytes()
+                    }
+                    zis.closeEntry()
+                    entry = zis.nextEntry
+                }
+            }
+            ExtractResult.Success(SiteBacking.Ram(files))
+        } catch (e: Exception) {
+            ExtractResult.Failed("bad zip once unsealed: ${e.message}")
+        }
+    }
+
+    private fun extractToDisk(zipBytes: ByteArray, outDir: File): ExtractResult {
         outDir.deleteRecursively()
         outDir.mkdirs()
 
@@ -107,7 +175,7 @@ object ArkBundle {
                     entry = zis.nextEntry
                 }
             }
-            ExtractResult.Success(outDir)
+            ExtractResult.Success(SiteBacking.Disk(outDir))
         } catch (e: Exception) {
             outDir.deleteRecursively()
             ExtractResult.Failed("bad zip once unsealed: ${e.message}")

app/src/main/java/com/arklight/viewer/MainActivity.kt

@@ -21,7 +21,9 @@ import androidx.webkit.WebViewAssetLoader
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import java.io.ByteArrayInputStream
 import java.io.File
+import android.webkit.MimeTypeMap
 
 /**
  * Origin strategy (see ARCHITECTURE.md, "Origin stability"):
@@ -54,6 +56,13 @@ class MainActivity : AppCompatActivity() {
     private var siteReady = false
     private var showingFullSite = false
 
+    // Which backing the currently-open bundle's full site is using --
+    // RAM when there was headroom for it, disk otherwise. Whatever it
+    // is, it gets flushed (RAM reference dropped / disk dir deleted)
+    // as soon as we're done with it: right before extracting the next
+    // bundle, and when the activity is destroyed. See ArkBundle.flush.
+    private var currentBacking: ArkBundle.SiteBacking? = null
+
     private val openDocument =
         registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
             uri?.let { openArkFile(it) }
@@ -75,7 +84,7 @@ class MainActivity : AppCompatActivity() {
 
         assetLoader = WebViewAssetLoader.Builder()
             .addPathHandler("/entry/", WebViewAssetLoader.InternalStoragePathHandler(this, entryDir))
-            .addPathHandler("/site/", WebViewAssetLoader.InternalStoragePathHandler(this, siteDir))
+            .addPathHandler("/site/", SitePathHandler())
             .build()
 
         webView.webViewClient = object : WebViewClient() {
@@ -97,6 +106,49 @@ class MainActivity : AppCompatActivity() {
         handleIntent(intent)
     }
 
+    override fun onDestroy() {
+        super.onDestroy()
+        // App's actually done with the current site now -- release
+        // whichever backing it was using (RAM reference dropped for
+        // GC, or the disk fallback directory deleted outright).
+        flushCurrentSite()
+    }
+
+    private fun flushCurrentSite() {
+        ArkBundle.flush(currentBacking)
+        currentBacking = null
+        siteReady = false
+    }
+
+    /**
+     * Serves the currently-open site's files from whichever backing
+     * [currentBacking] holds. RAM-backed sites are served straight out
+     * of the in-memory map; disk-backed ones delegate to a plain
+     * [WebViewAssetLoader.InternalStoragePathHandler] pointed at the
+     * fallback directory. Either way callers just see `/site/...`
+     * resolve under the same stable origin -- see the class doc above.
+     */
+    private inner class SitePathHandler : WebViewAssetLoader.PathHandler {
+        override fun handle(path: String): WebResourceResponse? {
+            return when (val backing = currentBacking) {
+                is ArkBundle.SiteBacking.Ram -> {
+                    val key = if (path.isEmpty()) "index.html" else path
+                    val bytes = backing.files[key] ?: return null
+                    WebResourceResponse(mimeTypeFor(key), null, ByteArrayInputStream(bytes))
+                }
+                is ArkBundle.SiteBacking.Disk ->
+                    WebViewAssetLoader.InternalStoragePathHandler(this@MainActivity, backing.dir)
+                        .handle(path)
+                null -> null
+            }
+        }
+    }
+
+    private fun mimeTypeFor(path: String): String {
+        val ext = path.substringAfterLast('.', "")
+        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) ?: "application/octet-stream"
+    }
+
     private fun handleIntent(intent: Intent?) {
         val uri: Uri? = intent?.data
         if (uri != null) openArkFile(uri) else showWelcomeScreen()
@@ -121,6 +173,11 @@ class MainActivity : AppCompatActivity() {
     private fun openArkFile(uri: Uri) {
         lifecycleScope.launch {
             progress.visibility = ProgressBar.VISIBLE
+
+            // Done with whatever was open before -- release its RAM
+            // or disk backing before we start pulling in the next one.
+            flushCurrentSite()
+
             val bytes = withContext(Dispatchers.IO) {
                 runCatching { contentResolver.openInputStream(uri)?.use { it.readBytes() } }
                     .getOrNull()
@@ -152,13 +209,18 @@ class MainActivity : AppCompatActivity() {
 
     private suspend fun tryExtractFullSite(archiveBytes: ByteArray, passphrase: String?) {
         val result = withContext(Dispatchers.IO) {
-            ArkBundle.unsealAndExtract(archiveBytes, siteDir, passphrase)
+            ArkBundle.unsealAndExtract(archiveBytes, siteDir, passphrase, applicationContext)
         }
         when (result) {
             is ArkBundle.ExtractResult.Success -> {
+                currentBacking = result.backing
                 siteReady = true
                 invalidateOptionsMenu()
-                toast("Full site ready — see \u22EE menu \u2192 Browse full site.")
+                val where = when (result.backing) {
+                    is ArkBundle.SiteBacking.Ram -> "in memory"
+                    is ArkBundle.SiteBacking.Disk -> "on disk"
+                }
+                toast("Full site ready ($where) — see \u22EE menu \u2192 Browse full site.")
             }
             is ArkBundle.ExtractResult.NeedsPassphrase -> {
                 if (passphrase == null) {

app/src/main/java/com/arklight/viewer/MemoryGuard.kt

@@ -0,0 +1,37 @@
+package com.arklight.viewer
+
+import android.app.ActivityManager
+import android.content.Context
+
+/**
+ * Decides whether it's safe to hold an extracted site's files in RAM
+ * instead of writing them to disk. Conservative by design: any
+ * uncertainty resolves to "no" (disk), since the cost of guessing
+ * wrong on RAM is a possible low-memory kill, while the cost of
+ * guessing wrong on disk is just a slower, disk-backed WebView load.
+ */
+object MemoryGuard {
+
+    /** Extra headroom kept above the system's own low-memory threshold. */
+    private const val SAFETY_MARGIN_BYTES = 32L * 1024 * 1024 // 32MB
+
+    /**
+     * True if the device currently has enough free RAM to comfortably
+     * absorb [requiredBytes] more resident data without approaching
+     * the point where Android would start killing background
+     * processes for memory.
+     */
+    fun hasRamHeadroom(context: Context, requiredBytes: Long): Boolean {
+        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+            ?: return false
+
+        val info = ActivityManager.MemoryInfo()
+        am.getMemoryInfo(info)
+
+        // The system is already telling us it's tight -- don't add to it.
+        if (info.lowMemory) return false
+
+        val freeAboveThreshold = info.availMem - info.threshold - SAFETY_MARGIN_BYTES
+        return freeAboveThreshold > requiredBytes
+    }
+}

app/src/main/res/menu/main_menu.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <menu xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res/app">
+    xmlns:app="http://schemas.android.com/apk/res-auto">
 
     <item
         android:id="@+id/action_open"