Add android and ios target

Author: kdroidFilter

AGENTS.md

@@ -0,0 +1,41 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+
+- `demo/`: Compose Desktop sample app (`demo/src/jvmMain/kotlin/...`).
+- `wrywebview/`: native WebView core.
+  - Rust crate: `wrywebview/Cargo.toml` with sources in `wrywebview/src/main/rust/` (wry + UniFFI).
+  - JVM glue: `wrywebview/src/main/kotlin/` + `wrywebview/src/main/java/` (JNA/Skiko interop).
+- `wrywebview-compose/`: Compose wrapper exposing `io.github.kdroidfilter.webview.*` (`WebView`, `WebViewState`, `WebViewNavigator`).
+  - Shared API/types: `wrywebview-compose/src/commonMain/kotlin/...`.
+  - Platform actuals: `.../src/jvmMain/` (Wry), `.../src/androidMain/` (Android WebView), `.../src/iosMain/` (WKWebView + cinterop in `.../src/nativeInterop/`).
+- Generated/build outputs live under `*/build/` and `wrywebview/target/` (don’t edit or commit).
+
+## Build, Test, and Development Commands
+
+- `./gradlew build`: builds all modules (Kotlin + Rust via Gobley/UniFFI); requires a working Rust toolchain.
+- `./gradlew :demo:run`: runs the desktop demo app.
+- `./gradlew :wrywebview:build`: rebuilds the native core and refreshes generated bindings.
+- `./gradlew :wrywebview-compose:compileDebugKotlinAndroid`: compiles the Android implementation (requires Android SDK).
+- `./gradlew clean`: removes Gradle build outputs (useful when native artifacts get out of sync).
+
+## Coding Style & Naming Conventions
+
+- Kotlin/Compose: 4-space indentation, idiomatic Kotlin style, `camelCase` for values/functions, `PascalCase` for types and `@Composable` functions (e.g., `WebView`).
+- Keep public API changes small and documented (README usage snippets should stay accurate).
+- Rust: format with `cargo fmt` in `wrywebview/`; keep the `#[uniffi::export]` surface stable and cross-platform.
+
+## Testing Guidelines
+
+- Kotlin tests (when added) should live in `*/src/jvmTest/kotlin` (or `commonTest`) and run with `./gradlew test`.
+- Rust tests (when added) can run via `cd wrywebview && cargo test`.
+
+## Commit & Pull Request Guidelines
+
+- Commit messages follow a simple imperative style (e.g., “Add …”, “Fix …”, “Refactor …”) and mention the affected module/API when helpful.
+- PRs should include: a short rationale, steps to verify (`./gradlew :demo:run`), OS tested (Linux/macOS/Windows), and screenshots/GIFs for UI changes.
+
+## Security & Configuration Tips
+
+- The demo/app JVM needs `--enable-native-access=ALL-UNNAMED` (JNA); keep this in sync with `README.md`.
+- Platform builds may require system deps (notably GTK/WebKit on Linux); call out any new requirements in the PR description.

README.md

@@ -1,18 +1,20 @@
 # ComposeWebview
 
-Wry-powered **WebView for Compose Desktop (Kotlin/JVM)**, backed by a small Rust core (wry) exposed via **Gobley/UniFFI**.
+Compose Multiplatform **WebView** with a **KevinnZou/compose-webview-multiplatform-inspired API** under `io.github.kdroidfilter.webview.*`.
 
-This repository exposes a **KevinnZou/compose-webview-multiplatform-inspired API** under `io.github.kdroidfilter.webview.*` so you can keep the same mental model (`WebView`, `WebViewState`, `WebViewNavigator`, cookies, JS bridge) while using a desktop backend.
+- Desktop: **Wry** backend (Rust core via **Gobley/UniFFI**)
+- Android: `android.webkit.WebView`
+- iOS: `WKWebView`
 
 ## Demo
 
-Run the showcase app (recommended first):
+This repo ships a feature showcase app (recommended first):
 
-```bash
-./gradlew :demo:run
-```
+- Desktop (Wry): `./gradlew :demo:run`
+- Android: `./gradlew :demo-android:installDebug` (or `:demo-android:assembleDebug`)
+- iOS: open `iosApp/iosApp.xcodeproj` in Xcode and Run (it calls `./gradlew :demo-shared:embedAndSignAppleFrameworkForXcode`)
 
-The demo includes a “Tools” panel to exercise most APIs (navigation, headers + interceptor, cookies, JS, bridge, settings).
+The demo UI is responsive: on large screens it shows a side “Tools” panel, and on phones it uses a bottom sheet.
 
 ## Features
 
@@ -30,27 +32,32 @@ The demo includes a “Tools” panel to exercise most APIs (navigation, headers
 - **Cookies**
   - `state.cookieManager.setCookie/getCookies/removeCookies/removeAllCookies`
 - **JavaScript**
-  - `navigator.evaluateJavaScript(script)` *(fire-and-forget on desktop right now)*
+  - `navigator.evaluateJavaScript(script)` *(fire-and-forget; no return value)*
   - JS ↔ Kotlin **bridge**: `window.kmpJsBridge.callNative(...)` with callbacks
 - **Settings**
-  - `customUserAgentString` (**implemented**; requires WebView recreation)
+  - `customUserAgentString` (**implemented**; desktop recreates, Android/iOS update in-place)
   - `logSeverity` (internal logging)
 
 ## Limitations (current)
 
-- **Desktop/JVM only** (no Android/iOS in this repo).
+- Desktop + Android demos build from Gradle; iOS requires **macOS + Xcode toolchain** (Kotlin/Native + cinterop).
 - `RequestInterceptor` only applies to **navigations triggered via `WebViewNavigator`** (not to sub-resources like images/XHR loaded by the page).
-- Changing `customUserAgentString` **recreates** the WebView (debounced ~400ms): expect JS context/history loss.
+- On desktop, changing `customUserAgentString` **recreates** the WebView (debounced ~400ms): expect JS context/history loss.
 
 ## Project layout
 
 - `wrywebview/`: Rust core (wry) + UniFFI exports + JVM glue (`WryWebViewPanel`).
 - `wrywebview-compose/`: Compose API layer (`io.github.kdroidfilter.webview.*`).
-- `demo/`: feature showcase app.
+- `demo-shared/`: shared demo UI (`App()`), used by all demo targets.
+- `demo/`: Compose Desktop demo wrapper.
+- `demo-android/`: Android demo app wrapper.
+- `iosApp/`: iOS SwiftUI demo app wrapper (imports the `demoShared` framework).
 
 ## Requirements
 
 - Rust toolchain (`rustup` installed) for building the native core.
+- Android SDK for building the Android target.
+- macOS + Xcode for building iOS targets.
 - Platform deps for the underlying webview (notably on Linux: GTK/WebKitGTK packages depending on your distro).
 - JVM flag (required for JNA native access):
   - `--enable-native-access=ALL-UNNAMED`
@@ -184,9 +191,9 @@ navigator.loadHtml("<html><body><h1>Hello</h1></body></html>")
 
 #### HTML file from resources (assets)
 
-On desktop, `WebViewFileReadType.ASSET_RESOURCES` loads from classpath resources under `assets/`.
+Recommended (cross-platform): put your HTML under Compose Multiplatform resources and load it with `WebViewFileReadType.ASSET_RESOURCES`.
 
-- Put your file here: `src/jvmMain/resources/assets/my_page.html`
+- Put your file here: `src/commonMain/composeResources/files/my_page.html`
 - Load it:
 
 ```kotlin
@@ -195,7 +202,7 @@ import io.github.kdroidfilter.webview.web.WebViewFileReadType
 navigator.loadHtmlFile("my_page.html", WebViewFileReadType.ASSET_RESOURCES)
 ```
 
-The demo includes `demo/src/jvmMain/resources/assets/bridge_playground.html` (JS bridge playground).
+The demo includes `demo-shared/src/commonMain/composeResources/files/bridge_playground.html` (JS bridge playground).
 
 ### RequestInterceptor (pre-navigation)
 

build.gradle.kts

@@ -1,6 +1,8 @@
 plugins {
     // this is necessary to avoid the plugins to be loaded multiple times
     // in each subproject's classloader
+    alias(libs.plugins.androidApplication) apply false
+    alias(libs.plugins.androidLibrary) apply false
     alias(libs.plugins.composeHotReload) apply false
     alias(libs.plugins.composeMultiplatform) apply false
     alias(libs.plugins.composeCompiler) apply false

demo-android/build.gradle.kts

@@ -0,0 +1,53 @@
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.composeMultiplatform)
+    alias(libs.plugins.composeCompiler)
+    alias(libs.plugins.androidApplication)
+}
+
+kotlin {
+    androidTarget()
+
+    sourceSets {
+        androidMain.dependencies {
+            implementation(libs.androidx.activity.compose)
+            implementation(libs.google.material)
+            implementation(compose.material3)
+            implementation(project(":demo-shared"))
+        }
+    }
+}
+
+android {
+    namespace = "io.github.kdroidfilter.webview.demo.android"
+    compileSdk = 35
+
+    sourceSets["main"].manifest.srcFile("src/androidMain/AndroidManifest.xml")
+
+    defaultConfig {
+        applicationId = "io.github.kdroidfilter.webview.demo"
+        minSdk = 23
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlin {
+        jvmToolchain(17)
+    }
+
+    // Lint is unstable with this KMP + AGP setup in CI.
+    lint {
+        abortOnError = false
+        checkReleaseBuilds = false
+    }
+}
+
+tasks.matching { it.name.startsWith("lint") }.configureEach {
+    enabled = false
+}

demo-android/src/androidMain/AndroidManifest.xml

@@ -0,0 +1,16 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+        android:label="ComposeWebView"
+        android:theme="@style/Theme.ComposeWebViewDemo">
+        <activity
+            android:name="io.github.kdroidfilter.webview.demo.MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

demo-android/src/androidMain/kotlin/io/github/kdroidfilter/webview/demo/MainActivity.kt

@@ -0,0 +1,14 @@
+package io.github.kdroidfilter.webview.demo
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            App()
+        }
+    }
+}

demo-android/src/androidMain/res/values/themes.xml

@@ -0,0 +1,3 @@
+<resources>
+    <style name="Theme.ComposeWebViewDemo" parent="Theme.Material3.DayNight.NoActionBar" />
+</resources>

demo-shared/build.gradle.kts

@@ -0,0 +1,81 @@
+plugins {
+    alias(libs.plugins.androidLibrary)
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.composeMultiplatform)
+    alias(libs.plugins.composeCompiler)
+}
+
+kotlin {
+    applyDefaultHierarchyTemplate()
+
+    androidTarget()
+    jvm()
+
+    val isMacHost = System.getProperty("os.name")?.contains("Mac", ignoreCase = true) == true
+    if (isMacHost) {
+        listOf(
+            iosX64(),
+            iosArm64(),
+            iosSimulatorArm64(),
+        ).forEach { iosTarget ->
+            iosTarget.binaries.framework {
+                baseName = "demoShared"
+                isStatic = true
+            }
+        }
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(compose.runtime)
+            implementation(compose.foundation)
+            implementation(compose.material3)
+            implementation(compose.materialIconsExtended)
+            implementation(compose.ui)
+            implementation(compose.components.resources)
+            implementation(compose.components.uiToolingPreview)
+            implementation(libs.androidx.lifecycle.viewmodelCompose)
+            implementation(libs.androidx.lifecycle.runtimeCompose)
+            implementation(libs.kotlinx.coroutinesCore)
+            implementation(libs.kotlinx.serializationJson)
+
+            implementation(project(":wrywebview-compose"))
+        }
+
+        jvmMain.dependencies {
+            implementation(compose.desktop.common)
+        }
+
+        if (isMacHost) {
+            iosMain.dependencies { }
+        }
+    }
+}
+
+android {
+    namespace = "io.github.kdroidfilter.webview.demo.shared"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 23
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlin {
+        jvmToolchain(17)
+    }
+
+    // Lint is unstable with this KMP + AGP setup in CI.
+    lint {
+        abortOnError = false
+        checkReleaseBuilds = false
+    }
+}
+
+tasks.matching { it.name.startsWith("lint") }.configureEach {
+    enabled = false
+}

demo-shared/src/androidMain/kotlin/io/github/kdroidfilter/webview/demo/DemoUtils.android.kt

@@ -0,0 +1,16 @@
+package io.github.kdroidfilter.webview.demo
+
+import java.time.LocalTime
+
+internal actual fun nowTimestamp(): String {
+    val time = LocalTime.now()
+    return buildString {
+        append(time.hour.twoDigits())
+        append(':')
+        append(time.minute.twoDigits())
+        append(':')
+        append(time.second.twoDigits())
+        append('.')
+        append((time.nano / 1_000_000).threeDigits())
+    }
+}

demo-shared/src/androidMain/kotlin/io/github/kdroidfilter/webview/demo/PlatformInfo.android.kt

@@ -0,0 +1,11 @@
+package io.github.kdroidfilter.webview.demo
+
+import android.os.Build
+
+internal actual fun platformInfoJson(): String {
+    val device = Build.MODEL.orEmpty()
+    val brand = Build.BRAND.orEmpty()
+    val sdk = Build.VERSION.SDK_INT.toString()
+    val release = Build.VERSION.RELEASE.orEmpty()
+    return """{"platform":"android","brand":"$brand","device":"$device","sdk":$sdk,"osVersion":"$release"}"""
+}