create-mithril-lynx 0.0.2 → 0.1.1

package/templates/android/app-scripts/android.mjs

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+/**
+ * Bridge between this JS project (the Lynx bundle) and its sibling Android host
+ * (`{{ANDROID_DIR}}/`).
+ *
+ * Automates Part C of ANDROID_APK_GUIDE.md: build the bundle, copy it into
+ * `app/src/main/assets/`, then build/install and launch the APK.
+ *
+ *   npm run android            build + sync + installDebug + launch on the device
+ *   npm run android:apk        build + sync + assembleDebug (build the APK only)
+ *   npm run android:release    build + sync + assembleRelease (signs if keystore.properties exists)
+ *   npm run android:sync       build + sync into assets only (no Gradle)
+ *   npm run android:keystore   generate release.keystore + keystore.properties (once)
+ *
+ * Extra flags, passed after `--`:
+ *   npm run android -- --no-build        reuse dist/ as-is (don't rebuild)
+ *   npm run android -- --no-launch       don't launch the app over adb at the end
+ *   npm run android:apk -- -- --info     everything after `--` is forwarded to ./gradlew
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+/** Sibling Android host, resolved when the project was generated. */
+const ANDROID_DIR = path.resolve(projectRoot, "{{ANDROID_REL_DIR}}");
+
+const APPLICATION_ID = "{{PACKAGE_NAME}}";
+const ACTIVITY_CLASS = ".MainActivity";
+const BUNDLE_NAME = "main-thread.bundle";
+
+const BUNDLE_SRC = path.join(projectRoot, "dist", BUNDLE_NAME);
+const BUNDLE_DEST = path.join(ANDROID_DIR, "app", "src", "main", "assets", BUNDLE_NAME);
+
+const USAGE = `
+Usage: npm run android -- [flags] [-- gradle-args]
+
+  --apk          build the debug APK (assembleDebug) instead of installing it
+  --release      build the release APK (assembleRelease, signed if keystore.properties exists)
+  --sync-only    only build the bundle and copy it into assets/ (no Gradle)
+  --no-build     don't rebuild the bundle; use dist/ as it is
+  --no-launch    don't launch the app over adb at the end
+  --keystore     generate release.keystore + keystore.properties and exit
+  --help         print this
+`.trim();
+
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((a) => a.startsWith("-")));
+
+function afterDoubleDash() {
+	const i = args.indexOf("--");
+	return i === -1 ? [] : args.slice(i + 1);
+}
+
+function fail(message) {
+	console.error(`\n  ✖ ${message}\n`);
+	process.exit(1);
+}
+
+function run(command, commandArgs, options = {}) {
+	const result = spawnSync(command, commandArgs, {
+		cwd: options.cwd ?? projectRoot,
+		stdio: options.capture ? "pipe" : "inherit",
+		shell: process.platform === "win32",
+		encoding: "utf8",
+	});
+	if (result.error) {
+		fail(`Could not run "${command}": ${result.error.message}`);
+	}
+	if (result.status !== 0) {
+		fail(`"${command} ${commandArgs.join(" ")}" exited with code ${result.status}.`);
+	}
+	return result.stdout ?? "";
+}
+
+function detectPackageManager() {
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("bun")) return "bun";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	return "npm";
+}
+
+function gradlew() {
+	return process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+}
+
+function requireAndroidDir() {
+	if (!fs.existsSync(path.join(ANDROID_DIR, "settings.gradle.kts"))) {
+		fail(
+			`Can't find the Android host at ${ANDROID_DIR}.\n` +
+				`    Generate it with:  npm create mithril-lynx@latest <name> --android\n` +
+				`    (or pass --android-id/--app-name so it doesn't prompt).`,
+		);
+	}
+}
+
+function syncBundle() {
+	if (!fs.existsSync(BUNDLE_SRC)) {
+		fail(`${path.relative(projectRoot, BUNDLE_SRC)} doesn't exist. Run "npm run build" first (or drop --no-build).`);
+	}
+	requireAndroidDir();
+	fs.mkdirSync(path.dirname(BUNDLE_DEST), { recursive: true });
+	fs.copyFileSync(BUNDLE_SRC, BUNDLE_DEST);
+	const kb = (fs.statSync(BUNDLE_DEST).size / 1024).toFixed(1);
+	console.log(`  → ${path.relative(projectRoot, BUNDLE_DEST)} (${kb} kB)`);
+}
+
+function generateKeystore() {
+	requireAndroidDir();
+	const alias = "release";
+	const storeFile = path.join(ANDROID_DIR, "release.keystore");
+	const propertiesFile = path.join(ANDROID_DIR, "keystore.properties");
+
+	if (fs.existsSync(propertiesFile)) {
+		fail(`${path.relative(projectRoot, propertiesFile)} already exists. Delete it by hand to regenerate.`);
+	}
+
+	const password = process.env.KEYSTORE_PASSWORD;
+	if (!password) {
+		fail(
+			"The KEYSTORE_PASSWORD environment variable is missing.\n" +
+				`    KEYSTORE_PASSWORD='...' npm run android:keystore`,
+		);
+	}
+
+	const keytool = spawnSync(
+		"keytool",
+		[
+			"-genkeypair", "-v",
+			"-keystore", storeFile,
+			"-alias", alias,
+			"-keyalg", "RSA",
+			"-keysize", "2048",
+			"-validity", "10000",
+			"-storepass", password,
+			"-keypass", password,
+			"-dname", "CN={{APP_NAME}}",
+		],
+		{ stdio: "inherit" },
+	);
+	if (keytool.error?.code === "ENOENT") {
+		fail("Can't find `keytool` on PATH. It ships with JDK 17 — check JAVA_HOME.");
+	}
+	if (keytool.status !== 0) fail(`keytool exited with code ${keytool.status}.`);
+
+	fs.writeFileSync(
+		propertiesFile,
+		[
+			"# Generated by scripts/android.mjs — do NOT commit (see the Android host's .gitignore).",
+			"storeFile=release.keystore",
+			`storePassword=${password}`,
+			`keyAlias=${alias}`,
+			`keyPassword=${password}`,
+			"",
+		].join("\n"),
+	);
+
+	console.log(`\n  ✔ ${path.relative(projectRoot, storeFile)}`);
+	console.log(`  ✔ ${path.relative(projectRoot, propertiesFile)}`);
+	console.log("\n  Next: npm run android:release\n");
+}
+
+function buildBundle() {
+	const manager = detectPackageManager();
+	console.log(`\n▸ Building the bundle (${manager} run build)…`);
+	run(manager, ["run", "build"]);
+}
+
+function runGradle(task, extraArgs) {
+	console.log(`\n▸ ./gradlew ${task}…`);
+	run(gradlew(), [task, ...extraArgs], { cwd: ANDROID_DIR });
+}
+
+function launch() {
+	console.log("\n▸ Launching on the device…\n");
+	run("adb", ["shell", "am", "force-stop", APPLICATION_ID]);
+	const output = run("adb", ["shell", "am", "start", "-W", "-n", `${APPLICATION_ID}/${ACTIVITY_CLASS}`], {
+		capture: true,
+	});
+	for (const line of output.split("\n")) {
+		if (/TotalTime|WaitTime|LaunchState|Error|Exception/.test(line)) console.log(`  ${line.trim()}`);
+	}
+	console.log("\n  Logs:  adb logcat | grep -i lynx");
+}
+
+function main() {
+	if (flags.has("--help") || flags.has("-h")) {
+		console.log(USAGE);
+		return;
+	}
+	if (flags.has("--keystore")) {
+		generateKeystore();
+		return;
+	}
+
+	const syncOnly = flags.has("--sync-only");
+
+	if (!flags.has("--no-build")) buildBundle();
+	syncBundle();
+
+	if (syncOnly) {
+		console.log("\n  ✔ Assets synced.\n");
+		return;
+	}
+
+	const extraGradleArgs = afterDoubleDash();
+	if (flags.has("--release")) {
+		runGradle("assembleRelease", extraGradleArgs);
+		const apkDir = path.join(ANDROID_DIR, "app", "build", "outputs", "apk", "release");
+		for (const apk of fs.existsSync(apkDir) ? fs.readdirSync(apkDir).filter((f) => f.endsWith(".apk")) : []) {
+			console.log(`\n  ✔ APK: ${path.relative(projectRoot, path.join(apkDir, apk))}`);
+		}
+	} else if (flags.has("--apk") || process.env.CI) {
+		runGradle("assembleDebug", extraGradleArgs);
+		console.log(
+			`\n  ✔ APK: ${path.relative(projectRoot, path.join(ANDROID_DIR, "app", "build", "outputs", "apk", "debug", "app-debug.apk"))}`,
+		);
+	} else {
+		runGradle("installDebug", extraGradleArgs);
+	}
+
+	if (!flags.has("--no-launch") && !flags.has("--apk") && !flags.has("--release")) {
+		launch();
+	} else {
+		console.log("");
+	}
+}
+
+main();

package/templates/android/font/AssetFontFaceLoader.kt

@@ -0,0 +1,39 @@
+package {{PACKAGE_NAME}}
+
+import android.graphics.Typeface
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.fontface.FontFace
+import com.lynx.tasm.loader.LynxFontFaceLoader
+
+/**
+ * Resolves `asset:///` in `@font-face`, both for the prefetch and for the real
+ * lookup.
+ *
+ * Lynx's default loader (LynxFontFaceLoader$1, decompiled from
+ * lynx-4.1.0.aar) is a no-op that never resolves `asset:///`: in
+ * FontFaceManager that scheme is only handled inline inside loadTypeface()
+ * when a FONT-type LynxResourceProvider is registered, and the non-http/
+ * non-data: branch of prefetchFont() (prefetchFontWithLoader) goes through this
+ * Loader only, with no fallback of its own. Without registering this,
+ * `asset:///` resolves no way at all.
+ *
+ * Trade-off to keep in mind: FontFaceManager/LynxFontFaceLoader are public
+ * classes (not @RestrictTo) but are not documented for this specific use —
+ * they could change without notice in a major Lynx SDK release.
+ */
+object AssetFontFaceLoader : LynxFontFaceLoader.Loader() {
+    private const val ASSET_PREFIX = "asset:///"
+
+    override fun onLoadFontFace(
+        context: LynxContext,
+        type: FontFace.TYPE,
+        src: String,
+    ): Typeface? {
+        if (!src.startsWith(ASSET_PREFIX)) return null
+        return try {
+            Typeface.createFromAsset(context.context.assets, src.removePrefix(ASSET_PREFIX))
+        } catch (e: Exception) {
+            null
+        }
+    }
+}

package/templates/android/host/app/build.gradle.kts

@@ -0,0 +1,103 @@
+import java.io.FileInputStream
+import java.util.Properties
+
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+// Optional release signing, driven by keystore.properties (gitignored).
+// Without that file, `./gradlew assembleRelease` simply produces an unsigned
+// APK instead of failing. To generate it:
+//   npm run android:keystore
+val keystorePropertiesFile = rootProject.file("keystore.properties")
+val keystoreProperties = Properties().apply {
+    if (keystorePropertiesFile.exists()) {
+        FileInputStream(keystorePropertiesFile).use { load(it) }
+    }
+}
+
+android {
+    namespace = "{{PACKAGE_NAME}}"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "{{PACKAGE_NAME}}"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    signingConfigs {
+        if (keystorePropertiesFile.exists()) {
+            create("release") {
+                // storeFile resolves against the Android project root, so
+                // "release.keystore" means <android-dir>/release.keystore.
+                storeFile = rootProject.file(keystoreProperties.getProperty("storeFile"))
+                storePassword = keystoreProperties.getProperty("storePassword")
+                keyAlias = keystoreProperties.getProperty("keyAlias")
+                keyPassword = keystoreProperties.getProperty("keyPassword")
+            }
+        }
+    }
+
+    buildTypes {
+        debug {
+            isMinifyEnabled = false
+        }
+        release {
+            isMinifyEnabled = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+            if (keystorePropertiesFile.exists()) {
+                signingConfig = signingConfigs.getByName("release")
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    // The core artifact — LynxView, LynxViewBuilder, the layout engine, etc.
+    implementation("org.lynxsdk.lynx:lynx:4.1.0")
+
+    // OPT-IN: add these only if you use those elements, but they cost little
+    // and without them the failure is silent (the element mounts and never
+    // responds), so the scaffold ships them.
+
+    // <input>/<textarea> — without this those elements take up zero size and
+    // never open the keyboard. XElementBehaviors is registered in MainActivity.kt.
+    implementation("org.lynxsdk.lynx:xelement:4.1.0")
+    implementation("org.lynxsdk.lynx:xelement-input:4.1.0")
+
+    // <overlay> — without this the element mounts without error but is never
+    // visible (mithril-lynx-ui's Dialog/Sheet/Popover need it).
+    implementation("org.lynxsdk.lynx:xelement-overlay:4.1.0")
+
+    // Without a registered ILynxLogService, console.log() and JS errors from
+    // the bundle are dropped silently — not even logcat shows them. Remove it
+    // (along with its registration in the Application class) in a production
+    // build.
+    implementation("org.lynxsdk.lynx:lynx-service-log:4.1.0")
+
+    // <refresh> (pull-to-refresh, inside the xelement artifact) internally
+    // depends on SmartRefreshLayout, whose touch-dispatch code references
+    // ViewPager2 even though you don't use it — without this, every touch on a
+    // <refresh> throws NoClassDefFoundError (caught by the engine, but the
+    // gesture then never works).
+    implementation("androidx.viewpager2:viewpager2:1.1.0")
+
+    implementation("androidx.appcompat:appcompat:1.7.0")
+    implementation("androidx.core:core-splashscreen:1.0.1")
+}

package/templates/android/host/app/proguard-rules.pro

@@ -0,0 +1,51 @@
+# ProGuard/R8 rules for the release build.
+
+# ---------------------------------------------------------------------------
+# 1. OPTIONAL Lynx SDK dependencies that are not on the classpath.
+#
+# The `xelement` artifact (and part of the core) references library classes the
+# SDK does NOT declare as transitive dependencies:
+#   - Fresco (com.facebook.**)        -> SvgDefaultResourceManager's remote SVG path
+#   - Gson (com.google.gson.**)       -> LynxEnv.GetNativeEnvDebugDescription()
+#   - Markdown (com.lynx.markdown.**) -> LynxUIMarkdownShadowNode
+#
+# Without these -dontwarn rules, R8 aborts with "Missing classes detected while
+# running R8" and `./gradlew assembleRelease` fails outright. Verified with
+# lynx:4.1.0 + AGP 8.5.2. They are optional paths a normal mithril-lynx app
+# never uses, so ignoring them is correct (adding the real libraries would only
+# bloat the APK for nothing).
+-dontwarn com.facebook.**
+-dontwarn com.google.gson.**
+-dontwarn com.lynx.markdown.**
+
+# ---------------------------------------------------------------------------
+# 1b. Methods Lynx's NATIVE code calls by exact name + signature.
+#
+# The `lynx-base` AAR calls
+# `com.lynx.base.log.LynxLog.log(int, String, String, int, long, int, int)`
+# from C++ via JNI GetStaticMethodID. That class is NOT annotated with
+# @CalledByNative (unlike most of the bridge), so the AAR's consumer rules
+# don't cover it: R8 renames it and startup dies with
+#
+#   java.lang.NoSuchMethodError: no static method
+#     "Lcom/lynx/base/log/LynxLog;.log(ILjava/lang/String;Ljava/lang/String;IJII)V"
+#   JNI DETECTED ERROR IN APPLICATION: mid == null
+#   Fatal signal 6 (SIGABRT)  <- on the LynxTraceInit thread, before drawing anything
+#
+# Verified on a device (minified release, lynx:4.1.0 + AGP 8.5.2): without this
+# rule the release APK crashes on startup; with it, it starts like the debug one.
+-keep class com.lynx.base.log.LynxLog { *; }
+
+# ---------------------------------------------------------------------------
+# 2. Your own classes reached by reflection.
+#
+# The Lynx SDK ships its own "consumer" rules inside the AAR. What it cannot
+# know about is your classes, so anything Lynx reaches by name has to survive
+# minification:
+#
+#   - modules registered with builder.registerModule("Name", Class::class.java)
+#   - your own @LynxMethod / behaviors
+#
+# Example:
+#
+#   -keep class com.example.myapp.MyNativeModule { *; }

package/templates/android/host/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+        android:name=".{{APP_CLASS}}"
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:icon="@mipmap/ic_launcher"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:hardwareAccelerated="true"
+        android:usesCleartextTraffic="true"
+        android:theme="@style/AppTheme">
+
+        <activity
+            android:name=".MainActivity"
+            android:theme="@style/Theme.App.Starting"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+    </application>
+
+</manifest>

package/templates/android/host/app/src/main/java/package-path/App.kt

@@ -0,0 +1,23 @@
+package {{PACKAGE_NAME}}
+
+import android.app.Application
+import com.lynx.service.log.LynxLogService
+import com.lynx.tasm.LynxEnv
+// {{FONT_LOADER_IMPORT}}
+import com.lynx.tasm.service.LynxServiceCenter
+
+class {{APP_CLASS}} : Application() {
+    override fun onCreate() {
+        super.onCreate()
+
+        // Without a registered ILynxLogService, console.log() and JS errors
+        // from the bundle are dropped silently — not even logcat shows them.
+        // Drop this (and the lynx-service-log dependency) in production if you
+        // don't want it.
+        LynxServiceCenter.inst().registerService(LynxLogService)
+        LynxLogService.switchLogToSystem(true)
+
+        // {{FONT_LOADER_REGISTRATION}}
+        LynxEnv.inst().init(this, null, null, null)
+    }
+}

package/templates/android/host/app/src/main/java/package-path/AssetTemplateProvider.kt

@@ -0,0 +1,27 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import com.lynx.tasm.provider.AbsTemplateProvider
+import java.io.IOException
+
+/**
+ * Reads the Lynx bundle from assets on a separate thread.
+ *
+ * Measured on real hardware: reading the same asset SYNCHRONOUSLY in
+ * MainActivity.onCreate() (blocking Android's UI thread — distinct from Lynx's
+ * internal main/background thread split, but just as harmful to the first
+ * frame) cost 2.4-2.8s of cold start under `adb shell am start -W`; with this
+ * async provider, ~300ms. This is not optional.
+ */
+class AssetTemplateProvider(private val context: Context) : AbsTemplateProvider() {
+    override fun loadTemplate(url: String, callback: Callback) {
+        Thread {
+            try {
+                val bytes = context.assets.open(url).use { it.readBytes() }
+                callback.onSuccess(bytes)
+            } catch (e: IOException) {
+                callback.onFailed(e.toString())
+            }
+        }.start()
+    }
+}

package/templates/android/host/app/src/main/java/package-path/MainActivity.kt

@@ -0,0 +1,37 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
+import com.lynx.tasm.LynxViewBuilder
+import com.lynx.tasm.ThreadStrategyForRendering
+// {{FONT_IMPORT}}
+import com.lynx.xelement.XElementBehaviors
+
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        // Must run BEFORE super.onCreate() — a Splash Screen API requirement.
+        installSplashScreen()
+        super.onCreate(savedInstanceState)
+
+        val builder = LynxViewBuilder()
+        // <input>/<textarea> are opt-in "xelement" components, not part of the
+        // core artifact: without this they measure 0 and never open the
+        // keyboard. Remove this line (and the xelement dependencies) if you
+        // don't use them.
+        builder.addBehaviors(XElementBehaviors().create())
+        builder.setThreadStrategyForRendering(ThreadStrategyForRendering.ALL_ON_UI)
+        // Reads the bundle from assets on a separate thread — see
+        // AssetTemplateProvider's comment: reading it synchronously here cost
+        // 2.4-2.8s of cold start measured on a real device, vs ~300ms with this.
+        builder.setTemplateProvider(AssetTemplateProvider(this))
+        val lynxView = builder.build(this)
+        setContentView(lynxView)
+
+        // {{FONT_PREFETCH}}
+        // The bundle lives in app/src/main/assets/main-thread.bundle, copied
+        // there by `npm run android` (scripts/android.mjs) from the JS
+        // project's dist/. The name has to match exactly.
+        lynxView.renderTemplateUrl("main-thread.bundle", "")
+    }
+}

package/templates/android/host/app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp" android:height="108dp"
+    android:viewportWidth="108" android:viewportHeight="108">
+    <path android:pathData="M0,0h108v108h-108z" android:fillColor="#0F1115" />
+</vector>

package/templates/android/host/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp" android:height="108dp"
+    android:viewportWidth="108" android:viewportHeight="108">
+    <path
+        android:pathData="M30,54 L50,74 L78,34"
+        android:strokeColor="#6EE7B7"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round" />
+</vector>

package/templates/android/host/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

package/templates/android/host/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

package/templates/android/host/app/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">{{APP_NAME}}</string>
+</resources>

package/templates/android/host/app/src/main/res/values/themes.xml

@@ -0,0 +1,17 @@
+<resources>
+
+    <!-- The app's normal theme, handed off to once the splash screen ends.
+         No ActionBar: Lynx draws the whole app. -->
+    <style name="AppTheme" parent="Theme.AppCompat.DayNight.NoActionBar" />
+
+    <!-- Shown by the system from process start until installSplashScreen()
+         gets its default signal — which is this Activity's first drawn frame,
+         i.e. exactly the real cold-start window (~700-800ms), not an arbitrary
+         fixed delay. -->
+    <style name="Theme.App.Starting" parent="Theme.SplashScreen">
+        <item name="windowSplashScreenBackground">#0F1115</item>
+        <item name="windowSplashScreenAnimatedIcon">@drawable/ic_launcher_foreground</item>
+        <item name="postSplashScreenTheme">@style/AppTheme</item>
+    </style>
+
+</resources>

package/templates/android/host/build.gradle.kts

@@ -0,0 +1,4 @@
+plugins {
+    id("com.android.application") version "8.5.2" apply false
+    id("org.jetbrains.kotlin.android") version "1.9.24" apply false
+}

package/templates/android/host/gitignore

@@ -0,0 +1,16 @@
+# Gradle / Android
+.gradle/
+build/
+app/build/
+.cxx/
+local.properties
+*.iml
+.idea/
+
+# Release signing — never committed (see keystore.properties.example).
+keystore.properties
+*.keystore
+*.jks
+
+# Regenerated by `npm run android` from the sibling JS project.
+app/src/main/assets/main-thread.bundle

package/templates/android/host/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.2-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/templates/android/host/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official